Algorítmica y programación por bloques

Un algoritmo es una secuencia de instrucciones precisas, ordenadas y finitas que permiten resolver un problema o realizar una tarea. Podemos imaginarlo como una receta de cocina: si seguimos los pasos en el orden correcto, obtendremos el plato deseado.

Todo algoritmo consta de tres partes fundamentales:

1. Entrada (Input): Los datos o elementos necesarios para comenzar (ej. los ingredientes).
2. Proceso: El conjunto de pasos que transforman la entrada (ej. cocinar los ingredientes).
3. Salida (Output): El resultado final obtenido (ej. el plato terminado).

Un algoritmo debe ser inequívoco, lo que significa que cada paso debe estar tan claro que no haya lugar a dudas sobre qué hacer.

Cuando nos enfrentamos a un reto grande, puede parecer imposible. La descomposición consiste en dividir un problema complejo en subproblemas más pequeños y manejables.

• Identificación de patrones: Buscamos similitudes entre los problemas pequeños. Si ya sabemos resolver uno, podemos aplicar la misma solución a otros similares.
• Abstracción: Consiste en centrarse en la información importante y ignorar los detalles innecesarios que solo sirven para confundirnos.

Para que un algoritmo sea comprensible antes de programarlo, usamos diferentes herramientas:

• Lenguaje natural: Describir los pasos con nuestras propias palabras (ej. "Primero, abre la puerta").
• Diagramas de flujo: Representaciones gráficas que usan flechas y figuras geométricas (óvalos para inicio/fin, rectángulos para acciones y rombos para decisiones).
• Pseudocódigo: Un lenguaje intermedio entre el humano y el de las máquinas, que utiliza una estructura formal pero fácil de leer.

La mayoría de estos entornos comparten una estructura común:

• El Escenario: Es el lugar donde ocurre la acción. Aquí vemos cómo se mueven nuestros personajes u objetos.
• Objetos (Sprites): Son los elementos que programamos. Cada objeto puede tener su propia lógica.
• Paleta de bloques: Un menú organizado por categorías (Movimiento, Sonido, Control, etc.) donde elegimos las piezas.
• Área de scripts: El espacio central donde arrastramos y conectamos los bloques para formar el programa.

Los programas no se ejecutan solos; necesitan un disparador. Un evento es una acción que el ordenador detecta para ejecutar un bloque de código.

• Bloques de inicio: El más común es "al presionar la bandera verde".
• Eventos externos: Pulsar una tecla (espacio, flechas) o hacer clic en un objeto.
• Mensajes: Los objetos pueden enviarse "cartas" invisibles entre ellos para coordinarse (ej. cuando el Jugador 1 pierde, envía un mensaje de "Fin de partida" al escenario).

Aprender a gestionar nuestro trabajo es vital:

1. Guardar y cargar: Los proyectos suelen guardarse con extensiones específicas (como .sb3 en Scratch).
2. Compartir: La mayoría de plataformas permiten publicar el proyecto para que otros lo vean.
3. Exploración: Analizar proyectos de la comunidad es una excelente forma de aprender trucos nuevos.

Es la estructura más básica. Las instrucciones se ejecutan una tras otra, de arriba a abajo.

• Movimiento: Bloques como "mover 10 pasos" o "girar 15 grados".
• Apariencia: Cambiar el color, decir "¡Hola!" o cambiar el tamaño del objeto. Si cambiamos el orden de dos bloques de movimiento, el resultado final del objeto puede ser totalmente distinto.

Un bucle permite repetir un conjunto de instrucciones sin tener que escribirlas muchas veces.

• Por siempre: El código dentro no para nunca (ideal para la música de fondo).
• Repetir $n$ veces: Se ejecuta un número concreto de veces (ej. repetir 4 veces para dibujar un cuadrado).
• Repetir hasta que: El bucle continúa solo hasta que se cumple una condición específica (ej. repetir hasta que el personaje toque la meta).

Permiten que el programa tome decisiones.

• Si [condición] entonces: Si la condición es verdadera, se ejecuta el código interior.
• Si [condición] entonces / si no: Si la condición es verdadera hace una cosa, y si es falsa, hace una acción diferente. Esto permite crear caminos alternativos en el flujo del programa.

Una variable es como una caja con un nombre donde guardamos un valor que puede cambiar (el número de vidas, la puntuación, el nombre del jugador).

• Asignación: Darle un valor inicial (ej. Puntos = 0).
• Incremento/Decremento: Sumar o restar puntos a la variable según las acciones del juego.

Son los bloques que realizan cálculos:

• Aritmética: Suma ($+$), resta ($-$), multiplicación ($*$) y división ($/$).
• Azar: Generar números aleatorios (ej. "número al azar entre 1 y 10"), fundamental para que los juegos no sean siempre iguales.
• Comparaciones: Sirven para las condiciones, usando los símbolos mayor que ($>$), menor que ($<$) o igual ($=$).

Permiten combinar varias condiciones:

• Y (AND): Ambas condiciones deben ser ciertas.
• O (OR): Al menos una de las condiciones debe ser cierta.
• NO (NOT): Invierte el valor (si algo es verdadero, lo convierte en falso).

Los bloques de sensores devuelven valores de verdadero o falso:

• Contacto: "¿Tocando el puntero del ratón?" o "¿Tocando el color rojo?".
• Preguntas: El bloque "preguntar y esperar" abre un cuadro de texto para que el usuario escriba, y la respuesta se guarda en una variable especial llamada "respuesta".

Un programa es más atractivo si tiene elementos visuales y sonoros:

• Disfraces: Cambiar la imagen del objeto para simular animación (ej. caminar).
• Fondos: Cambiar el escenario según el nivel del juego.
• Sonidos: Reproducir efectos cuando ocurre una colisión o se gana un punto.

El escenario se divide mediante un sistema de coordenadas cartesianas:

• Eje X: Controla la posición horizontal (izquierda a derecha). El centro es $0$.
• Eje Y: Controla la posición vertical (arriba a abajo).
• Dirección: Los objetos pueden apuntar en ángulos (0° arriba, 90° derecha, 180° abajo, -90° izquierda).

Un bug es un error en el código.

• Errores de lógica: El programa funciona pero no hace lo que queremos (ej. el personaje atraviesa las paredes).
• Prueba y error: Probar el programa tras cada pequeño cambio para localizar dónde surge el fallo.
• Ejecución paso a paso: Observar qué bloques se iluminan mientras el programa corre para ver el flujo real.

Un buen programador es ordenado:

• Comentarios: Notas que explicamos para nosotros mismos o para otros compañeros sobre qué hace una parte del código.
• Nombres claros: Llamar a una variable "Puntuación" es mucho mejor que llamarla "Variable1".
• Limpieza: Eliminar bloques sueltos que no están conectados a ningún evento para mantener el área de trabajo despejada.

Para consolidar lo aprendido, el paso final es crear un proyecto propio.

1. Diseño: Dibujar en papel qué queremos que haga el juego o aplicación.
2. Desarrollo: Ir programando por partes (primero el movimiento, luego los puntos, luego los niveles).
3. Presentación: Explicar a los compañeros cómo funciona y qué retos hemos superado.