Unlocking a Lost Programming Language: The Plankalkül Story

Imagine you‘re a programmer in the 1940s. Instead of Python and Java, your "languages" are circuits of wires and boards of spinning relays. To add a simple IF statement, you interconnect a rats nest of metal with tweezers and soldering tools. An impossible maze of electromechanical gates now handles your branch logic.

In this world, a German visionary devised a radical concept – what if programmers could express algorithms with familiar math and logic notation instead? You could solve problems by simply writing formulas rather than constructing control flow from physical components. This high-level language could automate the tedious mapping to circuits or assembly code.

That visionary pioneer was Konrad Zuse, and his invention was Plankalkül – the first high level programming language.

Overview: The Dawn of Abstraction

Today, languages like Java allow us to code by manipulating variables and calling functions rather than micromanaging registers and memory. Concepts are expressed algorithmically rather than converted one-to-one to executable machine code. This abstraction revolutionized programming by enabling more complex and flexible software.

Plankalkül pioneered this layer of abstraction in the early 1940s. For his Ph.D. thesis, Zuse devised a language based on math-like notation for algorithms. It introduced now familiar elements like:

• Variables and Data Structures
• Subroutines for Reuse
• Conditionals and Boolean Logic
• Scoped Local Data
• Loops and Iterators

At the time, programming was done via electrical wiring or numeric machine code. So Zuse‘s symbolic system to capture algorithms was revolutionary. However, World War 2 and technology disinterest doomed Plankalkül to obscurity as languages like Fortran took off instead.

Decades later, Plankalkül was rediscovered as the first high-level language. Its visionary design influenced modern coding fundamentally, even if its compiler came 50 years late! This article explores its prescient conception during the war, lost years in the computing wilderness and ultimate resurrection.

Konrad Zuse and the First Computers

Konrad Zuse was born in 1910 Berlin under the influence of Germany’s Weimar Republic. During his student years, Zuse was captivated by the futuristic imaginings in science publications and David Hilbert‘s formal mathematics. Inspired, he daydreamed up elaborate calculating engines and automated factories.

Unlike British pioneers Charles Babbage and Alan Turing, Zuse had no knowledge of their earlier computing work. In isolation, he began building electromechanical logic machines to explore his ideas. These efforts crystallized into the Z1 prototype – considered by many the first modern computer. While far from commercial products of today, it could automatically solve arithmetic problems when programmed via perforated tape.

Over the following decade in his parents’ living room, Zuse iterated this computer series to pioneering milestones like:

1936 – Z1 electrical/mechanical binary calculator
1939 – Z2 with electrical memory
1941 – Z3, the first fully working program computer

However, Zuse felt limited expressing algorithms via wiring or numeric instructions. Instead, he devised Plankalkül, a mathematical notation to capture programs at a symbolic level.

Origins of Plankalkül

As Zuse experimented on his Z1 prototype in 1938, he created a formalism called "Combinatorics of Propositions" to define logical circuits symbolically. Realizing established notation already existed in Whitehead and Russell‘s Principia Mathematica, Zuse was determined to create something better suited to his goals.

The key inspiration struck in 1939 – representing code as familiar mathematical expressions and formulas. By 1941, implemented via electrical relays, these ideas had evolved into the hardware architecture behind the revolutionary electromechanical Z3. For his 1942 doctoral dissertation on the system, Zuse wrote:

"These days an engineer works with design formulas and a mathematician with functions. But one day, a third type of formula language will likely be used, whose formulas capture the logical structure of the process of computation in a way most immediate to the machine.”

This vision was embodied by his symbolic programming language which he fully documented in a 1945 technical report titled “Calculating Space”. Later named Plankalkül by Zuse’s doctoral advisor, it was considered far ahead of its time.

Unfortunately, only two working Z3 machines were ever constructed by Zuse and his small Berlin workshop. In 1943, their operation was ended due to war damage and resource constraints.

In 1944, Allied bombing demolished Zuse‘s workshop completely, destroying the Z3 along with blueprints for his follow up Z4 supercomputer. After the Nazi regime‘s 1945 collapse, Zuse rescued the nearly complete Z4 system and fled to the rural town of Hinterstein. Cut off from computing industry connections and restricted by Allied restrictions against advanced technology, Zuse focused his energy on reconstructing his lost innovations.

Revival from War’s Ashes

Over the next 3 years in a picturesque barn, Zuse and his team secretly rebuilt the Z4 system entirely from memory. This herculean effort produced the first working general purpose stored program computer by 1948. Its tape drives, printers and Typewriter style terminal cemented electromechanical computing as viable versus just an academic exercise.

*Zuse Z4 Computer recreation by Deutsches Technikmuseum Berlin – Einsiedler, CC BY-SA 3.0*

With the Z4 complete, Zuse hoped to finally implement the language he envisioned years earlier – Plankalkül. However, due to post-war laws forbidding advanced technology, the Z4 was confiscated by the German government in 1950 before development could start. Zuse joined computer manufacturer Zuse KG to aid reconstruction efforts while continuing his design work.

By 1972, Zuse had documented the full Plankalkül language with its advanced concepts like subroutines, data structures and conditional logic. This languished as just a technical publication for years before later researchers began implementing his vision on modern hardware in the 80s.

So why did Plankalkül – clearly ahead of other languages of its era – fail to materialize until decades after Zuse‘s death? The key reasons lie in brutal timing and business misfortune.

The Fortran Juggernaut

In 1957, mathematician John Backus presented a new language called Fortran at an IBM conference. Billed as a productivity booster for scientific work, it gained quick acceptance in academia and industry. As the first successful high level language, Fortran compilers and its mathematical notation syntax became ubiquitous worldwide. Through corporate backing, Fortran outcompeted rivals through revolutionary optimization – its first compiler squeezed hand coded assembly performance from symbolic instructions. Zuse‘s Plankalkül never gained such support or commercialization during his lifetime. Political constraints kept it isolated from the exploding computing industry centered around US research.

However, history shows Plankalkül preceded Fortran with many pioneering concepts:

Other elements like arrays, data typing, operators and conditionals emerged concurrently across language attempts of this era as programmers recognized common needs. However, Plankalkül‘s formulation of these into a systematic, flexible notation for algorithms was unprecedented.

Backus himself later acknowledged Plankalkül‘s influence in formalizing procedural programming. So while Fortran won the race commercially, Zuse‘s conception stands as the seminal ancestor to which all high level languages owe their origins.

Revival and Implementations

In the 1980s, Zuse‘s 1972 Plankalkül publication was repopularized as historians reexamined origins of programming. The elegance of its symbolic representations and mathematical grounding earned recognition separate from its aborted launch.

With programming knowledge more widespread, early implementations of Plankalkül for modern hardware began appearing. In 1988, computer scientist Prof. Friedrich Bauer wrote his own interpreter to model its behavior. In 1995, the first compiler emerged from a German dissertation by Joachim Hohmann. Since then, hobbyists and researchers have produced additional ports, validating Zuse‘s forward thinking architecture across devices exponentially faster than the relay era ever could foresee.

So does Plankalkül remain a viable way to write programs today? For most applications, modern languages like Python or Java provide richer capabilities and library ecosystems. But niche projects continue using Plankalkül as a reminder of how early programmers envisioned human computer interactivity. Its formulas offer surprising flexibility despite lacking later advancements like objects or lambdas. Implementations must also limit arbitrarily recursive functions for practicality, as Zuse focused more on conceptual capabilities over production restraints.

Nonetheless, Plankalkül‘s mathematical underpinnings directly inspired declarative languages and array programming techniques used in today‘s data science. The ability to manipulate entire data sets symbolically without explicit iteration later found form in APL, MATLAB and R. So while not used daily like workhorses such as C, echoes of Plankalkül continue influencing innovation at computing frontiers to this day.

Conclusion: Vision Overdue, But Not Forgotten

Timing and luck delayed Plankalkül‘s debut as the first high level programming dialect. But Zuse‘s vision proved prescient to be revived so many years later. Computing has come incredibly far since its relay era origins – from punch cards to touch screens, megabytes to petabytes. As interfaces continue to evolve, Zuse reminds us that progress stems from abstracting the endless complexity underneath into understandable models.

So while your daily code may look nothing like Plankalkül‘s idiosyncratic notation, appreciate that its pioneering vision echoes through software layers ever upwards today. Each app we build with modern languages owes credit to early idealists imagining how to bridge human and computer minds. One day coding may invoke new realities like quantum or biological systems through new abstractions. When facing that future, remember pioneers like Konrad Zuse who took the first symbolic steps to free programmers from the chains of bits and metal underneath.

Where will the next great visions take us? Onward and upward!