El estilo de programación

Para tener un buen estilo de programación, se deben considerar los siguientes puntos:

Comentarios
Variables
Identación
Claridad
Simpleza

Comentarios

Una buena y recomendable práctica es siempre comentar los programas. Un error común es pensar: para quÈ comento mis programas si yo mismo soy el que los escribo. Primero que nada, el código que parece obvio al programador al tiempo que lo escribe, es confuso y poco entendible cuando lo vuelve a revisar una semana después.

Un buen estilo de programación nos ayudará a crear programas de buena calidad; es lo que diferencía las joyas de la basura.

Contrario a lo que se podría creer, el programador no invierte mucho tiempo escribiendo programas. La mayor parte del tiempo es invertido en el mantenimiento, mejora y corrección del programa. En una encuesta realizada en 1990 en el Encuentro y Conferencia Anual de la Asociación de Mantenimiento de Software, el 74% de los gerentes de proyecto dijeron que ellos tenían sistemas en sus departamentos que tenían que ser revisados por personas específicas, ya que nadie más les entendía.

Algunos programadores creen que el propósito de un programa es sólamente presentar a la computadora un compacto set de instrucciones. Este concepto es falso. Los programas escritos sólo para las computadoras tienen dos problemas:

Un programa que funciona pero que carece de comentarios es una especie de bomba de tiempo esperando para explotar. Tarde o temprano alguien tendrá que arreglar algún error, modificar o actualizar el programa y si el código no tiene comentarios será un trabajo muy difícil.

Ejemplo:

/****************************************************
* Hello - programa que imprime "Hello World".       *
* Un programa muy sencillo                          *
*                                                   *
* Autor: Andrés Tortolero                           *
*                                                   *
* Propósito: Demostración de un programa muy simple *
*                                                   *
* Uso:                                              *
* Correr el programa y el mensaje aparece           *
*****************************************************/

#include <stdio.h>
int main(void)
{
   /*Dice al mundo Hola */
   printf("Hello world\n");
}

En el ejemplo anterior, pusimos al principio del código comentarios en una caja de asteriscos (*). Dicho formato se utiliza para enfatizar los comentarios más importantes, de la misma manera en la que se utilizan las letras en negritas en un libro. Los comentarios menos importantes se pueden escribir en una sola línea: 

/*Dice al mundo Hola */
printf("Hello world\n");

Para poder escribir un programa se debe tener una idea clara de qué es lo que se va a hacer. Una de las mejores maneras de organizar el pensamiento es escribir en lenguaje común (pseudocódigo) lo que se quiere hacer. Después de dicho proceso, podemos fácilmente traducir lo escrito a un lenguaje de computadora, cualquiera que éste sea.

La parte más importante de la programación es entender qué es lo que se está haciendo y lo que nos ayuda a hacerlo es poner comentarios en el código.

En el principio de un programa, es decir, en el encabezado, se suele poner una caja de comentarios, la cual contiene información acerca del programa. Al encerrar los comentarios en una caja, hacemos que resalten. A continuación se enuncian una serie de indicaciones de qué es lo que comúnmente se acostumbra poner en los comentarios iniciales de un programa:

A continuación se enlistan diferentes tipos para remarcar comentarios en un programa:

/*******************************************************
********************************************************
******** WARNING: Este es un ejemplo de un       *******
******** mensaje de alerta que llama la          *******
******** atención del programador.               *******
********************************************************/


/*------ Otro mensaje de alerta de menos importancia ------*/


/* >>>>>>>> Encabezado de principio de sección <<<<<<<<<<< */


/*******************************************************
* Podemos utilizar comentarios encerrados en una caja  *
* para empezar una sección en el pograma               *
*******************************************************/


/*----------------------------------------------------*\
*                                                      *
*    Esta es otra manera de escribir cajas             *
*                                                      *
\*----------------------------------------------------*/


/*
* Este es el principio de una sección.
* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
*
* En este párrafo, podemos explicar qué
* es lo que hace la sección y cómo lo hace.
*/


/*
* Un comentario de medio nivel explicando la siguiente docena
* o más de líneas de código. Aunque no podemos utilizar
* negritas, podemos **enfatizar** las palabras.
*/


/* Un comentario simple explicando la siguiente línea */

Una función debe comenzar con un bloque de comentarios el cual contenga lo siguiente:

Adicionalmente, se deben incluir comentarios en la declaración de las variables locales de la función, en las secciones que compongan a la función, etc.

Por ejemplo, supongamos que estamos desarrollando una función para obtener el área de un triángulo, los comentarios en el encabezado de dicha función serían:

/******************************************************
*  Area - Obtiene el área de un triángulo             *
*  Parámetros:                                        *
*    int base - Base del triángulo                    *
*    int altura - Altura del triángulo                *
*                                                     *
*  Valor de retorno:                                  *
*    float area_tr área del triángulo                 *
*                                                     *
*******************************************************/

Variables

Una variable es algún lugar en la memoria de la computadora en el cual se guarda un valor. C identifica dicho lugar por medio del nombre de la variable. Como ya se sabe, los nombres pueden ser de una longitud máxima de 32 caracteres para ANSI C. Cada variable en C debe ser declarada antes de ser utilizada y antes de empezar cualquier instrucción. La siguiente declaración le dice a C que vamos a utilizar tres variables enteras p, q y r:

int p, q, r;

Pero para qué son dichas variables. Cualquier persona que revise el programa no tendrá idea. Podrían representar la velocidad de un automóvil, el número de cuenta de un usuario o los lados de un polígono. Como buena práctica, es recomendable evitar abreviaciones en el nombre de las variables. Ahora consideremos la siguiente declaración:

int num_cuenta;      /* Indice para la tabla de cuentas */

int balance        /* Total en la cuenta del usuario */

Al poner un comentario después de cada declaración, así como un nombre significativo a nuestras variables, podemos crear una especie de mini-diccionario en donde definimos el significado de cada variable utilizada en nuestro programa.

Otro aspecto importante que hay que considerar es que siempre debemos desarrollar las instrucciones de nuestros programas lo más claro posible.

Consideremos el siguiente código:

   while (ë\ní != (*p++ = *q++));

Es casi imposible para un programador decir a primera vista qué es lo que se está haciendo, por el contrario, si reescribimos el código anterior de la siguiente manera:

while(1){
   *destination_ptr = *source_ptr;

   if(*destination_ptr == ë\ní)
      break; /* Sale del ciclo al encontrar final de línea */

   destination_ptr++;
   source_ptr++;
}

Aunque la versión anterior es más larga, es mucho más fácil de leer y de entender.

Identación

Otro aspecto importante para hacer un código fácil de leer y de entender es la identación. La regla general de C es identar un nivel por cada nuevo bloque o condicional. El espacio para la identación se deja al criterio del programador; dos, cuatro u ocho espacios son comunes. Los estudios dicen que cuatro espacios hacen más legible el código. Algunos editores de texto, como emacs, realizan la identación de manera automática al mismo tiempo en que se está escribiendo el código.

Claridad

Un programa se debe poder leer como cualquier ficha técnica. Debe estar organizado en secciones y párrafos. Las funciones forman un límite natural de una sección. El código debe estar organizado en párrafos, de tal manera que sea fácil de leer. Se debe comenzar un párrafo con un comentario indicando qué es lo que se hace a continuación en el programa, separando el comentario de las demás líneas con una línea en blanco. Por ejemplo:

/* Pobre práctica de programación */

temp = box_x1;
box_x1 = box_x2;
box_x2 = temp;
temp = box_y1;
box_y1 = box_y2;
box_y2 = temp;

Una mejor versión sería:

/*
* Intercambia las dos esquinas
*/

/* Intercambia las coordenadas X */
temp = box_x1;
box_x1 = box_x2;
box_x2 = temp;

/* Intercambia las coordenadas Y */
temp = box_y1;
box_y1 = box_y2;
box_y2 = temp;

Simpleza

Un programa debe ser simple. Algunas reglas generales para conservar la simpleza son:

  • Una función no debe ser mayor de dos o tres páginas. Si la función se vuelve mayor, probablemente se puede dividir en dos o más funciones.

  • Evitar lógica compleja, como múltiples ifís anidados, ya que mientras más ifís existan, más identación se tendrá que hacer.

  • Evitar instrucciones muy largas en una sola línea, como ecuaciones y comparaciones lógicas.

  • Finalmente, hacer programas tan simples y fáciles de entender como sea posible.