AV 100, GI 25: lo único de la clase de informática que no ha caducado

De todo lo que me enseñaron en el colegio, hay una cosa que sigo usando cada día de mi vida profesional.

No fueron las integrales.

Fue una tortuga.

El aula de informática

Estudié en Marianistas. Desde primero de EGB hasta COU, el mismo edificio y los mismos pasillos; el colegio ha cambiado de nombre desde entonces, pero para los que estuvimos allí sigue llamándose así. Mi promoción fue la última que hizo COU: detrás de nosotros ya venía la ESO.

Y durante varios cursos tuvimos clase de informática, en un aula con PCs y —esto era el lujo— uno por alumno. Nada de ir por parejas turnándose el teclado.

No recuerdo en qué curso empezamos, ni cuál de las muchas versiones de Logo era la que teníamos instalada, ni si el profesor era informático de formación o le tocó a él. Podría mirarlo y contarlo con seguridad fingida, pero sería inventarme un dato para que la historia quede más redonda, y eso ya me lo prohibí en otro artículo.

Lo que recuerdo perfectamente es lo que había en la pantalla. Una tortuga. Y dos palabras:

AV 100
GI 25

Avanza cien. Gira veinticinco grados a la izquierda.

Ese era el lenguaje entero el primer día. Y con eso ya podías hacer que pasara algo.

Qué era aquello en realidad

Aquella tortuga no era un jueguecito que alguien hubiera montado para entretener a unos críos de un colegio de Donostia. Era la punta visible de una de las ideas más serias que ha dado la informática educativa.

Logo se diseñó en 1967 en Bolt, Beranek and Newman —la misma casa que un par de años después construiría los primeros nodos de ARPANET— y lo firman tres personas: Wally Feurzeig, Seymour Papert y Cynthia Solomon. El primer intérprete corría sobre un PDP-1 y estaba escrito en Lisp. El nombre viene del griego logos: palabra, pensamiento. No es un acrónimo de nada.

Y la tortuga, casi desde el principio, tuvo dos cuerpos: una figura dentro de la pantalla y un robot de suelo con un bolígrafo en la barriga. En 1969 ya funcionaban las dos. A la de suelo le decías «avanza cien» y el bicho recorría el aula dejando una raya en el papel.

Una tortuga de suelo junto a lo que acaba de dibujar. No es la del MIT: es la Valiant Turtle, que se manejaba por infrarrojos y se fabricó entre 1983 y 2011 para colegios de medio mundo. Figuras como la del papel salen de repetir «avanza y gira» cambiando poco a poco los números. Foto: Valiant Technology Ltd., CC BY-SA 3.0; imagen recortada y disponible bajo la misma licencia.

La de suelo se quedó con el bolígrafo y la de pantalla ganó velocidad, pero las dos compartían lo importante: tienen una posición y están mirando hacia algún sitio.

La idea buena: geometría en primera persona

Aquí está lo que hacía distinto a Logo, y tardé veinte años en darme cuenta de que lo había tenido delante.

Para dibujar un cuadrado en cualquier otro sitio —entonces y ahora— dices dónde están las esquinas. Coordenadas: moveTo(0, 0), lineTo(100, 0), lineTo(100, 100). Estás mirando el papel desde arriba, como un dios pequeño con un sistema de ejes.

En Logo no. En Logo tú eres la tortuga.

Avanzas. Giras. Vuelves a avanzar. Para saber qué hacer a continuación, la pregunta no es «¿cuáles son las coordenadas del siguiente vértice?», sino «si yo estuviera ahí de pie, ¿hacia dónde tendría que girar?». Y esa pregunta un crío de nueve años la contesta de sobra, porque lleva nueve años andando y girando.

Papert lo llamaba geometría sintónica con el cuerpo: matemáticas que se resuelven poniéndote tú en el sitio y andando el camino. Cuando alguien se atascaba, el truco era levantarse y hacerlo con los pies.

Llevo media vida ganándome la vida con la versión adulta de ese truco. Depurar un proceso es exactamente eso: dejar de mirar el sistema desde arriba, meterse dentro, ponerse donde está la máquina y recorrer el camino paso a paso con lo que ella sabe en cada momento, no con lo que sabes tú, que has visto el código entero. Los fallos que más tardo en encontrar son siempre los que he intentado resolver desde el diagrama.

REPITE, o el primer bucle de mi vida

El segundo día ya no escribías cuatro líneas para hacer un cuadrado. Escribías esta:

REPITE 4 [AV 100 GD 90]

Y ahí, sin que nadie usara la palabra, acababas de escribir un bucle: un bloque de instrucciones y un número de veces.

Lo bueno viene después. Porque lo que tú quieres es que la figura cierre, que la tortuga termine donde empezó, y para eso hay una regla que en el libro de Papert tiene hasta nombre propio: el teorema de la vuelta total. Si la tortuga recorre el borde de una figura y acaba en el mismo estado en que empezó, la suma de todos sus giros es 360 grados.

Eso es un invariante. Con nueve años.

Y de ahí sale lo demás sin que nadie lo explique. ¿Un triángulo? Tres giros que sumen 360: REPITE 3 [AV 100 GD 120]. ¿Un pentágono? GD 72. ¿Un círculo? Un polígono de 360 lados diminutos:

REPITE 360 [AV 1 GD 1]

Ahora mira otra vez el GI 25 con el que empieza el artículo, que es el número que se me quedó grabado y que no divide a 360. Veinticinco grados no cierran nunca... hasta que cierran: REPITE 72 [AV 100 GI 25] suma 1800 grados, o sea cinco vueltas completas, y devuelve la tortuga exactamente al punto de partida.

Lo que queda en la pantalla, por cierto, no es ninguna estrella: son cinco vueltas casi superpuestas, un anillo de bordes ondulados, como un círculo repasado cinco veces con el pulso un poco distinto. Lo he ejecutado para comprobarlo, porque me lo imaginaba de otra manera.

Eso no es una clase de dibujo. Es el mínimo común múltiplo entrando por los ojos.

Y las espirales, que también las hice hasta aburrirme, salían de cambiar dos cosas poco a poco: avanzar un poco más en cada tramo y girar algo que no fueran 90 grados. El cuadrado dejaba de cerrarse y empezaba a desplegarse por la pantalla.

PARA, o la primera función

Y luego estaba la palabra que lo cambiaba todo:

PARA CUADRADO
  REPITE 4 [AV 100 GD 90]
FIN

A partir de ese momento CUADRADO era una orden más, como AV o GI. La máquina había aprendido una palabra nueva y ya no había que volver a explicársela.

Hacíamos casas, estrellas, círculos, espirales y algún castillo. Y el castillo es el mejor ejemplo, porque nadie ha dibujado nunca un castillo: dibujas un rectángulo y lo llamas TORRE, escribes PARA ALMENA, y luego PARA CASTILLO no hace más que llamar a las otras dos unas cuantas veces.

Descomposición. Reutilización. Nombres que dicen lo que hacen. Es literalmente lo que hago hoy cuando parto un proceso grande en funciones pequeñas, y es lo primero que miro cuando reviso el código de otra persona.

Nadie en aquella aula pronunció ninguna de esas palabras. Nos las dieron a hacer.

Seis cosas que puedes escribir esta tarde

Con lo que llevas leído —AV, RE, GD, GI, REPITE y PARA— ya puedes leer estos seis programas de arriba abajo. Los he ejecutado todos antes de ponerlos aquí, que en esto de las figuras la intuición engaña bastante. Los nombres exactos bailan un poco de una versión de Logo a otra —SI y ALTO son los que más—, pero esta es la forma castellana de las que corrían por los colegios.

La casa. El primer dibujo de todo el mundo: un cuadrado, te subes a la esquina de arriba, apuntas al cielo y le pones el tejado.

REPITE 4 [AV 100 GD 90]
AV 100
GD 30
REPITE 3 [AV 100 GD 120]

La estrella de cinco puntas. En una línea. Cinco giros de 144 grados suman 720: dos vueltas completas, y por eso cada lado se cruza con el anterior en lugar de cerrar un pentágono.

REPITE 5 [AV 200 GD 144]

La roseta. Treinta y seis cuadrados, cada uno girado diez grados respecto al anterior. Y lo mejor es lo que no está escrito en ninguna parte: los lados hacen aparecer por dentro la ilusión de un círculo que nadie ha dibujado.

REPITE 36 [REPITE 4 [AV 100 GD 90] GD 10]

La flor de doce círculos. Aquí ya le enseñas una palabra nueva a la máquina y luego se la mandas repetir. El círculo, como antes, es un polígono de 360 lados de un paso.

PARA CIRCULO
  REPITE 360 [AV 1 GD 1]
FIN

REPITE 12 [CIRCULO GD 30]

La espiral. Esta es la que no sale solo con girar raro: hace falta que el paso crezca. El procedimiento se llama a sí mismo con un paso un poco mayor y para cuando se le va de las manos. Y los 91 grados en vez de 90 hacen que la espiral entera vaya girando, en lugar de quedar alineada como una espiral cuadrada.

PARA ESPIRAL :PASO
  SI :PASO > 150 [ALTO]
  AV :PASO
  GD 91
  ESPIRAL :PASO + 3
FIN

ESPIRAL 5

El árbol. Y este me sigue pareciendo magia. Un tronco, dos ramas más cortas abriéndose a los lados, y cada rama volviendo a hacer lo mismo hasta que se hacen demasiado pequeñas. La clave está en que cada llamada termina deshaciendo su giro y retrocediendo: devuelve la tortuga exactamente como la encontró, y por eso la rama siguiente puede fiarse de dónde está.

PARA RAMA :LARGO
  SI :LARGO < 8 [ALTO]
  AV :LARGO
  GI 30
  RAMA :LARGO * 0.7
  GD 60
  RAMA :LARGO * 0.7
  GI 30
  RE :LARGO
FIN

RAMA 120

Quédate con ese último, que lo voy a necesitar dentro de unos párrafos. Un árbol entero en nueve líneas, sin una sola coordenada, y toda la dificultad concentrada en una idea: guardar dónde estabas antes de irte por una rama, y volver ahí al acabar.

Si te pica probarlo, hay versiones libres de Logo que siguen funcionando —FMSLogo, XLogo— y, si no quieres instalar nada, import turtle en Python hace exactamente esto con otros nombres.

El error no era un suspenso: era un dibujo torcido

Esta es la parte que me sigue pareciendo subversiva, y la que rara vez encontraba en el resto de las asignaturas.

En Logo el error no llegaba como un «incorrecto». Aparecía dibujado.

Escribías GD 90 donde iba GD 120 y en la pantalla no salía ninguna cruz roja: salía una figura torcida. Y una figura torcida no te hunde, te pica. Miras el dibujo, deduces por dónde se ha ido, cambias un número y lo lanzas otra vez. Y otra.

Eso tiene dos nombres en mi oficio y los dos importan: ciclo de realimentación corto y depuración. Miras la salida, formulas una hipótesis, cambias una cosa —una— y vuelves a ejecutar. Ni siquiera la palabra bug significa lo que la gente cree, pero el gesto es ese, y en aquella aula lo hacíamos cuarenta veces por clase sin saber que se llamaba de alguna manera.

Compáralo con el resto de la asignatura. El ejercicio de mecanografía tenía una respuesta correcta. La hoja de cálculo tenía una respuesta correcta. El dibujo de la tortuga tenía muchísimos resultados posibles, y todos se podían mirar, incluso cuando no eran el que estabas buscando.

Seymour Papert

Para entender la idea educativa que había debajo de Logo, el nombre que hay que conocer es Seymour Papert, porque a él aquello no le salió de la informática: le salió de una teoría sobre cómo aprenden los niños.

Nació en Pretoria, en Sudáfrica, el 29 de febrero de 1928 —así que la fecha exacta de su cumpleaños solo aparece en el calendario una vez cada cuatro años—. Antes del MIT pasó cinco años en Ginebra trabajando con Jean Piaget, y llegó a Boston con una idea que en 1967 sonaba casi a provocación: que un niño aprende mejor construyendo algo que puede enseñar a los demás que escuchando a alguien explicárselo. Lo llamó construccionismo. En el MIT fundó con Marvin Minsky el laboratorio de inteligencia artificial, y en 1980 publicó Mindstorms, que es donde está el teorema de la vuelta total y donde está esta idea, que es este artículo entero resumido:

En muchas escuelas de hoy, «enseñanza asistida por ordenador» significa poner al ordenador a enseñar al niño. Podría decirse que se está usando el ordenador para programar al niño. En mi visión, es el niño quien programa al ordenador.

Murió el 31 de julio de 2016, en Maine.

Seymour Papert, matemático y educador, uno de los tres autores de Logo y el que puso la teoría debajo de la tortuga. Foto: Matematicamente.it, CC BY-SA 3.0; imagen recortada y disponible bajo la misma licencia.

Lo que caducó de aquella asignatura y lo que no

Aquí está el chiste, y es un chiste con moraleja.

La clase de informática de mi colegio enseñaba tres cosas distintas sin distinguirlas nunca: una destreza, unas herramientas y unas ideas. Y han envejecido de tres maneras diferentes.

La destreza era la mecanografía, con aquel programa que te hacía repetir frases medidas por filas de teclas —«añada la sal a la salsa» y compañía—, y esa no ha caducado ni un poco. Me gano la vida escribiendo, código y texto, todo el día; escribir rápido sin mirar el teclado es seguramente lo segundo que más uso de aquella aula. Y da para su propio artículo, así que algún día lo escribiré.

Las herramientas eran los programas concretos, con sus menús, sus cuadros de diálogo y sus combinaciones de teclas que había que memorizar. Eso fue lo que más rápido caducó: los programas desaparecieron, los menús se movieron de sitio dos o tres reformas después, y lo que aprendí de aquella hoja de cálculo no me vale hoy ni para abrirla.

Y las ideas eran la tortuga: el rato que parecía un juego, y que muy probablemente estaba en el temario porque venía en el temario.

Así que, con la mecanografía a salvo, la frase que queda es esta, que deja bastante peor a la asignatura: de todo lo que allí parecía propiamente informática, lo único que sigue sirviendo tal cual es la tortuga. Un bucle sigue siendo un bucle, una función sigue siendo una función, un invariante sigue siendo un invariante, y meterse dentro del proceso para entender por qué falla sigue siendo lo que separa a alguien que arregla cosas de alguien que las mira.

Es la diferencia entre enseñar una herramienta y enseñar una idea, y sigue sin estar resuelta. Cada vez que alguien me pregunta si su hijo debería aprender tal aplicación de moda, lo que contesto es esto, con la tortuga por delante.

Dónde está la tortuga ahora

En todas partes, y con otro nombre.

• Scratch, con el que se enseña a programar hoy en muchos colegios, nació también en el MIT —en el Media Lab, con Mitchel Resnick— y viene en línea recta de la tradición construccionista de Papert. Los bloques que arrastras dicen «muévete 10 pasos» y «gira 15 grados». Adivina de dónde viene eso.
• Python —que es un lenguaje de adultos y de producción— trae de serie, en su biblioteca estándar, un módulo llamado turtle. forward(100), left(25). Cincuenta y tantos años después, ahí sigue.
• Y los LEGO Mindstorms, los de los motores y los sensores, se llaman así por el libro de Papert. La empresa financió durante años al grupo del MIT y le puso al producto el nombre de la idea.

Así que no fue una moda pedagógica de los noventa que se apagó sola. Es una de las cosas que mejor han envejecido de toda la historia del software educativo.

Y yo la sigo usando, literalmente

Esto no es nostalgia. Parte de aquello lo uso en trabajo facturable, y más a menudo de lo que parece razonable.

Me toca generar imágenes por código bastante: portadas, montajes, gráficos, plantillas que se rellenan solas con datos, marcas de agua, recortes en cadena. Unas veces con PHP y GD, otras con Python, otras con JavaScript sobre un canvas. Y cada vez que me pongo con una de estas, el primer intento es el de todo el mundo —calcular coordenadas— y el segundo intento, el que funciona, acaba siendo la tortuga.

En canvas está hasta con los mismos verbos. translate() mueve el origen y rotate() gira los ejes: dejas de mover el dibujo y mueves el sistema de referencia, que es la diferencia entera entre lineTo y AV. Y save() / restore() es una pila de estados de la tortuga: guarda dónde estoy y hacia dónde miro, vete a dibujar una rama, y vuelve exactamente a donde estabas.

ctx.save();
ctx.translate(x, y);        // ahora el origen soy yo
ctx.rotate(angulo);         // y miro hacia allí
rama(ctx, largo * 0.7);     // que se apañe la rama
ctx.restore();              // vuelvo a donde estaba, mirando como miraba

Y eso es exactamente el árbol de más arriba: save() es «guarda dónde estoy y hacia dónde miro» y restore() hace el trabajo de aquel GI 30 RE :LARGO con el que la rama devolvía la tortuga a su sitio. La misma idea, treinta años después, con otras palabras y sin una sola coordenada absoluta.

GD, en cambio, no tiene sistema de coordenadas móvil: es imageline($im, $x1, $y1, $x2, $y2, $color) y arréglatelas. Así que ahí la tortuga te la llevas tú, y la llevo: tres variables —x, y, rumbo— y tu propio «avanza», que son un seno y un coseno.

$nx = $x + $paso * cos($rumbo);
$ny = $y + $paso * sin($rumbo);
imageline($im, (int) $x, (int) $y, (int) $nx, (int) $ny, $color);
[$x, $y] = [$nx, $ny];

Cuatro líneas. Eso es AV 100.

Y el REPITE no se ha ido a ninguna parte: las marcas de un reloj, los sectores de un gráfico circular, una rejilla en perspectiva o una roseta decorativa son siempre un bucle que avanza y gira. Y si el número de repeticiones y el ángulo no completan una o varias vueltas exactas, aparece un pico feo justo al cerrar. El teorema de la vuelta total pasando factura en producción, veinticinco años después de aquella aula.

Hasta el caso más soso de todos es una tortuga. Componer una portada con texto es apilar líneas: escribes el antetítulo, mides lo que ocupa, bajas el cursor esa cantidad, escribes el título, mides, bajas. Nada de escribir en el píxel 340 porque en las pruebas quedaba bien. Es una tortuga que solo sabe avanzar y que mira siempre hacia el sur. Las portadas generadas de este blog —las que no salen de una foto— se componen exactamente así.

La lección de fondo es la de 1967 y no ha cambiado: casi siempre es más fácil llevar un estado —dónde estoy y hacia dónde miro— y avanzar, que calcular desde fuera dónde va cada punto. Lo primero se puede seguir con el dedo. Lo segundo se convierte en una hoja de cálculo con senos.

Lo que me llevé de allí

Hace unos días escribí sobre lo que aprendí cacharreando en casa con Javier: que la caja se abre, que el manual se lee y que no saber algo es el paso previo a aprenderlo. Eso pasaba en la mesa del comedor, un sábado por la mañana, sin horario y sin matrícula.

Este artículo es el otro lado. Porque en el colegio, aquella vez, acertaron.

Sin ordenador en casa yo habría llegado igual a la informática, seguramente más tarde. Pero fue en un aula, con un profesor cuyo nombre no recuerdo y un programa cuya versión no sé decir, donde por primera vez le di una orden a una máquina, la máquina la obedeció, y el resultado era mío.

AV 100. GI 25.

Sigo escribiendo lo mismo todos los días. Lo que pasa es que ahora lo llamo función, lo llamo bucle y cobro por ello.

Y sigo intentando, cada vez que algo se tuerce, que la suma de los giros dé 360 y volver al sitio del que salí.