Esta es prácticamente la única regla de formato de código que he encontrado que realmente tiene un impacto notable en la legibilidad y casi no requiere esfuerzo (suponiendo que el editor de código no comience una pelea con usted por eso).
Es un buen diseño de lenguaje de programación que los nombres aparezcan en una posición coherente en las declaraciones / definiciones. El razonamiento es sencillo: tiene un buen ancla visual (una abrazadera rizada o simplemente una hendidura colgante) que puede usar para encontrar inmediatamente el inicio del nombre. No tiene que analizar realmente el idioma al escanear un archivo para encontrar el nombre.
Es lo mismo que cuando está formateando un documento: cuando comienza una nueva sección, pone el nombre en negrita, a menudo en su propia línea, sin enterrar en ninguna parte, sin diferenciar, en una oración larga.
Early C tenía firmas muy concisas: los tipos de retorno eran opcionales y los tipos de argumento se declararon después de la firma. Los nombres también tienden a ser muy cortos. Esto mitigó el impacto de tener un tipo de retorno ocasional que compensa el nombre.
double dot(x, y);
Todavía es bastante digerible.
C ++ hizo esto un poco peor. Movió las especificaciones de tipo de argumento a las firmas haciendo que las firmas sean más largas. Esta sintaxis se adoptó posteriormente durante la estandarización de C.
static struct origin *find_origin(struct scoreboard *sb,
struct commit *parent,
struct origin *origin)
es menos digerible, pero no demasiado malo. (Extracto de Git)
Ahora considere prácticas de programación modernas con nombres largos y descriptivos y tipos parametrizados y vea cómo esta elección se ha vuelto desastrosa. Un ejemplo de un encabezado Boost:
template <class A1, class A2, class A3, class A4, class A5, class A6>
inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&)
{
typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6>::type result_type;
return result_type();
}
Si está escribiendo un código genérico, las firmas como esa no están fuera de lo común. Puede encontrar ejemplos de casos mucho peores que esto sin esforzarse demasiado.
C, C ++ y sus derivados, Java y C #, parecen ser las excepciones a tener declaraciones / definiciones legibles. Sus populares predecesores y compañeros (Fortran, ALGOL, Pascal) colocaron nombres antes que los tipos de resultados y, afortunadamente, muchos de sus sucesores (Go, Scala, TypeScript y Swift, por nombrar algunos) también han elegido sintaxis más legibles.