Hay días que echo de menos los ejercicios de la facultad, los descubrimientos de algunas clases, las demostraciones ingeniosas y las soluciones inesperadas a problemas que parecían imposibles. La realidad es que esos problemas no suelen darse en el día a día. En la facultad se tiran años machacándote con problemas que cuesta tan siquiera entender cuando luego la mayor parte del trabajo que harás consistirá en mostrar formularios, recoger datos, guardarlos, mostrarlos y vuelta a empezar.

Para los que ahora mismo estéis asintiendo con la cabeza con los ojillos tristes, tengo buenas noticias: ¡Ejercicios! Esta semana he encontrado un par de páginas de ejercicios de programación, y me he decidido a practicar en casa con problemas que me parezcan más estimulantes y más difíciles para mantener esa chispa y mejorar como programador. Y también me he comprometido a tratar de que este blog tenga vida gracias a eso. Intentaré postear lo más a menudo posible con ejercicios o retos de programación intentando a la vez que sean útiles de alguna forma.El blog lleva un tiempo parado porque no sabía que rumbo darle y creo que por fin lo he encontrado.

Mientras, dejo una página que me ha encantado sobre ejercicios. No son de los útiles, son matemáticos Pero sí que sirven para mantener la mente despierta y para sorprendernos con las distintas soluciones posibles al mismo problema:

ProjectEuler

En la página hay más de 300 problemas ordenados por dificultad. Una vez registrado se desbloquea gran parte de la web y puedes ver estadísticas y un historial de tu progreso. Además, cuando resuelves un problema puedes ver su hilo en el foro donde los usuarios comentan las posibles soluciones. Desde luego mucho mejor que hacer sudocus

Es cierto que aun hay páginas que parecen salidas de principios de los 90, llanas, sin posibilidad de interactuar con ellas, solo leer y ver unas imágenes que no sabemos ni de donde vienen… Pero aún así, la gente con conocimientos e iniciativa sigue buscando nuevas formas de mejorar la web, de hacerla más interactiva, más amena y más dinámica de lo que ya es. Y poco a poco vamos oyendo hablar de HTML5, CSS3, javascript y demás palabrejos. Con Steve Jobs cavando una fosa para flash, Google apostando fuerte por todas estas nuevas tecnologías y Microsoft cazando moscas parece evidente que en el futuro habrá muchos cambios en la web, que será más interactiva, libre y accesible. Estaremos pendientes porque parece divertido.

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….” ?

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?

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