Este juego está pensado para iniciar al alumno en la programación estructurada, se requieren unos conocimientos previos básicos que pueden adquirirse en el juego de Los valorines.
Antes de iniciar el juego, el profesor ha de impartir los conocimientos redactados en el apartado de Saberes básicos que son necesarios para poder jugar al mismo.
El juego esta formado por una baraja de cartas con fragmentos de código y unas cuentas a modo de puntos.
Los estudiantes adquirirán conocimientos relativos a la programación estructurada, es decir, aprenderan a leer de forma correcta el código secuencial, condicional e iteraciones de bucles.
Al conocer y dominar el juego, seran capaces de distinguir y generar ellos mismos bucles for, while, sentencias if, etc.
El juego está pensado para 4 jugadores, cada uno de ellos adquiere un rol relativo a una de las 4 variables del juego, V1, V2, V3 o V4. La finalidad del juego es terminar "la carrera" con el valor más alto posible para su variable, Para conseguirlo cada jugador ha de jugar correctamente sus cartas pensando siempre en aumentar el valor de su variable y disminuir el de los demás. Más info
La palabra programación, a veces, asusta. Y si le pones estructurada justo después, más. Pero, en realidad, no es para tanto. Vamos a verlo. La programación estructurada es una corriente que nació con la vocación de facilitar la vida de los programadores, sobre todo cuando estos debían abordar fases de mejora posteriores a la creación del programa, y de ordenar la forma en la que se creaba cualquier tipo de programa. ¿Cualquiera, cualquiera? ¡Sí!
Para comprenderlo mejor, vamos a hacer un pequeño viaje en el tiempo. Nos vamos al año 1966, cuando Böhm y Jacopini proponen el teorema del programa estructurado, con el que demuestran que cualquier programa puede ser escrito utilizando solo tres instrucciones de control. Imagínate, ¡esto fue toda una revolución! Implicaba la construcción de programas más sencillos y más rápidos, en los que disminuía la complejidad de las pruebas y el testing para ponerlos en funcionamiento.
Avanzamos dos años más en el tiempo. En 1968, Edsger Dijkstra publicó un célebre artículo que impactó en la computación moderna: Go To Statement Considered Harmful. ¿Por qué es tan importante? Pues porque este científico holandés promovió activamente el uso de lenguajes de programación estructurada, fomentando la verificación formal de programas y la eliminación de la sentencia Goto. De hecho, Dijkstra participó en el comité que diseñó Algol 60, el primer lenguaje de programación estructurado.
La programación estructurada se convierte así, junto con la programación orientada a objetos, en uno de los paradigmas de programación más populares que ejecuta los lenguajes más potentes que seguro conoces, incluidos, entre otros, Java, C, Python y C++.
El teorema del programa estructurado es la base teórica sobre la que se construyó esta nueva forma de programar, ya que nos da la característica fundamental de la programación estructurada. Postula que, simplemente con la combinación de tres estructuras básicas, es suficiente para expresar cualquier función computable. Parece sencillo, ¿verdad? En realidad, lo es y, precisamente por eso, se abre inmediatamente el debate entre los programadores que querían continuar con el sistema anterior y los que abrazaban estas nuevas estructuras de control con los ojos cerrados. ¿Quién crees que ganó?
Vale, nadie fue declarado vencedor inmediatamente, pero sí que es cierto que ‘los Digital Workers de los años 70’ empezaban a ver poco a poco las grandes ventajas que ofrecía la programación estructurada sobre el código espagueti (los programas de computación antiguos que tenían una estructura de control de flujo compleja e incomprensible). Y, ¿qué ventajas eran esas?
Los programas desarrollados con la programación estructurada son más sencillos de entender, ya que tienen una estructura secuencial y desaparece la necesidad de rastrear los complejos saltos de líneas (propios de la sentencia Goto) dentro de los bloques de código para intentar comprender la lógica interna.
Como consecuencia inmediata de lo anterior, otra ventaja es que los programas resultantes tendrán una estructura clara, gracias a que las sentencias están ligadas y relacionadas entre sí.
La fase de prueba y depuración de los programas se optimiza, ya que es mucho más sencillo hacer el seguimiento de los fallos y errores y, por tanto, detectarlos y corregirlos.
El coste del mantenimiento de los programas que usan la programación estructurada es más reducido. ¿Por qué? Pues porque modificar o extender los programas es más fácil al estar formados por una estructura secuencial.
Al ser más sencillos los programas, son más rápidos de crear y los programadores aumentan su rendimiento.
Ya nos ha quedado claro que la programación estructurada es una forma de programar más sencilla que se basa únicamente en la combinación de tres órdenes. Pero, ¿cuáles son esos tipos de estructuras de control que son capaces de expresarlo todo?
Secuencia. La estructura secuencial es la que se da de forma natural en el lenguaje, porque las sentencias se ejecutan en el orden en el que aparecen en el programa, es decir, una detrás de la otra.
Selección o condicional. La estructura condicional se basa en que una sentencia se ejecuta según el valor que se le atribuye a una variable booleana. ¡Un pequeño inciso! Una variable booleana es aquella que tiene dos valores posibles. Por tanto, esta estructura se puede ejecutar de dos formas distintas, dependiendo del valor que tenga su variable.
Como apunte para los verdaderos amantes de la programación: para las estructuras condicionales o de selección, se utiliza la sentencia if, que puede combinarse tambien con else.
Iteración (ciclo o bucle). La estructura de repetición ejecuta una o un conjunto de sentencias siempre que una variable booleana sea verdadera. Para los bucles o iteraciones, los lenguajes de programación usan las estructuras while y for.
En el corazón del Multiverso Programático, se celebra un evento legendario: "La Gran Carrera de las Variables". Este fascinante torneo reúne a las variables más intrépidas y habilidosas, cada una representando un Valorín de un lenguaje de programación distinto.
La competición toma lugar en el Circuito Binario, una pista de carreras virtual donde las variables corren a velocidades vertiginosas, impulsadas por los fragmentos de código que los jugadores lanzan al tablero. Cuatro Valorines legendarios (V1, V2, V3 y V4) están ansiosos por mostrar su destreza y alcanzar la cima de la clasificación.
Cada jugador forma parte del equipo de un Valorín y utiliza cartas con fragmentos de código para acelerar su variable y afectar a las otras. Los fragmentos de código son estratégicamente diseñados para aumentar o disminuir los valores de las variables, crear bucles temporales o incluso invocar eventos especiales en la pista.
Los jugadores lanzan sus cartas en cada turno, determinando así el destino de las variables en la carrera. Las variables avanzan por la pista, enfrentándose a desafíos y cambios de código mientras buscan alcanzar la meta final. El jugador cuya variable tenga el valor más alto al final del juego será coronado como el Programador Supremo y ganará la Gran Carrera de las Variables.
Pero ten cuidado, ¡los rivales estarán al acecho! Estrategia y astucia son clave para manipular las variables en tu favor y asegurar la victoria para tu Valorín. ¿Estás preparado para enfrentarte a la emocionante carrera y llevar a tu variable hacia la gloria programática?
X cartas ( 1 carta de INICIO de carrera, 1 carta de FIN de carrera y X-2 de fragmento de código ) e Y cuentas de puntos.
Conseguir el máximo valor posible para tu variable al finalizar la partida.
Se asigna a cada jugador una variable a su elección (V1, V2, V3 o V4) y se le entrega una cuenta a cada uno, dejando el resto en un montón, las cuentas equivalen al valor de las variables, siempre valen 1 al comenzar el juego. Se barajan todas las cartas, excepto la de INICIO de carrera que se sitúa boca arriba en el tablero de juego. Se reparten 4 cartas a cada jugador (la carta de FIN de carrera puede tocarle a un jugador al inicio del juego o durante el mismo en cualquier momento) dejando el resto del mazo boca abajo junto a la carta de INICIO y se inicia la partida.
El más joven comienza. Cada jugador en su turno debe escoger entre descartarse una de sus cartas (poniéndola boca abajo y la última en el mazo central) y cogiendo en su lugar la primera del mazo. O bien, jugar dos de sus cartas y coger entonces dos cartas nuevas del mazo. Tanto al inicio como al final de cada turno, todos los jugadores dispondrán de 4 cartas en sus manos.
Cuando un jugador juega sus dos cartas, debe hacerlo en el orden de su elección, primero una y luego otra, mostrando el código de las mismas, dependiendo de dicho código, los jugadores cuyas variables se vean afectadas por él, incluido el propio jugador, deberán aumentar o disminuir el número de cuentas en función de lo que indique el código. Si una de las cartas jugadas es la de FIN de juego, el juego termina y cada jugador se queda con el número de cuentas de que dispone en ese momento.
El jugador que haya conseguido más cuentas al final de la partida, es decir, el que tenga un valor más alto para su variable.
El juego está formado por las cartas de INICIO (que da inicio a la partida, poniendo el valor inicial de las variables a 1), la de FIN (que finaliza la partida) y cartas de código.
Las cartas de código pueden ser de tipo secuencial, condicional o de bucle. A continuación se ve un ejemplo de cuatro cartas de cada tipo:
Puedes descargar los cuatro archivos que contienen las cartas e imprimirlas desde los siguientes enlaces:
Tambien puedes descargarte el siguiente archivo y crear tantas cartas nuevas como desees:
Si tienes alguna consulta, sea cual sea tu inquietud, estaré encantado de atenderla lo antes posible.
Puedes ponerte en contacto conmigo en cualquiera de los canales siguientes:
