Uno de los mayores problemas que se encuentra todo el que comienza a desarrollar un programa de ajedrez es determinar el punto de comienzo. Cuando comencé a implementar mi programa NChess tuve la suerte de encontrar en Internet una lista donde se sugerían una serie de pasos a seguir para afrontar con ciertas garantías el desarrollo de un programa de este tipo. Esto resultó ser una gran ayuda para saber por dónde empezar y tener una idea general del orden en el que se podía ir construyendo la aplicación. Por ello, me parece una buena idea traducir esa misma lista en esta web para todo aquel que la necesite o la considere útil como pequeña guía de referencia.

1. Crear la aplicación básica con el tablero y algunos menús principales.
2. Crear la estructura de datos para representar el tablero y la posición.
3. Escribir las rutinas para dibujar las piezas.
4. Inicializar y mostrar el tablero en pantalla.
5. Escribir las funciones para Hacer y Deshacer movimientos.
6. Implementar algún método para que el usuario pueda realizar sus movimientos (“clic & clic” ó “arrastrar y soltar”)
7. Implementar las funciones para comprobar la legalidad de los movimientos del usuario. No olvidar aquí la comprobación de jaques.
8. Añadir a la aplicación las opciones de "Nueva Partida" y "Deshacer Movimiento".
9. Escribir una o varias funciones de generación de movimientos (GenerarTodos(), GenerarSoloCapturas(), etc.)
10. Añadir la opción de visualizar en la aplicación la lista de movimientos generados para la posición actual . Esto te ayudará enormemente a depurar el programa.
11. Añadir comprobaciones de jaques [Debió implementarse en el paso 7], mates, tablas por repetición, tablas por falta de material, tablas por la regla de los 50 movimientos, etc. Comprobarlas después de cada movimiento del usuario. He mantenido este paso aquí por respetar la lista original. Sin embargo, aunque considero interesante plantearse el problema de estas comprobaciones, existen otros muchos aspectos del programa que creo que deberían aparecer antes.
12. Implementar el movimiento del ordenador. Por ahora basta con que realice el primer movimiento de la lista generada o alguno de los movimientos generados al azar. Con esto ya debemos tener una aplicación que permite jugar con normalidad y siempre de forma legal contra la máquina, aunque aún las respuestas recibidas sean absurdas o aleatorias.
13. Añadir a la interfaz la lista de movimientos realizados por ambos jugadores en notación algebraica o similar. Esto nos ayudará para poder guardar las partidas jugadas y poder así reproducirlas más adelante.
14. Completar y depurar la interfaz de usuario. Es importante disponer de una aplicación relativamente estable y consistente antes de seguir con la lógica del programa. De no ser así, podemos unir los problemas derivados de la complejidad natural del juego y los procedentes de una interfaz de usuario inconsistente, pudiendo llegar al desastre fácilmente.
15. Implementar una función de evaluación sencilla. Por ahora basta con que tenga en cuanta sólo la diferencia de material (piezas*valorDePiezas) entre ambos lados. Con este sencillo paso, ya tendremos a nuestro programa jugando, al menos, sin perder piezas de forma ridícula.
16. Implementar la búsqueda en árbol. Mi consejo es comenzar implementando un algoritmo MiniMax básico e ir refinándolo hacia el AlfaBeta, de esta forma podremos ver más claramente las ventajas que ofrece éste último y entenderemos mejor sus bases teóricas.
17. Implementar alguna forma de ordenar los movimientos generados para mejorar las búsquedas.
18. Mostrar la continuación principal en pantalla , esto es, la mejor combinación de movimientos de uno y otro lado que encuentra el programa en cada turno de juego. Con este paso conseguiremos un mecanismo para asegurarnos de que el algoritmo de búsqueda está funcionando de forma lógica y genera combinaciones de jugadas coherentes.
19. Implementar y visualizar los relojes de cada lado.
20. Visualizar datos de las búsquedas a la interfaz (profundidad, nodos, nodos por segundo, puntuaciones, etc)
21. Implementar una función para búsquedas en frontera. Más adelante veremos en qué consiste esta técnica, pero adelanto que se utiliza para resolver un problema típico en algoritmos de búsqueda del tipo AlfaBeta, llamados normalmente problemas de horizonte de búsqueda .
22. Añadir optimizaciones a las búsquedas: hashing , movimientos nulos, killers , history , extensiones, etc. Todas estas técnicas mejorarán enormemente la eficacia de la aplicación, reduciendo el número de evaluaciones realizadas o modificando el proceso general de búsqueda.
23. Mejorar la función de evaluación añadiendo más factores de puntuación además de la diferencia de piezas entre los lados.
24. Añadir opciones para Guardar y Abrir partidas.
25. Desarrollar un libro de aperturas que sirva para guiar al programa durante los primeros movimientos de cada partida.
26. Añadir la característica de cálculo continuo ( pondering ), es decir, que el ordenador sea capaz de seguir pensando mientras le toca jugar al usuario.
27. Añadir soporte para bases de datos de finales.

En esta lista he obviado algunos pasos poco importantes si no pretendes hacer un programa que compita con Deep Fritz o similar, como por ejemplo las pruebas con grupos de tests, la implementación de interfaces R-232, etc. Por último, recalcar que esto no pretende ser una lista exhaustiva con todas las tareas necesarias para desarrollar un programa de ajedrez, sino que se expone con la idea de que resulte útil como referencia para no perderse en el camino.