PorAmorAlCódigo

Cuando trabajas en un grupo de desarrollo en un proyecto largo te empiezas a dar cuenta de algunas cosas. Recuerdas esas clases en las que los profesores te decían que era importante documentar el código. Te acuerdas de sus consejos sobre mantener el código ordenado y utilizar nombres de variables legibles. Y con más frecuencia de la que quisieras, te acuerdas de la madre de Mengano.

El otro día leí una máxima para programadores que me encantó:

Write your code as if the next guy to maintain it is a homicidal maniac who knows where you live

(by Kathy Sierra and Bert Bates)

Me parece un gran consejo y es que parece que nadie piensa jamas que la documentación y el código correcto sea una prioridad. Hasta que le toca a él mantener el código de otro.

Como ejemplo veremos una pequeña porción de código. Es un algoritmo que me encanta y que ilustra muy bien lo que quiero decir:

void quicksort(int array[M], int in, int f){
	int pv, i, j, m;
	bool hc;

	if(in < f){
		pv = array[in];
		i = in+1;
		j = f;
		hc= true;
		while(hc){
			while((array[i] >= pv)&&(i < f )) i++;
			while((array[j] < pv)&&(j > im)) j–-;

			if(i < j) interc(array[i], array[j]);
			else hc= false;
		}         

		if(array[j][0] > pv) interc(array[j], array[in])

		quicksort(array, in, j-1);
		quicksort(array, j+1, f);
	}
}

Eso de ahí arriba es el Quick Sort. Desde luego no se entiende nada. No hay comentarios, las variables estan nombradas con una o dos letras, está pobremente sangrado… En definitiva, e programador no se molestó mas que en que funcionara, cuanto tenga que corregir errores o cuando alguien tenga que analizar éste código su madre será recordada junto a esquinas y callejones oscuros… Sin embargo, esto puede evitarse, este código puede mejorarse de forma que todo el mundo entienda qué es lo que el programador quería hacer:

/* Quicksort: El algoritmo quicksort consiste en ordenar
un array mediante recursividad. Esta versión del algoritmo toma como pivote el dato en la
primera posición del array y luego lo coloca en su sitio.
Argumentos:
int individuos[M] -> el array a ordenar
int inicio -> primera posición de la parte del array a ordenar
int fin -> última posición de la parte del array a ordenar */
void quicksort(int individuos[M], int inicio, int fin){
	int pivote, i, j, mitad;
	bool hayCambio;

	//caso base: si inicio>=fin hemos terminado con esta sección, no hacemos nada
	if(inicio < fin){
		pivote = individuos[inicio];
		i = inicio+1;
		j = fin;
		hayCambio = true;

		while(hayCambio){

                        //busca un elemento mayor que el pivote por debajo de él
			while((individuos[i] >= pivote)&&(i < fin )) i++;

                        //busca un elemento menor que el pivote por encima de él
			while((individuos[j] < pivote)&&(j > inicio)) j–-;

			if(i < j){ //intercambiamos las casillas
				intercambia(individuos[i], individuos[j]);
			}else{
				hayCambio = false;
			}
		}         

		//ponemos el pivote en su posición
		if(individuos[j][0] > pivote){
			intercambia(individuos[j], individuos[inicio])
		}

		//llamadas recursivas para las dos mitades
		quicksort(individuos, inicio, j-1);
		quicksort(individuos, j+1, fin);
	}
}

Puede que sigáis sin comprender por qué funciona el quicksort: no os preocupéis, es normal. Lo importante es que aun así, ahora habréis podido comprender que pretende hacer cada parte del código, para que sirve esta función y que significa cada variable. La diferencia creo que es bastante sustancial, pero pronto veremos más ejemplos de por qué documentar ^_^