Cooff, </div> Cooff, perdón…

Este es el problema de levantarse temprano en domingo.

Bueno, a lo que iba, después de aprender cositas de PHP, javascript, DOM, CSS, XHTML, AJAX, etc. y una vez me voy haciendo una idea de como funciona el tema, están llegando las cosas interesantes. Acabo de echarle un ojo a jQuery, prototype y Moo Tools, viendo un poco la página principal trantando de decidir a qué documentación le meto mano y me ha sorprendido de nuevo lo que se puede conseguir en la web hoy día.

Merece la pena echar un ojo a la de monerías que hay ahí fuera (y mientras nosotros no hacemos más que mirar el facebook como tontos…. Y me ha llamado especialmente la atención APE. APE es una API  para construir aplicaciones web con recepción y puclicación de datos en tiempo real. Es decir, con APE puedes hacer un MMO en tiempo real en el browser todo basado en javascript, sin instalar nada en el cliente. Menús animados, botones, previews, diapositivas, todas esas monadas de la web actual están ahí esperando ser usadas

Viendo todas estas APIs me siento como un niño pequeño con juguetes nuevos. Pero ¿Cuál elegiré para empezar? ¿Vosotros conocéis y utilizáis alguna? ¿Qué podéis recomendarme?

Y para eso recomiendo encarecidamente este enlace: Application Model Overview. En él se explica brevemente la estructura básica de un juego y algunos datos sobre la velocidad de actualización y demás… Al final de la página viene un enlace a cómo hacer el primer proyecto. Así comenzaremos desde cero, sabremos lo que estamos haciendo y no nos despistaremos con 3D, físicas y otras cosas divertidísimas de los engines y ejemplos, pero que nos pierden y no nos enseñan realmente a hacer un juego desde cero o a entender las bases de XNA.

Otro día contaré algo más, como por qué elegir XNA o como van mis avances ^^.

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

Una herramienta de gran utilidad tanto para curiosear y aprender de nuestras páginas favoritas como para validar y testear la propia Se llama Web Developer y podéis encontrarla AQUÍ.