Plankalkül, el primer lenguaje de programación de la historia: origen, sintaxis y ejemplos de código

En los albores de la era informática, cuando los ordenadores eran todavía una novedad y las posibilidades tecnológicas estaban en pleno desarrollo, surgió el primer lenguaje de programación de alto nivel de la historia. Este hito fue alcanzado por el ingeniero y científico alemán Konrad Zuse entre los años 1942 y 1945, aunque su creación no se publicó de forma completa hasta 1972. Denominado Plankalkül (pronunciado [ˈplaːnkalkyːl]), este lenguaje fue concebido para resolver problemas de ingeniería y optimizar el desarrollo de programas mucho antes de que existieran conceptos que hoy damos por sentados, como compiladores, variables o funciones.

¿Qué significa Plankalkül?

El nombre Plankalkül proviene del alemán: Kalkül es el término para «sistema formal» (como en Hilbert-Kalkül, el sistema de deducción de Hilbert), y Plan significa «plan» o «programa». La traducción más precisa sería «sistema formal de planificación» o «cálculo de programas». Zuse denominaba a cada programa individual un Rechenplan (plan de cálculo).

Historia y contexto: de la guerra a los Alpes

Los ordenadores de Zuse

Konrad Zuse (1910–1995), nacido en Berlín, fue un ingeniero civil autodidacta en el campo de la computación. Trabajando en el salón de la casa de sus padres, diseñó y construyó una serie de ordenadores innovadores:

• Z1 (1938): El primer ordenador mecánico programable, basado en aritmética binaria de punto flotante.
• Z3 (1941): Considerado el primer ordenador digital programable completamente funcional del mundo. Utilizaba relés electromagnéticos, memoria separada del procesador, y programa almacenado en cinta perforada.
• Z4 (1945): El primer ordenador comercial de la historia, el único que sobrevivió a la guerra.

El nacimiento de Plankalkül

Ya durante el desarrollo de la Z3, Zuse empezó a concebir un lenguaje que fuera más allá de la lógica formal y permitiera expresar algoritmos complejos. Para describir circuitos lógicos, inventó su propio sistema de notación llamado Bedingungskombinatorik (combinatoria de condiciones). Al terminar la Z1 en 1938, descubrió que el cálculo que había inventado de forma independiente ya existía y era conocido como cálculo proposicional.

En 1942, mientras los únicos ordenadores funcionales del mundo eran el ENIAC (que había que recablear para cada problema) y el Harvard Mark I, Zuse comenzó formalmente a esbozar las ideas de su lenguaje de programación. El proyecto arrancó como parte de su tesis doctoral: «Ansätze einer Theorie des allgemeinen Rechnens» (Aproximación a una teoría general del cálculo).

Hinterstein: aislamiento y creación

En 1945, la guerra destruyó todos los ordenadores de Zuse excepto el Z4. Tras la caída de la Alemania nazi, Zuse logró rescatar el Z4 y trasladarlo al pequeño pueblo alpino de Hinterstein (parte de Bad Hindelang, en Baviera). Allí, aislado por la situación de posguerra y sin posibilidad de avanzar en hardware — la ocupación aliada prohibió temporalmente la investigación en computación en Alemania —, dedicó todo su esfuerzo intelectual a desarrollar el Plankalkül.

La versión final fue completada en 1946. En 1944, Zuse ya había discutido su trabajo con el lógico y filósofo alemán Heinrich Scholz, quien expresó su profunda apreciación por la utilización del cálculo lógico por parte de Zuse.

La «Bella Durmiente» de la programación

En 1948, Zuse publicó un artículo en la revista Archiv der Mathematik y presentó su trabajo en la Reunión Anual de la GAMM (Sociedad de Mecánica y Matemáticas Aplicadas de Alemania). Sin embargo, no recibió apenas atención: en aquella época, programar un ordenador sólo se concebía mediante código máquina.

Nueve años después, en una conferencia de 1957, un Zuse que no se rendía expresaba su esperanza: «Después de algún tiempo, como la Bella Durmiente, aún está por despertar a la vida.»

La razón principal de la tardía publicación completa (1972) fue que Zuse se volcó en dirigir su empresa Zuse KG, que se convirtió en una de las pioneras de la industria informática alemana entre 1949 y 1964.

Cronología completa del lenguaje Plankalkül

Año	Hito
1938	Zuse termina la Z1 y desarrolla su Bedingungskombinatorik
1941	Terminada la Z3, primer ordenador digital programable funcional
1942	Comienza el diseño formal de Plankalkül; escribe un programa de ajedrez
1943	Inicio de la tesis doctoral que describe el lenguaje
1944	Reunión con Heinrich Scholz, que valora el uso del cálculo lógico
1945	Destrucción de los ordenadores. Zuse se traslada a Hinterstein con la Z4
1946	Versión final del Plankalkül completada
1948	Artículo publicado en Archiv der Mathematik. Escasa repercusión
1958	La GAMM y la ACM crean ALGOL 58, inspirándose parcialmente en Plankalkül
1972	Publicación completa por la GMD (Gesellschaft für Mathematik und Datenverarbeitung)
1975	Joachim Hohmann crea el primer compilador (tesis doctoral, TU Darmstadt)
1998	Implementación en la Universidad Libre de Berlín (Raúl Rojas y equipo)
2000	Nueva implementación con notación linealizada (Plankalkül 2000)

Características técnicas de Plankalkül

Utilizando terminología de programación moderna, Plankalkül es un lenguaje de programación imperativo de alto nivel con características que hoy resultan sorprendentemente actuales. El propio Heinz Rutishauser, cofundador de ALGOL, reconoció que «el primer intento de idear un lenguaje algorítmico fue realizado en 1948 por K. Zuse. Su notación era bastante general, pero la propuesta nunca alcanzó la consideración que merecía.»

José E. Marchesi, fundador de GNU Spain, describió Plankalkül como «un lenguaje muy anciano y que al mismo tiempo resulta sorprendentemente actual. Personalmente, es ahora, en el siglo XXI, cuando estoy comenzando a ver lenguajes que puedan compararse con Plankalkül en riqueza expresiva y potencia denotacional.»

Tipos de datos

• Tipo primitivo único: Un solo bit (S0), que Zuse denominaba Ja-Nein-Werte (valores sí-no).
• A partir de los bits se construyen: números enteros (n × S0, por ejemplo 8.0 para un entero de 8 bits), números reales (con punto flotante y un esquema similar al bit implícito que se usa actualmente en IEEE 754), arrays (matrices de dimensiones arbitrarias) y registros (estructuras compuestas).

Variables

Plankalkül utiliza tres tipos de variables con letras específicas:

Variable	Nombre alemán	Función
V	Variablen	Parámetros de entrada (paso de argumentos)
Z	Zwischenwerte	Valores intermedios (variables locales/temporales)
R	Resultatwerte	Resultados de salida

La primera asignación a una variable se consideraba su declaración. No existían declaraciones previas: el tipo se especificaba en el momento de uso.

Estructuras de control

• Asignación: Uso del operador ⇒ (Ergibtzeichen), leído de izquierda a derecha. En la conferencia de ALGOL 58, los participantes europeos propusieron adoptar este símbolo de Zuse, pero la delegación americana insistió en :=.
• Condicional: Sin cláusula else, usando el Bedingt-Zeichen (signo condicional).
• Iteración: Estructura W (de Wiederholung, repetición), similar a un bucle while.
• Sentencia Fin: Con superíndice para saltar fuera de varios niveles de anidamiento de bucles.
• Sin GOTO: Plankalkül no incluía instrucción goto.

Otras características avanzadas

• Funciones reutilizables (no recursivas), llamadas subrutinas o «planes» (Rechenpläne).
• Aritmética de punto flotante.
• Operadores lógicos: AND (∧), OR (∨) y NOT (¬).
• Operadores de cuantificación: Operadores «existe» (∃) y «para todo» (∀), tomados del cálculo de predicados.
• Operador µ: Selecciona el siguiente componente que cumple una propiedad.
• Manejo de excepciones y ejecución dirigida por objetivos.
• Grafos generalizados (verallgemeinerter Graph) para representar estructuras geométricas.
• Aserciones (precondiciones sobre datos).

La notación bidimensional: la sintaxis más peculiar de la historia

Una de las características más distintivas — y también la mayor barrera para su adopción — es la notación bidimensional de Plankalkül. Inspirada en la Begriffsschrift de Gottlob Frege (1879), cada instrucción se escribía en varias líneas verticales:

| V  | 1  |    ⇒  | Z  | 2  |
| K  |    |       | K  |    |
| S  | 8.0|       | S  | 8.0|

Donde:

• Primera fila: Tipo de variable (V, Z o R) y la operación.
• Fila V (Variablen-Index): Número de la variable y subíndices.
• Fila K (Komponenten-Index): Índice del componente (para acceder a elementos de arrays o registros).
• Fila S (Struktur-Index): Tipo de dato (por ejemplo, 8.0 = entero de 8 bits).

En notación moderna, algo como V0[0][i][j] se expresaría con los índices escritos verticalmente, uno debajo de otro.

Ejemplos de código en Plankalkül

Asignación simple

Notación bidimensional original (sumar V0 + V1 y guardar en R0):

| V0  +  V1  ⇒  R0 |
| K              K   |
| S   8.0   8.0  8.0 |

Notación lineal (Plankalkül 2000):

V0[:8.0] + V1[:8.0] => R0[:8.0]
Lenguaje del código: PHP (php)

Equivalente en Python:

R0 = V0 + V1

Función para calcular el máximo de tres números

Este ejemplo usa la notación linealizada desarrollada para la implementación del año 2000:

P1 max3 (V0[:8.0],V1[:8.0],V2[:8.0]) → R0[:8.0]
  max(V0[:8.0],V1[:8.0]) → Z1[:8.0]
  max(Z1[:8.0],V2[:8.0]) → R0[:8.0]
END

P2 max (V0[:8.0],V1[:8.0]) → R0[:8.0]
  V0[:8.0] → Z1[:8.0]
  (Z1[:8.0] < V1[:8.0]) → V1[:8.0] → Z1[:8.0]
  Z1[:8.0] → R0[:8.0]
END
Lenguaje del código: CSS (css)

Equivalente en Python:

def max3(v0, v1, v2):
    z1 = max(v0, v1)
    return max(z1, v2)

def max_func(v0, v1):
    z1 = v0
    if z1 < v1:
        z1 = v1
    return z1
Lenguaje del código: JavaScript (javascript)

«Hello, World!» en Plankalkül

Plankalkül no fue diseñado con instrucciones de entrada/salida convencionales, pero usando la notación lineal de la implementación del año 2000, el clásico «Hello, World!» se escribiría así:

R1.1(V0[:sig]) => R0

R1.2(V0[:m x sig]) => R0
  0 => i | m + 1 => j
  [W [ i < j -> [
    R1.1(V0[i: m x sig]) => R0
    | i + 1 => i
  ] ] ]
END

R1.3() => R0
  'H';'e';'l';'l';'o';',';' ';'w';'o';'r';'l';'d';'!' => Z0[: m x sig]
  R1.2(Z0) => R0
END
Lenguaje del código: PHP (php)

Desglose del programa:

• R1.1: Función que procesa un solo carácter (sig = tipo carácter).
• R1.2: Función que itera sobre un array de caracteres usando un bucle W (while), recorriéndolos desde la posición 0 hasta m.
• R1.3: Programa principal que crea el array con los caracteres 'H','e','l','l','o',',',' ','w','o','r','l','d','!' y llama a R1.2 para procesarlos.

Equivalente en Python:

def procesar_caracter(c):
    print(c, end='')

def procesar_cadena(cadena):
    i = 0
    while i < len(cadena):
        procesar_caracter(cadena[i])
        i += 1

def hello_world():
    mensaje = ['H','e','l','l','o',',',' ','w','o','r','l','d','!']
    procesar_cadena(mensaje)

hello_world()  # Salida: Hello, world!
Lenguaje del código: PHP (php)

El programa de ajedrez: 49 páginas de algoritmos

Uno de los logros más impresionantes de Zuse fue escribir un programa completo de ajedrez en Plankalkül, que ocupa 49 páginas de su manuscrito original. Además del ajedrez, desarrolló algoritmos para:

• Ordenación de arrays (similar a insertion sort).
• Prueba de conectividad de grafos.
• Aritmética de enteros, incluyendo cálculo de raíz cuadrada.
• Análisis sintáctico de fórmulas lógicas.

Todo esto entre 1942 y 1946, décadas antes de que existieran lenguajes como Fortran (1957) o LISP (1958).

Comparativa: Plankalkül vs. lenguajes modernos

Característica	Plankalkül (1945)	C (1972)	Python (1991)
Tipo primitivo	Bit (S0)	char/int	int/float/str
Arrays	Sí, multidimensionales	Sí	Sí (listas)
Registros/Structs	Sí	Sí (struct)	Sí (class/dict)
Funciones	Sí (no recursivas)	Sí (recursivas)	Sí (recursivas)
Condicional	Sí (sin else)	Sí (if/else)	Sí (if/elif/else)
Bucle while	Sí (W)	Sí	Sí
GOTO	No	Sí	No
Punto flotante	Sí	Sí	Sí
Operadores lógicos	∧, ∨, ¬	&&, ||, !	and, or, not
Cuantificadores (∀, ∃)	Sí	No	No (nativo)
Notación	Bidimensional	Lineal	Lineal
Primer compilador	1975	1972	1991

La influencia de Plankalkül en lenguajes posteriores

Aunque Plankalkül no tuvo impacto directo inmediato, su influencia se dejó sentir cuando finalmente fue conocido:

• ALGOL 58/60: La GAMM, inspirándose en Plankalkül, unió fuerzas con la ACM para crear ALGOL. Los europeos propusieron el operador de asignación ⇒ de Zuse, pero se acabó adoptando :=.
• Comparaciones con APL: Plankalkül ha sido comparado con APL y con el álgebra relacional por sus capacidades de manipulación de estructuras de datos.
• Lenguajes «no von Neumann»: En algunos aspectos, Plankalkül es más potente que el modelo de programación von Neumann que dominó durante décadas. Para encontrar conceptos similares hay que buscar en lenguajes como APL o el álgebra relacional.

Implementaciones y compiladores

Primer compilador (1975)

Joachim Hohmann desarrolló el primer compilador interpretativo en su tesis doctoral en la Universidad Técnica de Darmstadt.

Implementación de Berlín (1998-2000)

El equipo de Raúl Rojas en la Universidad Libre de Berlín creó una implementación completa que incluía:

• Un editor dirigido por sintaxis que generaba código en la notación bidimensional original de Zuse.
• Una notación linealizada (Plankalkül 2000) que permitía escribir programas con cualquier editor de texto.
• Un parser construido con el sistema generador de compiladores Cocktail.
• Un intérprete en Java capaz de ejecutar los algoritmos originales de Zuse.

Los primeros programas en Plankalkül se ejecutaron en febrero del año 2000, 55 años después de su concepción.

¿Por qué Plankalkül es importante hoy?

El legado de Konrad Zuse y su lenguaje Plankalkül va más allá de la curiosidad histórica:

1. Demostró que era posible abstraer la programación del código máquina, décadas antes de Fortran.
2. Introdujo el operador de asignación (⇒), un concepto fundamental en todos los lenguajes actuales.
3. Anticipó las estructuras de datos compuestas (arrays, registros) que son pilares de la programación moderna.
4. Incluyó operadores del cálculo de predicados (∀, ∃, µ) que hoy se encuentran en lenguajes funcionales y en SQL.
5. Rechazó el GOTO antes de que Dijkstra lo hiciera famoso con su carta de 1968 «Go To Statement Considered Harmful».

Como señaló Friedrich L. Bauer: «Cualquiera que haya tenido la oportunidad de estudiar la definición original de Plankalkül queda asombrado por su sorprendente carácter actual — parece como si hubiera sido creado mucho después de 1945.»

Recursos y referencias

• Tesis original de Zuse (1945): disponible en el Deutsches Museum Digital
• Publicación de 1972: Zuse, K. «Der Plankalkül». Gesellschaft für Mathematik und Datenverarbeitung, Nr. 63.
• Artículo de Friedrich L. Bauer: «The Plankalkül of Konrad Zuse: A Forerunner of Today’s Programming Languages»
• Implementación de Berlín: Rojas, R. et al. (2000). «Plankalkül: The First High-Level Programming Language and its Implementation». Technical Report B-3/2000, Freie Universität Berlin.
• Libro: Rojas, R. (2023). «Plankalkül» en Konrad Zuse’s Early Computers. History of Computing. Springer.
• Artículo de Knuth y Pardo: «The Early Development of Programming Languages» (1976), Stanford University, que incluye la implementación del algoritmo TPK en Plankalkül.
• Wikipedia: Plankalkül en Wikipedia