Yo estoy totalmente de acuerdo, es necesario conocer y aprender a utilizar otras herramientas, lenguajes de programación, técnicas, APIs… Hay un mundo enorme ahí fuera que puede facilitarnos mucho la vida si buscamos un poco. Tal vez nuestro entorno de programación no sea el mejor, tal vez haya un framework o una API que hace lo que estamos programando de forma mucho más eficiente, limpia y reutilizable.

¿Alguna vez habéis pensado: “Sé hacerlo, pero voy a mirar si podría hacerlo mucho mejor o en menos tiempo de otra forma….” ?

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 ^_^