Diff — Plankalkül

{{infobox

| title = Plankalkül

| designed_by = [[Konrad Zuse]]

| designed = 1942–1945 — written in wartime Germany, mostly in hiding in the Allgäu

| published = abstract 1948 · full text 1972

| first_implemented = c. 2000 — by a research team, fifty-five years late

| typing = strong, with user-defined structures

| paradigms = procedural · structured · remarkably modern

| influenced = nothing directly — it was unread until after ALGOL

}}

**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.

```fact The strangest sentence in language history

The first high-level programming language predates the first stored-program computer. Plankalkül was *designed* in 1945; a working implementation had to wait until around **2000**. The language waited fifty-five years for the machine.

```

## 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

```chart Plankalkül's strange journey

process a "designed\n1942–45"

process b "unpublished\nfor decades"

process c "full text\n1972"

process d "first working\nimplementation\nc. 2000"

a -> b -> c -> d

```

## The notation

[[File:plankalkul-notation.svg|right|320px|The two-dimensional statement layout, simplified — operation on the main line, indices stacked below (our diagram)]]

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.

```note A taste of the style

In loose modernized form, a Plankalkül plan for "add two numbers and store the result" reads like `V0 + V1 ⇒ Z0` — operands on the left, the yields sign in the middle, the destination on the right. Underneath, the V/K/S sub-lines pinned down exactly *which* variables and *what* structures were meant. The arrow points the way the data flows — an idea that survives in every `=` and `:=` ever written.

```

## 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 [[Alan Turing|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 — [[Grace Hopper|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.

```alb The ALB connection

Plankalkül and [[AdaLogic BASIC]] are bookends of the same argument: **notation belongs to everyone.** Zuse designed a language for machines that didn't exist; ALB is a language for people who've been told programming isn't for them. Eighty years apart, the bet is the same — that what you can *write down precisely*, a machine can *do*.

```

## 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]]

[[Category:Languages]]

[[Category:History]]