Deploy Plankalkül to Europe — Konrad Zuse 🇩🇪 (Berlin 1942), the First Programming Language in History, on EU Infrastructure in 2026
Every programming language you have ever written — Python, JavaScript, Go, Rust, TypeScript, Java — descends, directly or indirectly, from a conceptual framework designed by a German civil engineer in Berlin, between 1942 and 1945, in a city being bombed to rubble, with no knowledge of what Alan Turing in England or John von Neumann in America were thinking about computation.
Plankalkül — the Plankalkühl or "Program Calculus" — was designed by Konrad Zuse 🇩🇪 as the programming language for his series of Z-series computers. It was the first complete programming language ever designed. Not the first compiled, not the first implemented — the first designed, in the full sense: a formal notation with data types, variables, arrays, nested composite data structures, loops, conditional branching, subroutines, and even a rudimentary form of recursion. All of this in 1942–1945. All written by hand in mathematical notation by a single engineer.
The fact that Plankalkül was never implemented during Zuse's most productive years, that it was published only in 1948 and not widely read until the 1970s, and that its author spent decades rebuilding his work from rubble, does not diminish its intellectual achievement. It magnifies it. Zuse arrived at the essential concepts of programming, independently, before anyone else. European computing does not begin with ALGOL in 1958 or with the Manchester Baby in 1948. It begins with Plankalkül in 1942.
Konrad Zuse 🇩🇪 and the Z-Series: Computing Born in Berlin
Konrad Zuse was born in 1910 in Berlin-Wilmersdorf. He studied civil engineering at the Technische Hochschule Berlin-Charlottenburg (today Technische Universität Berlin 🇩🇪) and graduated in 1935. During his studies he became frustrated with the tedious numerical calculations required in structural engineering — the kind of repetitive arithmetic that occupied teams of human "computers" in every engineering firm. He decided to build a machine to do it automatically.
Z1 (1936–1938, Berlin, Methfesselstraße 7): Zuse built the Z1 in his parents' living room in Berlin using scrap metal, funding the project himself. The Z1 was a mechanical binary floating-point computer — the first of its kind. The mechanical relays were cut from sheet metal with a hand saw. It was programmable via punched film strips cut from discarded 35mm movie film. It was unreliable due to the mechanical tolerances, but it proved the concept: a general-purpose binary computing machine could be built from scratch by one person.
Z2 (1939, Berlin): Zuse rebuilt the arithmetic unit using telephone relays (electromagnetic, not mechanical) while keeping the mechanical memory. More reliable, but still experimental. By this time, Zuse had secured support from the Deutsche Versuchsanstalt für Luftfahrt (DVL — German Aeronautics Research Institute) for his subsequent work. The DVL would fund and house the Z3.
Z3 (December 1941, Berlin, Methfesselstraße): The Z3 was the world's first freely programmable, fully automatic, electromechanical computer. It used 2,600 telephone relays for computation and memory, operated on 22-bit binary floating-point numbers, and was programmable via punched film strips. Crucially, the Z3 implemented: floating-point arithmetic, programme loops via loop-back of the punched tape, and conditional jumps via a flag register.
On 12 May 1941, the Z3 was first operated successfully, executing a demonstration program at the DVL's Berlin premises. This is, by most historical accounts, the birth of the programmable computer. ENIAC (Electronic Numerical Integrator and Computer, Philadelphia) would not run its first program until February 1946 — nearly five years later. The Manchester Small-Scale Experimental Machine (the "Baby") first ran a stored-program in June 1948.
Zuse built the first programmable computer in 1941, in Berlin, from telephone relays.
The Z3 was destroyed in an Allied bombing raid on 21 December 1943. A replica, built in 1960 by Zuse and later donated to the Deutsches Museum in Munich 🇩🇪, is on permanent display there.
Plankalkül: Designing a Language in Wartime Berlin
While building the Z3, Zuse recognised that hardware alone was insufficient. He needed a formal notation for expressing algorithms — a language in which programmes could be written, studied, communicated, and eventually fed to a machine. Between 1942 and 1945, working in isolation in Berlin and later in the Bavarian Alps (where he evacuated after the bombing intensified), he designed Plankalkül — Plan (German: programme, Rechenplan = computation plan) + Kalkül (German: calculus, formal system).
Plankalkül was not a simple assembly-level instruction set. It was a high-level programming language in the modern sense. Its features, designed entirely by Zuse before any other programming language had been conceived:
Typed variables with composite data structures: Plankalkül had a type system. Variables had types, and types could be composite — "Komponenten" (components), which are analogous to structs or records. A variable of type V2.1.m referred to the m-th component of the second component of a variable of type 1 (bit). This notation was hierarchical: you could nest data structures to arbitrary depth. The type system preceded ALGOL's structured types by fifteen years.
Arrays: Plankalkül supported one-dimensional and multi-dimensional arrays of typed elements. Zuse called these "Felder" (fields). Array indexing with variable indices — not just constants — was supported. This is the essential prerequisite for all numerical algorithms.
Conditionals (Bedingungen): Plankalkül had conditional expressions. A programme could take different computational paths based on the value of a boolean expression. Without conditionals, a computer is merely a calculator; with them, it becomes a general-purpose problem solver.
Loops (Wiederholungen): Plankalkül had both definite iteration (iterate N times) and indefinite iteration (iterate while a condition holds). The combination of loops and conditionals gives Plankalkül Turing-completeness — the ability to compute any computable function given sufficient time and memory.
Subroutines (Unterprogramme): Plankalkül supported subroutine definitions and calls, with input and output parameters. The subroutine mechanism in Plankalkül is sophisticated: it supports output parameters (return values), multiple return values, and local variables — capabilities that FORTRAN (1957) would struggle with and ALGOL 60 (1960) would finally handle cleanly.
Assertions and invariants: Zuse included a mechanism for writing programme assertions — conditions that should hold at a given point in the computation. This concept, which Tony Hoare would formalise as Hoare Logic in 1969 (winning him the Turing Award 1980), appeared in Plankalkül twenty-seven years earlier.
The notation was two-dimensional — the kind of mathematical tabular notation that a civil engineer comfortable with structural calculation sheets would naturally design:
; Plankalkül notation (approximate ASCII rendering)
; A programme to compute the maximum of two numbers A and B
P1 | K1 | K2
---+----+----
| A | B
| |
| R |
Indices and subscripts were written below the main line; types above or alongside. The notation was designed to be written on paper, not typed — a limitation that would contribute to its historical obscurity when the typewriter and teletypewriter became the standard interfaces for programme preparation.
The First Chess Programme in History
In 1945, Zuse used Plankalkül to write the first chess programme in the history of computing. The programme — documented in his manuscripts — evaluated chess positions and selected moves according to a minimax-like evaluation function. It included:
- A representation of the chess board as an 8×8 array of piece types
- Functions for generating legal moves for each piece type
- An evaluation function assigning numerical scores to board positions
- A search procedure selecting the move that maximised the evaluation score
This chess programme predates Claude Shannon's seminal paper "Programming a Computer for Playing Chess" (1950) by five years. Shannon is widely credited with founding computer chess; Zuse designed a chess programme before Shannon published. The manuscripts were in German and not widely accessible to the English-speaking research community.
The chess programme was never executed on any physical machine in 1945. The Z3 had been destroyed in 1943, and the Z4 (Zuse's next machine) was evacuated to Hinterstein in Bavaria to protect it from bombing. But the intellectual achievement stands: Zuse wrote the first documented chess algorithm using a formal programming language of his own design.
Isolation and Independence: What Zuse Did Not Know
The historical significance of Plankalkül is amplified by what Zuse did not know. Germany in the early 1940s was scientifically isolated from the Allied nations. Zuse had no access to:
- Alan Turing's 1936 paper ("On Computable Numbers") establishing the theoretical framework for universal computation. Turing's paper was published in England; Zuse had not read it.
- John von Neumann's 1945 "First Draft of a Report on the EDVAC" — the foundational document for the stored-program architecture. Von Neumann wrote it in 1945; Zuse was in Bavaria.
- Alonzo Church's lambda calculus (1932-1936) — the mathematical theory of functions that underlies functional programming languages.
- John Atanasoff's ABC computer (Iowa State, 1939-1942) — another early electronic computer project, which Zuse was unaware of.
Working entirely independently, using only his engineering training and his direct experience building and programming the Z1, Z2, and Z3, Zuse arrived at substantially the same conceptual conclusions about the structure of a programming language that the rest of the computing world would arrive at over the following twenty years.
This parallel, independent development is one of the most striking facts in the history of computing: the essential concepts of programming — types, variables, composite data, loops, conditionals, subroutines — were not inevitable logical derivations from a single source. They were discovered independently, from first principles, by at least two intellectual communities (European/Zuse and American/British/Turing-von Neumann) who were at war with each other and could not communicate.
Reconstruction: Zuse KG and the Z4 at ETH Zürich
After Germany's defeat in May 1945, Zuse evacuated the Z4 computer to Hinterstein, a small village in the Allgäu Alps of Bavaria, where it was hidden in a barn. He spent the immediate postwar years in the Bavarian countryside, working on his programming language theory and writing up Plankalkül.
In 1948, Zuse moved to Hopferau (also Allgäu) and completed his manuscript on Plankalkül: "Über den allgemeinen Plankalkül als Mittel zur Formulierung schematisch-kombinativer Aufgaben" (On the General Plan Calculus as a Means for Formulating Schematic-Combinatorial Tasks). This manuscript, though circulated among some German researchers, was not published in a widely accessible venue. The English-speaking computing community proceeded to develop FORTRAN (1957), LISP (1958), COBOL (1959), and ALGOL 60 (1960) largely without awareness of Plankalkül.
In 1950, Zuse's Z4 computer — the only surviving Z-series machine — was installed at ETH Zürich 🇨🇭 (the Eidgenössische Technische Hochschule), where it became the first computer in continental Europe to be used for scientific computation. ETH Zürich thus became the first Swiss and one of the first European institutions to operate a programmable computer — the same institution where Niklaus Wirth 🇨🇭 would later design Pascal (1970), Modula-2 (1978), and Oberon (1987), and where Robert Griesemer 🇨🇭 would begin work that led to Go's package system (PhD under Wirth).
In 1949, Zuse founded Zuse KG (Zuse Kommanditgesellschaft) in Bad Hersfeld, Hessen 🇩🇪 — one of the first computer companies in Europe. Zuse KG built and sold over 250 computers between 1949 and 1969, when the company was acquired by Siemens 🇩🇪. The Z11 (1955) was used by the Carl Zeiss Foundation 🇩🇪 in Jena for optical calculations; the Z22 (1955) was the first transistorised Zuse computer. Zuse KG's commercial activity established the German commercial computing industry years before IBM's dominance in Europe.
First Implementation: Hohmann 1975 and the Berlin 2000 Implementation
Plankalkül was not implemented during Zuse's most productive years. The first working implementation was created by Joachim Hohmann 🇩🇪 at the Technische Hochschule Darmstadt in 1975 — thirty-three years after Zuse designed the language. Hohmann's implementation was a compiler that translated a subset of Plankalkül to assembly code, demonstrating that Zuse's language design was indeed technically correct and implementable.
A more complete implementation was created in 2000 by a team at the Freie Universität Berlin 🇩🇪 (Free University of Berlin) — an ironic homecoming, as Zuse had designed the language in Berlin during wartime. The FU Berlin implementation compiled Plankalkül to C, providing a working Plankalkül interpreter and demonstrating the language's features including composite data types, loops, and conditionals. The implementation was released as open-source academic software.
In 2005, Zuse's original 1945 manuscript on Plankalkül was published in full, with English translation and commentary, as part of the Konrad Zuse Internet Archive maintained by the Gesellschaft für Informatik (German Informatics Society) 🇩🇪. The original handwritten documents are preserved at the Konrad Zuse Zentrum für Informationstechnik Berlin (ZIB — Zuse Institute Berlin) 🇩🇪, the scientific computing research centre that bears his name and continues his legacy.
EU Regulatory Alignment: Plankalkül as Predecessor to Safe Systems Design
The concepts embedded in Plankalkül — type safety, structured data, explicit programme structure, formal assertion support — are the conceptual ancestors of the techniques that EU legislation now mandates for high-integrity systems.
EU AI Act (Regulation 2024/1689), Article 9 — Risk Management System: High-risk AI systems must undergo systematic risk management including formal verification of system behaviour under specified conditions. The assertion mechanism in Plankalkül — conditions that must hold at programme points — prefigured the Hoare Logic and Design by Contract approaches that underpin formal verification tools today (Frama-C 🇫🇷, KeY 🇩🇪, SPARK Ada 🇬🇧).
EU AI Act, Article 10 — Data and Data Governance: Training data and computational pipelines must be documented and their transformations traceable. Plankalkül's explicit type annotations and structured data access patterns (Komponenten hierarchy) provide the kind of programme-level documentation that makes data transformation auditable. A Plankalkül programme, by its structure, forces explicit declaration of all data types and all data access patterns.
GDPR Article 25 — Data Protection by Design and by Default: Plankalkül's composite data type system — where each datum has an explicit declared type and hierarchical structure — enables the kind of data-structure-level access control that GDPR Article 25 requires. You cannot accidentally access a field you have not declared; type errors are structural, not runtime surprises.
GDPR Article 5(1)(f) — Integrity and Confidentiality: Plankalkül's deterministic computation model — fixed inputs produce fixed outputs, with no hidden side effects not declared in the programme's structure — prefigures the principle of computational integrity that GDPR requires for automated processing of personal data.
NIS2 Directive (2022/2555), Critical Infrastructure Protection: The deterministic, formally specifiable nature of Plankalkül-influenced computation — where programmes have explicit structure and assertions — aligns with NIS2's requirements for software supply chain transparency and systems resilience in operators of essential services.
Plankalkül's Lineage: From Berlin to Every Language You Write Today
Plankalkül's influence on subsequent programming languages is indirect but real, operating through two pathways:
Pathway 1: Through ALGOL 60. ALGOL 60 was designed by an international committee (Peter Naur 🇩🇰, John Backus 🇺🇸, Edsger Dijkstra 🇳🇱, Friedrich Bauer 🇩🇪, and others) that was aware of Zuse's work. The ALGOL 60 report acknowledges Zuse's Plankalkül as an antecedent. ALGOL 60's block structure, scoped variables, typed parameters, and structured control flow are the direct ancestors of Pascal, Modula-2, Ada, C, and every subsequent imperative language.
Pathway 2: Through the history of ideas. Even where direct citation is absent, Plankalkül demonstrates that the concepts of typed structured programming were independently discoverable from first principles by a trained engineer applying systematic thought to the problem of expressing algorithms. This historical fact influenced the philosophy of language design — the understanding that certain ideas (types, structure, assertion) are not accidental historical contingencies but natural discoveries that any careful thinker arrives at.
Plankalkül (Zuse 🇩🇪, 1942-1945, Berlin)
↓ conceptual lineage (via ALGOL committee's awareness)
ALGOL 60 (Naur 🇩🇰 + Bauer 🇩🇪 + Dijkstra 🇳🇱 + Backus 🇺🇸, 1960)
↓ ↓ ↓
Pascal (Wirth 🇨🇭, 1970) C (Ritchie 🇺🇸, 1972) Simula (Dahl+Nygaard 🇳🇴, 1967)
↓ ↓ ↓
Modula-2 (Wirth 🇨🇭, 1978) C++ (Stroustrup 🇩🇰) Smalltalk, Eiffel, Java, ...
↓
Oberon (Wirth 🇨🇭, 1987)
↓ (Robert Griesemer 🇨🇭 PhD under Wirth → Go package system)
Go (Google, 2009)
Python ← ABC (Meertens 🇳🇱 + Geurts 🇳🇱, CWI Amsterdam, 1987)
TypeScript ← Anders Hejlsberg 🇩🇰 (Copenhagen → Borland → Microsoft)
Rust ← borrow checker ← Milner's type theory (Edinburgh 🏴)
Every branch of this tree can be traced, with varying directness, to the European computing tradition that Konrad Zuse initiated in Berlin in 1942.
Deploying Your Systems to EU Infrastructure with sota.io
Plankalkül was never executed on a computer during the years its author designed it. The machines did not exist, then were destroyed, and the war scattered their maker across Bavaria. But the ideas persisted — on paper, in manuscripts, in a tradition of careful formal thinking about programmes and data and structure that European computer scientists have maintained continuously from Zuse's Berlin to today.
When you deploy your application to sota.io, you deploy it to the same European infrastructure tradition. German data centres. GDPR compliance by design — not as an afterthought, not as a compliance checkbox, but as the structural foundation of the service. Managed PostgreSQL 17 with automatic backups, connection pooling, and no cross-border data transfers. An EU-native platform-as-a-service built for developers who want to build in Europe, for Europe.
# Deploy your service to EU infrastructure in minutes
curl -fsSL https://cli.sota.io/install.sh | sh
sota login
sota deploy --region eu-central-1
# A modern container — descended from decades of EU computing ideas
FROM debian:bookworm-slim
WORKDIR /app
COPY . .
RUN apt-get update && apt-get install -y \
build-essential \
&& rm -rf /var/lib/apt/lists/*
RUN make
CMD ["./myservice"]
Konrad Zuse designed Plankalkül in a city under bombardment, with no collaborators, no funding beyond a German aeronautics institute's interest in numerical calculation, and no knowledge of what the rest of the computing world was thinking. He designed it because the problem needed solving and he was the person who saw how to solve it.
That is the European computing spirit. sota.io is built in the same tradition.
See also: Deploy ALGOL to Europe → — Peter Naur 🇩🇰 (Copenhagen, Turing Award 2005) + Edsger Dijkstra 🇳🇱 (CWI Amsterdam, Turing Award 1972) + Friedrich Bauer 🇩🇪 (TH Munich), the first international programming language standard that carried Plankalkül's ideas into practice. Deploy BCPL to Europe → — Martin Richards 🇬🇧 (Cambridge Mathematical Laboratory, 1967), the ancestor of C through which Plankalkül's structured programming vision reached every modern systems language. Deploy Modula-2 to Europe → — Niklaus Wirth 🇨🇭 (ETH Zürich, Turing Award 1984), the Swiss–German engineering tradition that continued Zuse's discipline of minimal, correct, type-safe language design.