El tiempo de lectura de los programas es mucho más largo que el de escritura. Haz que la lectura sea fácil.
Regla de Programación

• Separa por una línea en blanco las declaración de variables y estructuras de datos y los instrucciones ejecutables del cuerpo mismo de la función, para enfatizar donde terminan las primeras y dónde inician las segundas.

• Inserta una línea en blanco entre el encabezado documentativo de una función y el código de la función misma.

• Inserta una línea en blanco alrededor de bloques de código importantes, tales como ciclos, sentencias if y conjuntos de instrucciones claves. La línea en blanco no debe separar la documentación del bloque del bloque mismo.

• Inserta una línea en blanco entre la última línea de una función y su delimitador de cierre.

• Deja un espacio después de cada coma, en especial en las declaraciones de tipos de datos tipo conjunto y entre las expresiones de las sentencias de control que permitan incluir más de una.

• Coloca espacios en blanco a ambos lados de un operador binario. Esto hace resaltar al operador y diferenciarlo por simple observación de sus operandos.

• Escriba una instrucción de código por línea, incluso si el compilador permite poner más de una, separadas entre sí por un símbolo especial de fin de instrucción (p. ej. el punto y coma en Pascal y C).

• La declaración de variables y estructuras de datos y el cuerpo del programa principal deben estar en el primer nivel de indentación, así como la declaración de funciones adicionales necesarias para el programa.

• El código del cuerpo del programa principal y el de sus funciones adicionales deben estar en el siguiente nivel de indentación.

• El bloque de instrucciones de las sentencias if, if/else, de los ciclos y las estructuras de selección múltiple deben estar así mismo en el siguiente nivel de indentación en el que está la instrucción a la cual se subordinan.

• Los delimitadores de funciones (p. ej. las llaves en C) deben estar en líneas independientes para denotar con claridad los límites de las mismas. Además, como se mencionó en la sección Comentarios al Código, el nombre de la función debe aparecer junto al delimitador de cierre, como un comentario de fin de línea, separado por un espacio.

• Los delimitadores de estructuras de control tales como los ciclos y las estructuras de selección simples y múltiples, deben aparecer en líneas independientes para denotar claramente los límites del bloque de código que estas intrucciones abarcan.

• Colóquense siempre delimitadores de bloques de instrucciones alrededor de las estructuras de control, incluso en el caso de que el bloque lo conforme una única instrucción. La única excepción a esta regla es en el caso de que la estructura de control posea sus propios delimitadores. Un ejemplo de esta excepción es la instrucción REPEAT de Pascal, cuyo delimitador final es la palabra reservada UNTIL seguida de una condición lógica que debe verificarse para determinar si se ha alcanzado el fin del ciclo.

• Evita las instrucciones largas. En su lugar, divídelas en varias líneas escogiendo puntos de corte que tengan sentido y aplica una tabulación a todas las líneas después de la primera.

• Limita a una sola línea los encabezados de estructuras de control, simplificando las expresiones lógicas de la condición o descomponiendo las estructuras de control en otras más simples.

• Asigna nombres significativos y autoexplicativos a tus identificadores para minimizar la documentación y aumentar la claridad del código.

• Para mayor claridad del código las variables deben declararse una por línea, con su correspodiente comentario de fin de línea para documentarla. No debe usarse el separador coma para declarar múltiples variables en una misma línea por la poca claridad que ello acarrea para su lectura. Lo anterior también se aplica para los declaraciones de campos/componentes en estructuras de datos tipo registro.

• Las declaraciones de variables y campos/componentes de estructuras de datos tipo registro deben agruparse por tipos de datos para tener una mejor organización de los elementos del programa (las de tipo entero aparte, las de tipo carácter aparte, etc.), excepto en el caso que los campos/componentes de las estructuras de datos tipo registro deban seguir un orden específico que refleje con mayor naturalidad el mundo que intentan representar.

• Haz la entrada fácil de proveer y la salida autoexplicativa.
• Usa formatos de entrada uniformes.
• Usa formatos de entrada libre (amplios) cuando sea posible.
• Usa entrada autoidentificativa. Permite valores por defecto. Muestra ambos en la salida.
• Ubica la entrada y la salida en puntos específicos en las subrutinas.

• Modulariza. Usa subrutinas.
• Reemplaza expresiones repetitivas por llamadas a una función común.
• Cada módulo debería hacer una única cosa bien.
• Asegúrate que cada módulo oculte algo.

• Evita niveles profundos de anidamiento de estructuras de control y de funciones. Más de tres niveles dificulta la comprensión de un programa.

• Elige el tipo de ciclo más apropiado.
• Evita múltiples salidas de los ciclos.

• Usa funciones de biblioteca.
• Deja a la máquina el trabajo sucio.
• Emplea paréntesis para evitar ambiguedades.
• Evita bifurcaciones innecesarias.
• No uses bifurcaciones condicionales como un sustituto de una expresión lógica.
• Usa arreglos de datos para evitar secuencias de control repetitivas.
• Elige una representación de datos que haga al programa sencillo.
• Haz el acoplamiento entre módulos visible.
• Deja que los datos estructuren el programa.
• Trata las condiciones de fin de archivo de una manera uniforme.
• Haz la entrada fácil de corregir.
• Asegúrate que todas las variables estén inicializadas antes de usarlas.
• Evita THEN-IF y los ELSE nulos.
• Evita los ELSE GOTO y los ELSE RETURN.
• Escribe claramente - no seas demasiado inteligente.
• Escribe claramente - no sacrifiques claridad por "eficiencia".

Ir al inicio de este artículo | Versión imprimible
Ir a la Página Principal de NeoProgramadores