Plankalkül

Plankalkül — "plan calculus" — is the first high-level programming language ever designed. Konrad Zuse conceived it between 1942 and 1945, while the machines it was meant for were being built in his living room and then destroyed in air raids. It had typed variables, arrays, structured records, conditionals, loops, and subroutines — in 1945, twelve years before FORTRAN, fourteen before ALGOL, in a notebook in a farmhouse in the Alps. Nobody could run it. Almost nobody could read it. It is the great lost design of programming history.

What it was for

Zuse did not set out to invent "a programming language" — the phrase did not exist. He wanted a calculus: a formal system for writing down computational plans precisely, the way civil engineers wrote down statics. The Plankalkül was to be the universal notation for describing anything a machine might do — from arithmetic to logic to chess.

The manuscript, written largely in 1945 while Zuse sheltered from the collapsing Reich in the Allgäu village of Hinterstein, describes a language that a 1960s compiler engineer would have recognized instantly — and that no one in 1945 had the conceptual vocabulary to understand.

What it already had

The list reads like a summary of a language from twenty years later:

• Typed data — from single yes/no bits up to integers, floating-point numbers, and user-defined composite structures — records, in modern terms
• Arrays — arbitrary-dimension lists, indexed by sub-variables
• Assignment as a distinct operator — the Ergibt-Zeichen, the "yields sign": a + b ⇒ c — "a plus b yields c." The arrow distinguished assigning from equaling — a subtlety languages would spend decades getting right
• Conditional plans — guarded statements: execute this plan only if the condition holds
• Iteration — Wiederholungspläne, repetition plans: bounded and conditional loops
• Subroutines — numbered plans that could take inputs, return results, and be composed into larger plans: procedural decomposition, before procedures existed
• Full Boolean and predicate logic — Zuse's companion Logistikkalkül meant Plankalkül programs could state and reason about logical conditions, not just arithmetic

The notation

Plankalkül was written in a two-dimensional notation — each statement carried up to four stacked lines:

• the main line — the operation itself (+, ×, the yields sign)
• V — the variable index (which numbered variable)
• K — the component index (which part of a structure or array)
• S — the structure index (the variable's type)

So a single "line" of Plankalkül was really a small table — machine-precise, but demanding to write and more demanding to read. The notation is part of why contemporaries who did encounter it bounced off: Zuse had invented not just the ideas but an uncompromising formalism for expressing them, optimized for the machine's precision rather than the reader's mercy.

Chess — the first computer game

To prove the language could handle more than arithmetic, Zuse wrote Plankalkül plans for chess — position evaluation and move generation — in 1945. It is widely regarded as the first design for a computer game program: years before Shannon's famous 1950 paper and before Turing and Champernowne's Turochamp (1948), a hidden manuscript in the Alps already contained the idea that a machine could play.

Why the world never saw it

Plankalkül's invisibility was overdetermined:

• No machine could run it. The Z3 had 64 words of memory; Plankalkül assumed a machine that existed only as a goal. It was written for the computers of the future — which is another way of saying it described them.
• Nothing existed to compile it. A "compiler" as a concept was still seven years away — Hopper's A-0 was 1952. Zuse was designing the high-level language before the industry had invented the job of translating it.
• The manuscript stayed a manuscript. A short abstract was published in 1948–49; the full text waited until 1972, issued as a research report — by which time FORTRAN, COBOL, ALGOL, and LISP had already happened without it.
• The notation was forbidding. The people best positioned to appreciate it — the designers of the 1950s languages — never studied a two-dimensional German formalism they could barely obtain, let alone parse.

So did it matter?

Directly, almost not at all — and that is the honest answer. FORTRAN's team never saw it; ALGOL's committee never saw it. Programming languages do not inherit through unpublished notebooks.

But indirectly, Plankalkül matters enormously — as evidence. It proves that the high-level language was not an accident of the transistor era: typed structures, assignment, control flow, subroutines — the whole grammar of programming — was worked out once already, in 1945, by an engineer who had never heard the words "programming language." When computer historians Knuth and Pardo surveyed the field's origins in 1976, they gave Plankalkül its own chapter; when a research team finally built a working implementation around 2000, the design — remarkably — worked.

See also

• Konrad Zuse · Z3
• FORTRAN · ALGOL · COBOL · LISP — the languages that arrived later and got the credit
• BASIC — the language that finally made everyone the audience
• History of Programming · Alan Turing
• History of Language — the older story of designed languages

References

1. Zuse, Konrad. The Computer — My Life (Springer, 1993, tr. of Der Computer – Mein Lebenswerk, 1970/1984).
2. Rojas, Raúl. "Konrad Zuse's Legacy: The Architecture of the Z1 and Z3." IEEE Annals of the History of Computing 19(2), 1997.
3. Rojas, Raúl, and Ulf Hashagen, eds. The First Computers: History and Architectures (MIT Press, 2000).
4. Bauer, Friedrich L., and Hans Wössner. "The 'Plankalkül' of Konrad Zuse: A Forerunner of Today's Programming Languages." Communications of the ACM 15(7), 1972.