Mejora de Nombres y Comunicación de Intenciones

1
2
3
4
5
6
7
8
9
// Problemático: nombres sin significado claro
int d;         // ¿días? ¿dinero? ¿distancia?
int tmp;       // temporal... ¿para qué?
int x, y;      // ¿coordenadas? ¿variables matemáticas?
char buf[256]; // ¿buffer de qué?
void proc(int n)
{ // ¿procesar qué?
  // ...
}

1
2
3
4
5
6
// Problemático: nombres que no reflejan el contenido real
int dias_del_mes;            // Contiene el número del mes, no los días
char *get_usuario();         // Retorna NULL si no existe, no "obtiene"
bool validar_email(char *e); // Solo verifica formato, no valida existencia
// Array que NO contiene elementos de ese tipo
usuario_t usuarios_activos[100]; // Puede tener usuarios inactivos

1
2
3
4
5
6
7
8
9
10
11
// Problemático: diferentes convenciones mezcladas
int obtener_edad();
int getAltura();
int fetch_peso();
int edad_recuperar();
typedef struct
{
    int ID;          // Mayúsculas
    char *nombre;    // minúsculas
    int EdadPersona; // PascalCase
} usuario_t;

1
2
3
4
5
6
7
8
9
10
11
// Problemático: nombres demasiado genéricos
void procesar(void *datos);
int calcular(int a, int b);
char *obtener_valor();
bool es_valido();
typedef struct
{
    int valor;
    char *dato;
    void *info;
} elemento_t;

1
2
3
4
5
6
7
8
// Problemático: notación húngara o prefijos de tipo
int iContador;
char *strNombre;
bool bActivo;
float fPrecio;
// Redundante
char nombre_string[50];
int edad_entero;

1
2
3
4
5
6
7
8
// Problemático: choca con palabras clave y tipos estándar
int free;        // función de <stdlib.h>
int malloc;      // función de <stdlib.h>
struct open {};  // nombre de función estándar
// Problemático: prefijos reservados al compilador
int _contador;
int __interno;
double __atributo_x;

1
2
3
4
5
// Problemático: las constantes no siguen una única convención
#define maxItems 100
#define TIMEOUT 30
const double tasa_iva = 0.21;
const int MAX_CONEXIONES = 5;

int d;       // días transcurridos
int elapsed; // mejor, pero ¿elapsed desde cuándo?

int dias_desde_ultima_modificacion;
int tiempo_transcurrido_en_milisegundos;

1
2
3
4
5
6
// Engañoso: no es una lista
usuario_t lista_usuarios[100];
// Engañoso: puede retornar NULL
usuario_t *get_usuario_by_id(int id);
// Confuso: ¿incluye o excluye el IVA?
double calcular_precio(double base);

1
2
3
4
5
6
7
usuario_t usuarios[100];
int cantidad_usuarios;
// Retorna NULL si no encuentra
usuario_t *buscar_usuario_por_id(int id);
// Explícito sobre lo que incluye
double calcular_precio_sin_iva(double base);
double calcular_precio_con_iva(double base);

1
2
3
4
5
6
7
8
9
10
void copiar_cadena(char *a1, char *a2);
void procesar_datos1(int *datos);
void procesar_datos2(int *datos);
void procesar_datos_final(int *datos);
typedef struct
{
    char *info;
    char *data;
    char *contenido;
} registro_t;

1
2
3
4
5
6
7
8
9
10
void copiar_cadena(const char *origen, char *destino);
void validar_datos(int *datos);
void transformar_datos(int *datos);
void guardar_datos(int *datos);
typedef struct
{
    char *titulo;
    char *descripcion;
    char *cuerpo;
} documento_t;

1
2
3
4
5
6
7
struct usrmgr
{
    int nusrs;
    char *usrnm[100];
    int usrsts;
};
int gnymdhms(void); // generation year, month, day, hour, minute, second

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
typedef struct
{
    int cantidad_usuarios;
    char *nombres_usuario[100];
    int estado_usuarios;
} gestor_usuarios_t;
typedef struct
{
    int anio;
    int mes;
    int dia;
    int hora;
    int minuto;
    int segundo;
} marca_temporal_t;
marca_temporal_t obtener_marca_temporal_actual(void);

1
2
3
4
5
6
7
8
9
10
// Difícil de buscar
for (int i = 0; i < 7; i++)
{
    double s = 0;
    for (int j = 0; j < n; j++)
    {
        s += a[j] * b[i];
    }
    r[i] = s;
}

1
2
3
4
5
6
7
8
9
10
11
const int DIAS_SEMANA = 7;
for (int dia = 0; dia < DIAS_SEMANA; dia++)
{
    double suma_diaria = 0;
    for (int transaccion = 0; transaccion < cantidad_transacciones;
         transaccion++)
    {
        suma_diaria += montos[transaccion] * factores[dia];
    }
    resultados[dia] = suma_diaria;
}

1
2
3
4
5
6
7
8
int iEdad;
char *strNombre;
bool bActivo;
float fPrecio;
struct user_struct
{
    int iId;
};

1
2
3
4
5
6
7
8
int edad;
char *nombre;
bool activo;
float precio;
typedef struct
{
    int id;
} usuario_t;

1
2
3
4
5
6
7
8
9
10
11
12
typedef struct
{
    // ...
} procesar_t;
typedef struct
{
    // ...
} manager_t;
typedef struct
{
    // ...
} data_t;

1
2
3
4
5
6
7
8
9
10
11
12
typedef struct
{
    // ...
} procesador_pedidos_t;
typedef struct
{
    // ...
} gestor_usuarios_t;
typedef struct
{
    // ...
} configuracion_sistema_t;

int cuenta();
void nombre(char *n);
bool estado();

int contar_elementos();
void establecer_nombre(const char *nombre);
bool esta_activo();

1
2
3
4
5
6
7
8
void calcular()
{
    int n = obtener_cantidad();
    double p = obtener_precio();
    double d = 0.15;
    double r = n * p * (1 - d);
    printf("Total: %.2f\n", r);
}

1
2
3
4
5
6
7
8
9
void calcular_total_con_descuento()
{
    int cantidad_items = obtener_cantidad();
    double precio_unitario = obtener_precio();
    const double DESCUENTO_MAYORISTA = 0.15;
    double total =
        cantidad_items * precio_unitario * (1 - DESCUENTO_MAYORISTA);
    printf("Total: %.2f\n", total);
}

1
2
3
4
5
6
7
8
9
10
11
12
bool chequear(usuario_t *u)
{
    return u->edad >= 18 && !u->bloqueado;
}
void hacer(pedido_t *p)
{
    // procesar pago y envío
}
int get(int id)
{
    // busca y retorna
}

1
2
3
4
5
6
7
8
9
10
11
12
13
bool puede_realizar_compra(const usuario_t *usuario)
{
    return usuario->edad >= 18 && !usuario->bloqueado;
}
void procesar_pedido_completo(pedido_t *pedido)
{
    procesar_pago(pedido);
    iniciar_envio(pedido);
}
int buscar_indice_por_id(int id)
{
    // busca y retorna índice, -1 si no encuentra
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
typedef struct
{
    char *calle;
    char *numero;
    char *ciudad;
    char *provincia;
    char *codigo_postal;
} direccion_t;
typedef struct
{
    char *nombre;
    direccion_t direccion;
    // Redundante con el contexto
    char *direccion_calle;
    char *direccion_numero;
} cliente_t;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
typedef struct
{
    char *calle;
    char *numero;
    char *ciudad;
    char *provincia;
    char *codigo_postal;
} direccion_t;
typedef struct
{
    char *nombre;
    direccion_t domicilio; // Evita redundancia
} cliente_t;
// Uso
printf("Calle: %s\n", cliente.domicilio.calle); // Claro por contexto

usuario_t *obtener_usuario(int id);
producto_t *fetch_producto(int id);
pedido_t *recuperar_pedido(int id);
factura_t *get_factura(int id);

1
2
3
4
5
6
7
8
9
usuario_t *buscar_usuario(int id);
producto_t *buscar_producto(int id);
pedido_t *buscar_pedido(int id);
factura_t *buscar_factura(int id);
// O usando un patrón diferente pero consistente:
usuario_t *obtener_usuario_por_id(int id);
producto_t *obtener_producto_por_id(int id);
pedido_t *obtener_pedido_por_id(int id);
factura_t *obtener_factura_por_id(int id);

1
2
3
4
5
6
7
8
9
10
11
12
void imprimir_direccion()
{
    char *calle;
    char *numero;
    char *ciudad;
    // ... código
    printf("%s %s, %s\n", calle, numero, ciudad);
}
// En otro lugar
char *calle;  // ¿De qué?
char *numero; // ¿De qué?
char *ciudad; // ¿De qué?

1
2
3
4
5
6
7
8
9
10
11
12
13
typedef struct
{
    char *calle;
    char *numero;
    char *ciudad;
    char *provincia;
    char *codigo_postal;
} direccion_t;
void imprimir_direccion(const direccion_t *direccion)
{
    printf("%s %s, %s\n", direccion->calle, direccion->numero,
           direccion->ciudad);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
typedef struct
{
    int id;
    char *n;
    int q;
    float p;
    int min;
    int max;
    char *cat;
} item_t;
int chk(item_t *i)
{
    return i->q >= i->min;
}
void upd(item_t *i, int cant)
{
    i->q += cant;
}
int proc(item_t *items, int n)
{
    int c = 0;
    for (int i = 0; i < n; i++)
    {
        if (!chk(&items[i]))
        {
            c++;
        }
    }
    return c;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
typedef struct
{
    int codigo_producto;
    char *nombre;
    int cantidad_en_stock;
    float precio_unitario;
    int stock_minimo;
    int stock_maximo;
    char *categoria;
} producto_t;
bool tiene_stock_suficiente(const producto_t *producto)
{
    return producto->cantidad_en_stock >= producto->stock_minimo;
}
void actualizar_stock(producto_t *producto, int cantidad_a_agregar)
{
    producto->cantidad_en_stock += cantidad_a_agregar;
}
int contar_productos_con_stock_bajo(const producto_t *productos,
                                    int cantidad_productos)
{
    int productos_con_stock_bajo = 0;
    for (int i = 0; i < cantidad_productos; i++)
    {
        if (!tiene_stock_suficiente(&productos[i]))
        {
            productos_con_stock_bajo++;
        }
    }
    return productos_con_stock_bajo;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
typedef struct
{
    double v;
    long t;
    int s;
} reading_t;
double calc(reading_t *r, int n)
{
    double sum = 0;
    int cnt = 0;
    for (int i = 0; i < n; i++)
    {
        if (r[i].s == 1)
        {
            sum += r[i].v;
            cnt++;
        }
    }
    return cnt > 0 ? sum / cnt : 0;
}
bool val(reading_t *r)
{
    return r->v >= 0 && r->v <= 100 && r->s == 1;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
typedef enum
{
    SENSOR_ERROR = 0,
    SENSOR_OK = 1,
    SENSOR_ADVERTENCIA = 2
} estado_sensor_t;
typedef struct
{
    double temperatura_celsius;
    long marca_temporal_unix;
    estado_sensor_t estado;
} lectura_sensor_t;
double calcular_temperatura_promedio(const lectura_sensor_t *lecturas,
                                     int cantidad_lecturas)
{
    double suma_temperaturas = 0;
    int lecturas_validas = 0;
    for (int i = 0; i < cantidad_lecturas; i++)
    {
        if (lecturas[i].estado == SENSOR_OK)
        {
            suma_temperaturas += lecturas[i].temperatura_celsius;
            lecturas_validas++;
        }
    }
    return (lecturas_validas > 0) ? suma_temperaturas / lecturas_validas : 0;
}
bool es_lectura_valida(const lectura_sensor_t *lectura)
{
    const double TEMPERATURA_MINIMA = 0.0;
    const double TEMPERATURA_MAXIMA = 100.0;
    return lectura->temperatura_celsius >= TEMPERATURA_MINIMA &&
           lectura->temperatura_celsius <= TEMPERATURA_MAXIMA &&
           lectura->estado == SENSOR_OK;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
typedef struct
{
    char *u;
    char *p;
    int a;
    long lt;
    int fc;
} usr_t;
int auth(usr_t *u, char *p)
{
    if (u->fc >= 3)
    {
        return -2;
    }
    if (strcmp(u->p, p) == 0)
    {
        u->fc = 0;
        u->lt = time(NULL);
        return 0;
    }
    u->fc++;
    return -1;
}
bool chk_t(usr_t *u)
{
    long now = time(NULL);
    return (now - u->lt) < 3600;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
typedef struct
{
    char *nombre_usuario;
    char *hash_password;
    bool activo;
    time_t ultimo_acceso;
    int intentos_fallidos;
} usuario_t;
typedef enum
{
    AUTH_EXITO = 0,
    AUTH_PASSWORD_INCORRECTO = -1,
    AUTH_CUENTA_BLOQUEADA = -2,
    AUTH_USUARIO_INACTIVO = -3
} resultado_autenticacion_t;
resultado_autenticacion_t autenticar_usuario(usuario_t *usuario,
                                             const char *password)
{
    const int MAX_INTENTOS_FALLIDOS = 3;
    if (!usuario->activo)
    {
        return AUTH_USUARIO_INACTIVO;
    }
    if (usuario->intentos_fallidos >= MAX_INTENTOS_FALLIDOS)
    {
        return AUTH_CUENTA_BLOQUEADA;
    }
    if (strcmp(usuario->hash_password, password) == 0)
    {
        usuario->intentos_fallidos = 0;
        usuario->ultimo_acceso = time(NULL);
        return AUTH_EXITO;
    }
    usuario->intentos_fallidos++;
    return AUTH_PASSWORD_INCORRECTO;
}
bool sesion_esta_vigente(const usuario_t *usuario)
{
    const long DURACION_SESION_SEGUNDOS = 3600; // 1 hora
    time_t tiempo_actual = time(NULL);
    time_t tiempo_transcurrido = tiempo_actual - usuario->ultimo_acceso;
    return tiempo_transcurrido < DURACION_SESION_SEGUNDOS;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Acciones
void crear_usuario();
void eliminar_producto();
void actualizar_stock();
void guardar_en_archivo();
// Consultas
int obtener_cantidad();
char *leer_linea();
double calcular_total();
// Predicados (retornan bool)
bool es_valido();
bool tiene_permiso();
bool esta_vacio();
bool puede_procesar();

1
2
3
4
5
6
7
8
9
10
11
12
// Buenos nombres de variables
int edad_usuario;
double precio_total;
char *nombre_completo;
bool esta_activo;
// Contadores y acumuladores
int cantidad_elementos;
int total_procesados;
double suma_acumulada;
// Índices y posiciones
int indice_actual;
int posicion_cursor;

const int MAX_USUARIOS = 100;
const double TASA_IVA = 0.21;
const char *RUTA_CONFIGURACION = "/etc/app/config.ini";
const int TIMEOUT_CONEXION_SEGUNDOS = 30;

1
2
3
4
5
6
7
8
9
10
11
typedef struct
{
    // ...
} usuario_t;
typedef enum
{
    ESTADO_ACTIVO,
    ESTADO_INACTIVO,
    ESTADO_BLOQUEADO
} estado_usuario_t;
typedef int (*funcion_comparacion_t)(const void *, const void *);

int obtener_edad(const usuario_t *usuario);
void establecer_edad(usuario_t *usuario, int edad);
char *obtener_nombre(const usuario_t *usuario);
void establecer_nombre(usuario_t *usuario, const char *nombre);

usuario_t *crear_usuario(const char *nombre);
void destruir_usuario(usuario_t *usuario);
lista_t *crear_lista(void);
void destruir_lista(lista_t *lista);

archivo_t *abrir_archivo(const char *ruta);
void cerrar_archivo(archivo_t *archivo);
conexion_t *abrir_conexion(const char *host);
void cerrar_conexion(conexion_t *conexion);

void iniciar_transaccion(void);
void finalizar_transaccion(void);
void comenzar_procesamiento(void);
void terminar_procesamiento(void);

1
2
3
4
5
6
7
8
9
// Problemático: palabras que no agregan información
int the_numero;
char *a_nombre;
void do_proceso();
typedef struct
{
    int dato_numero;
    char *info_cadena;
} objeto_data_t;

// Problemático: demasiado similar, fácil confundir
void procesar_cliente_activo();
void procesar_clientes_activos();
usuario_t usuario;
usuario_t usuarios; // Plural solo difiere en 's'

1
2
3
4
5
6
7
8
// Problemático en diferentes archivos
// archivo1.c
int contador; // Cuenta usuarios
// archivo2.c
int contador; // Cuenta productos
// Mejor: específico
int contador_usuarios;
int contador_productos;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#define maxUsers 50
int userCount; // global sin static ni prefijo g_

typedef struct
{
    int idUsuario;      // camelCase en campo
    char *nombreCompleto;
    int __estado;       // prefijo reservado y nombre opaco
    int añoAlta;        // carácter no ASCII
} User;                 // sin typedef ni sufijo _t

int CheckUser(User u, int idx) // PascalCase y parámetros pobres
{
    if (!u.__estado)           // doble negación
    {
        return 0;
    }
    return 1;
}

void ProcessAll(User users[], int n)
{
    int i;
    for (i = 0; i < n; i++)
    {
        if (CheckUser(users[i], i))
        {
            printf("%d\n", users[i].idUsuario);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#define MAX_USUARIOS 50

static int g_usuarios_activos;

typedef struct
{
    int id_usuario;
    char *nombre_completo;
    bool esta_activo;
    int anio_alta;
} usuario_t;

bool usuario_esta_activo(const usuario_t *usuario)
{
    return usuario->esta_activo;
}

void procesar_usuarios(const usuario_t *usuarios, int cantidad_usuarios)
{
    for (int indice = 0; indice < cantidad_usuarios; indice++)
    {
        if (usuario_esta_activo(&usuarios[indice]))
        {
            printf("%d\n", usuarios[indice].id_usuario);
        }
    }
}