The history of the Plankalkül programming language starts in wartime Germany, with an engineer who had already built working computers and wanted a better way to describe what they should compute. Konrad Zuse designed Plankalkül ("plan calculus") between roughly 1942 and 1945, which makes it the first known design for a high-level programming language. It was not implemented during the years Zuse was writing it, yet many of its ideas turned up in languages that appeared a decade or more later.
Origins: Konrad Zuse and the Z-series machines
Zuse completed the Z3 in Berlin in 1941, an electromechanical, program-controlled binary computer, and was working on the larger Z4 as the war came to an end. Programs for his machines were punched as instruction codes onto discarded film stock, a slow process tied closely to the hardware. Plankalkül was his attempt to write down algorithms independently of any particular machine, in a notation closer to mathematics and logic.
Much of the work was finished in 1945, after Zuse had moved the Z4 out of Berlin and taken refuge in the Allgäu region of Bavaria. With no way to run the machine for real work, he spent the time on theory. A short description appeared in 1948 in the journal Archiv der Mathematik, but the full manuscript was not published until 1972. That long gap is a big reason Plankalkül had less direct influence than its ideas deserved.
Design and key features
For a design of the 1940s, Plankalkül was strikingly modern. Its main features included:
- Data types built from bits. The single bit was the basic type, and from it Zuse composed integers, floating-point numbers, arrays and record-like compound structures.
- Assignment. Results were written with an arrow-like symbol pointing from the expression to the variable that received the value.
- Subroutines, called plans, which took inputs and returned results.
- Conditional execution and iteration, including constructs for repeating a block of statements.
- Assertions, logical expressions describing conditions that the program's values should satisfy.
Variables were grouped by role: V for input values, Z for intermediate values, R for results and C for constants. The notation was two-dimensional. A main line held the operation, and rows beneath it gave the variable number, the component being accessed and the data type. That layout was readable on paper but impractical for the punched media of the time, which helped keep a compiler out of reach in the late 1940s.
Illustrative notation
The snippet below is an illustrative, linearised rendering, not Zuse's original two-dimensional layout. It shows the general shape of a plan that adds two inputs and delivers the sum as its result:
P1 (V0, V1) => R0 plan P1: inputs V0, V1; result R0
V0 + V1 => Z0 store the sum in intermediate value Z0
Z0 => R0 assign Z0 to the result R0
ENDZuse's manuscript went well beyond toy arithmetic. He wrote example plans for sorting, for testing the connectivity of graphs and for checking Boolean expressions, and he devoted a considerable part of the work to chess, including routines for describing and evaluating positions. Few people in the 1940s were thinking about non-numerical programming at all.
From paper to implementation
For decades Plankalkül existed only as a written specification. Its path to a running system was slow:
| Year | Milestone |
|---|---|
| 1942–1945 | Zuse develops the language, completing most of it in 1945 |
| 1948 | First published description in Archiv der Mathematik |
| 1972 | Full manuscript published |
| 1975 | Joachim Hohmann describes an implementation in his dissertation |
| 1998–2000 | A team at the Free University of Berlin led by Raúl Rojas builds an implementation |
The Berlin work had to make choices Zuse never fixed, such as a practical linear syntax and details of program structure, so modern implementations are faithful reconstructions rather than exact copies of something that once ran.
Influence and legacy
Plankalkül's influence was real but indirect. It is generally counted among the influences on Heinz Rutishauser's Superplan, an early formula-compiling system from Zurich, and through the European side of the effort on ALGOL 58. Ideas that Zuse wrote down in the 1940s, including typed compound data, assignment as a distinct operation and assertions about program state, became mainstream only through later languages that arrived independently.
Historians usually describe Plankalkül as the first high-level programming language to be designed, while giving credit for the first languages actually implemented and used to systems such as Short Code and Autocode in the early 1950s.
Is Plankalkül used today?
No. It has no production compilers, no user community and no practical niche. Its value today is historical and educational: it shows how far one person could push the idea of programming before the field had shared vocabulary or working compilers.
Anyone tracing the history of the Plankalkül programming language reaches a slightly uncomfortable conclusion. The first high-level language was designed, documented and largely overlooked before Fortran existed. Zuse got many of the concepts right; what he lacked was timely publication, suitable hardware and a community to carry the work forward.
Frequently asked questions
Was Plankalkül the first high-level programming language?
It is generally regarded as the first designed high-level programming language, since Zuse's work dates to 1942–1945. It was not the first to be implemented and used, though. That distinction belongs to early systems such as Short Code and Autocode from the first half of the 1950s.
Why was Plankalkül not implemented in the 1940s?
Zuse had no suitable machine to target in the immediate postwar years, and the two-dimensional notation was awkward to put onto punched media. The full description also stayed unpublished until 1972. The first implementation was described in 1975, with a fuller one built around 2000.
What does the name Plankalkül mean?
It is German for "plan calculus", a formal system for writing plans. Zuse called a program a computation plan, and Plankalkül was the notation for expressing such plans precisely, independent of any one machine.
