Del laberinto al micro:bit

Enlaces de la sesión

• Plataforma institucional: estudiantes.osorvilo.org
• Blockly Games — Laberinto: blockly.games/?lang=es
• MakeCode para micro:bit: makecode.microbit.org

Código en marcha: del laberinto al micro:bit

Consolidar la construcción de algoritmos mediante la resolución individual de los niveles del juego Laberinto en Blockly Games, exigiendo que cada estudiante registre en el cuaderno el código con el que resolvió cada nivel, de modo que la solución se convierta en un texto que puede leerse, explicarse y corregirse.

En la segunda parte de la sesión, los estudiantes darán sus primeros pasos en el entorno MakeCode para micro:bit, reconociendo sus partes, la caja de bloques y el simulador, y construirán un primer programa basado en eventos: al presionar el botón A aparece un número y al presionar el botón B la pantalla se borra.

La sesión busca que los estudiantes comprendan que la programación no vive únicamente dentro de un juego: los mismos bloques y las mismas ideas permiten controlar un dispositivo que responde a acciones reales.

En la sesión anterior los estudiantes programaron el camino de Berni en Robo-Quest. Allí aprendieron a observar el tablero, planear la ruta, organizar instrucciones, predecir el resultado, ejecutar, detectar errores y optimizar utilizando el bloque Repetir.

En esta sesión se utilizarán esas mismas habilidades en una plataforma diferente y luego en un dispositivo distinto.

Esta sesión constituye la preparación directa para la siguiente sesión. Después de reconocer el entorno MakeCode y construir su primer programa, los estudiantes estarán preparados para:

• Utilizar variables.
• Trabajar con números aleatorios.
• Construir un dado digital.
• Usar otros eventos de entrada, como agitar el micro:bit.
• Mostrar iconos, animaciones y mensajes en la pantalla LED.
• Descargar un programa a un micro:bit físico, si se dispone del dispositivo.

Al finalizar esta sesión no se cierra la misión. Berni anunciará que el siguiente paso será convertir el micro:bit en un dispositivo que toma decisiones.

Al finalizar la sesión, los estudiantes estarán en capacidad de:

• Ingresar de manera autónoma a la plataforma estudiantes.osorvilo.org y a las plataformas de trabajo indicadas.
• Resolver niveles del juego Laberinto utilizando secuencias, bucles y condicionales.
• Escribir en el cuaderno, en forma ordenada, el código que resolvió cada nivel.
• Explicar con sus palabras qué hace cada bloque de su solución.
• Reconocer las partes principales del entorno MakeCode: simulador, caja de bloques y área de trabajo.
• Crear un proyecto nuevo y asignarle un nombre.
• Diferenciar un bloque de evento de un bloque de acción.
• Construir un programa que responda al presionar los botones A y B.
• Probar su programa en el simulador y corregir los errores encontrados.
• Registrar el proceso seguido en la bitácora del programador.

• Pensamiento algorítmico.
• Secuenciación.
• Reconocimiento de patrones.
• Uso de bucles y condicionales.
• Abstracción.
• Predicción.
• Depuración.
• Optimización de soluciones.
• Transferencia entre entornos de programación.
• Representación escrita del código.

• Computador por estudiante. Si no alcanzan los equipos, trabajo en parejas con roles definidos.
• Conexión a internet estable.
• Navegador actualizado, preferiblemente Google Chrome o Microsoft Edge.
• Tablero digital o proyector.
• Cuaderno y lápiz. Colores opcionales.
• Diademas, si se requieren.
• Micro:bit físico y cable USB, si la institución cuenta con los dispositivos. No es indispensable: el simulador permite realizar toda la actividad.
• Formato de registro del código dibujado en el tablero.

1. Encender los computadores y verificar la conexión a internet.
2. Comprobar que la página estudiantes.osorvilo.org abra correctamente en todos los equipos.
3. Verificar que blockly.games no esté bloqueado por el filtro de la red institucional.
4. Abrir makecode.microbit.org en un equipo. La primera carga puede ser lenta, pues descarga el editor completo.
5. Crear previamente el proyecto de ejemplo y dejarlo listo en el equipo del docente.
6. Probar los niveles del Laberinto para conocer su dificultad, sin planear mostrar las soluciones.
7. Proyectar el entorno de MakeCode en el tablero digital.
8. Preparar el formato de registro del código en el tablero.
9. Definir parejas de apoyo para estudiantes que requieran acompañamiento.
10. Preparar una lista de equipos para registrar los que presenten fallas de acceso.
11. Recordar que no se deben mostrar las soluciones completas de los niveles.

Formato del registro

Título: Blockly Games — Laberinto. Para cada nivel resuelto se escribe:

• Nivel:
• Número de bloques utilizados:
• Bloques que aparecieron por primera vez:
• Mi código:
• ¿Tuve que corregir algo?:

Cómo se escribe el código

Respetando la sangría, es decir, dejando un espacio a la derecha para lo que va dentro de un bloque.

repetir hasta (llegar a la meta)
    avanzar
    girar a la derecha

repetir hasta (llegar a la meta)
    si (hay camino a la izquierda)
        girar a la izquierda
    avanzar

Orientaciones

• Escribir el código con letra clara, un bloque por renglón.
• Marcar con una línea vertical o con color lo que quedó dentro de un bucle.
• Quien presente dificultad para escribir puede dibujar flechas y símbolos, siempre que respete el orden.
• Si un nivel no se resolvió, se escribe el intento realizado y hasta dónde llegó el personaje. El intento también es evidencia de trabajo.

Los estudiantes escriben en el cuaderno: en la próxima sesión haré que mi micro:bit tome decisiones.

1. Registro de la verificación de acceso a la plataforma.
2. Lista de los niveles del Laberinto resueltos.
3. Código escrito en el cuaderno de cada nivel resuelto, con la sangría correspondiente.
4. Explicación escrita o verbal de uno de los códigos registrados.
5. Proyecto Mi primer proyecto creado y guardado en MakeCode.
6. Programa funcional: el botón A muestra un número y el botón B borra la pantalla.
7. Registro del programa de micro:bit en el cuaderno.
8. Bitácora final del programador.

Evidencias

• Ingreso autónomo a la plataforma.
• Avance en los niveles del Laberinto.
• Uso de bucles y condicionales.
• Calidad y orden del código registrado en el cuaderno.
• Explicación oral de la solución construida.
• Reconocimiento de las partes del entorno MakeCode.
• Creación y nombramiento del proyecto.
• Ubicación correcta de los bloques dentro del evento.
• Prueba del programa en el simulador.
• Identificación y corrección de errores.

Lista de cotejo

Puede usarse en pantalla durante la clase o imprimirse. Toque una opción para marcarla; tóquela de nuevo para desmarcarla.

Limpiar valoraciones

Superior

Resuelve los niveles avanzados del Laberinto utilizando bucles y condicionales, registra el código de manera ordenada y con sangría correcta, explica su solución con claridad, reconoce las partes del entorno MakeCode, construye el programa de los botones sin ayuda y propone variaciones propias.

Alto

Resuelve la mayoría de los niveles, registra el código de manera comprensible, identifica sus errores y los corrige con poca orientación, y construye correctamente el programa de los botones A y B.

Básico

Resuelve los niveles iniciales, registra parcialmente el código y logra construir el programa en MakeCode con acompañamiento del docente o de una pareja de apoyo.

Bajo

Presenta dificultades para organizar las secuencias, para registrar el código en el cuaderno y para ubicar los bloques dentro del evento. Requiere acompañamiento permanente.

Representación de la información

• Proyectar cada paso en el tablero digital antes de que los estudiantes lo realicen.
• Explicar los bloques por su color y por su forma, además de su nombre.
• Modelar un ejemplo distinto de los niveles asignados.
• Señalar visualmente el inicio, el camino y la meta.
• Entregar una tarjeta con el nombre de las partes del entorno MakeCode.
• Mostrar la estructura del programa escrito junto a la imagen de los bloques.

Acción y expresión

• Permitir el registro del código mediante flechas, símbolos o dibujos.
• Permitir que algunos estudiantes expliquen oralmente su programa en lugar de escribirlo completo.
• Reducir el número de niveles exigidos y solicitar el registro únicamente de los resueltos.
• Permitir el uso de una cuadrícula dibujada en el cuaderno para planear el recorrido.
• Aceptar capturas de pantalla o fotografías del programa como evidencia complementaria.

Participación

• Presentar cada nivel como una misión.
• Reconocer el esfuerzo y la corrección de errores, no solamente el nivel alcanzado.
• Evitar la competencia por terminar primero.
• Permitir repetir los niveles sin penalización.
• Valorar la calidad de la explicación tanto como el resultado.

La sesión es de trabajo individual. Cuando sea necesario compartir computador, se asignan los siguientes roles:

Los roles se intercambian después de cada nivel.

• Comenzar únicamente con los niveles 1 y 2 del Laberinto.
• Recorrer el camino con el dedo antes de tomar cualquier bloque.
• Acompañar la diferenciación entre derecha e izquierda.
• Trabajar un bloque a la vez y ejecutar después de cada adición.
• Escribir el código junto con el estudiante, renglón por renglón.
• En MakeCode, entregar el bloque de evento ya colocado para que el estudiante ubique solamente la acción.
• Asignar una pareja tutora.
• Registrar únicamente nivel, bloque y corrección si escribir todo representa una barrera.
• Formular preguntas en lugar de entregar la solución.

1. Resolver un nivel del Laberinto utilizando menos bloques.
2. Comparar dos soluciones y explicar cuál es más eficiente.
3. Escribir un código con un error intencional para que un compañero lo encuentre.
4. Explorar otro juego de Blockly Games, como Rompecabezas o Pájaro.
5. Agregar iconos y animaciones al proyecto de micro:bit.
6. Programar el evento al presionar los botones A+B.
7. Utilizar el bloque al agitar de la categoría Entrada.
8. Explicar a un compañero la diferencia entre un evento y una acción.

• Dedicar los primeros minutos a la verificación de acceso; resolver esto al inicio evita perder tiempo después.
• Insistir en que el registro del código en el cuaderno no es un adorno: es la evidencia del razonamiento.
• Evitar mostrar soluciones completas de los niveles.
• Pedir siempre una predicción antes de ejecutar.
• Permitir que el error se observe antes de corregirlo.
• No reiniciar inmediatamente después de una falla; preguntar primero dónde ocurrió.
• No convertir la sesión en una competencia por terminar primero.
• Cuidar el tiempo: la segunda parte de la sesión requiere al menos 35 minutos completos.
• En MakeCode, mostrar primero el entorno completo y solo después pedir que arrastren bloques.
• Relacionar permanentemente lo aprendido en el laberinto con lo que ocurre en el micro:bit.
• Reservar los últimos minutos para el cierre y la apertura de la siguiente sesión.