Skip to content

The Pioneering Programming Language: The Story of Plankalkül

In the 1940s, while computers were still in their infancy, German engineer Konrad Zuse developed the first high-level programming language designed for a computer. Named Plankalkül, this innovative language introduced concepts like subroutines, conditional statements, and looping that became fundamentals of modern languages. However, Plankalkül‘s promising start soon faded into obscurity for over 30 years before being rediscovered by historians. This is the fascinating story of the pioneering programming language Plankalkül.

The Visionary Creator: Konrad Zuse

Konrad Zuse, born in 1910 Berlin, was a civil engineer turned computing pioneer. Working in isolation in his parents‘ living room, he designed and built a series of innovative mechanical computers in the late 1930s, including the Z1 in 1938 and Z3 in 1941. The Z3 is considered the first fully functional programmable computer using binary math and a form of memory storage.

Driven to create more practical software for his machines, in 1942 Zuse began formally drafting ideas for a programming language allowing flexible, algorithmic solutions for engineering problems. This concept foreshadowed what became known as "high-level" languages decades later by abstracting away direct machine code instructions.

“My goal was to make a programming language that was more practical, convenient and secure for large groups of mathematic technical calculations,” Zuse later wrote.

He expanded on these ideas in his 1945 manuscript for Plankalkül, presenting it along with his computer developments as his doctoral dissertation in 1948.

The Creation of Plankalkül: A Technical Milestone

The name Plankalkül comes from the German word "Kalkül" meaning formal system or calculus. So Plankalkül essentially translates to "formal system for planning."

Revolutionary Programming Concepts

While primitive by today‘s standards, Plankalkül pioneered several key programming concepts during computing‘s early years:

  • Procedures – reusable chunks of code now called subroutines or functions
  • Local variables – variables with scope limited to a procedure
  • Conditional statements – branching to alter program flow based on logic
  • Loops/iterations – repeating a process without rewriting code

Technical Details of the Initial Plankalkül Design

The central data type was the bit, with composite data structures built from arrays of bits representing numbers, text, and other data.

Data Type Details
Boolean Single bit, enough for True/False flags
Integers Unsigned integers made up of bit arrays
Floats Floating point numbers encoded in bit arrays
Complex Complex numbers built from float arrays
Arrays Indexable arrays of above primitives types
Records Group multiple arrays as records
Strings Abbreviation for char arrays representing text

Variables were strongly typed, though type declarations were not required in programs. Values could be assigned directly for simple cases or computed using nested array subscripting expressions.

Overall, Plankalkül was an advanced high-level language architecture when computers still relied on tedious, error-prone manual machine code programming.

Coding in Plankalkül

To illustrate Plankalkül‘s syntax, here is a program to print the message "Hello world!" – the standard first program in most languages:

‘H‘;‘E‘;‘L‘;‘L‘;‘O‘;‘ ‘;
‘W‘;‘O‘;‘R‘;‘L‘;‘D‘;‘!‘ =>  

Z4 = 12 
Z5 = 1

  PRINT Z0[Z5]
  Z5 = Z5 + 1

The structure uses alphanumeric labels rather than line numbers, with distinct variable types indicated by prefixes like Z for temporary values. The loop increments Z5 to print each character in the 1×12 Z0 array containing the message.

The output would be:

Hello world!

This example only touches on Plankalkül‘s capabilities, but helps illustrate its design as an accessible, high-level language – truly revolutionary concepts for the 1940s.

The Disappearance of Plankalkül: A Tragedy of Timing and Resources

If Plankalkül was such a milestone in software, why did it disappear from the programming landscape so quickly? A combination of bad timing, limited documentation, lack of computing resources, and personal obstacles tragically cut short Plankalkül‘s initial promise.

War and Economic Devastation in Germany

Germany‘s computing development was severely disrupted by World War II. Zuse‘s early computing work struggled to get funding attention from the Nazi regime in the 1930s. Later war time bombing raids destroyed several of his prototype computers as well as existing copies of Plankalkül documentation.

In the aftermath, the Allied post-war plan to limit German technology development temporarily banned computer research. Focused on rebuilding his decimated technology company, Zuse himself could not actively pursue implementing Plankalkül more widely across the recovering industry.

Missed Connections in a Scattered Computing Industry

In parallel in the 1940s, engineers around the world were also slowly advancing early computer development. But teams in Germany, the UK, and the US remained siloed, rarely sharing incremental discoveries that could have sped progress.

In the UK, Alan Turing designed the theorietical "Turing machine" model of computation but did not focus on programming language itself. In the US, Howard Aiken created electromechanical calculators and Grace Hopper paved the way for machine-independent languages. But neither connected with Zuse‘s existing language ideas.

Instead in 1945, the first draft specifications for Fortran emerged from US researchers like John Backus. Fortran went on to become the most widely used scientific programming language by the 1950s and 60s.

Zuse later reflected on this missed connection:

"If someone had told me in 1944 in Germany about the work in the USA, I am sure I would have dropped all work on Plankalkül and started immediately to adapt my compiler efforts to this programming language they were working on"

But with little awareness of parallel advances, Zuse focused locally applying Plankalkül to his machines instead.

The Shadow of Von Neumann Architecture

Even within continental Europe, America computing ideas attracted greater attention in the postwar years. Physicist John von Neumann published his seminal "First Draft of a Report on the EDVAC" paper in 1945. It described an influential universal architecture for stored-program digital computers.

The so-called "von Neumann architecture" became a template adopted by major US computer projects in the late 40s and 50s. For example:

  • 1948 – IBM SSEC electromechanical computer
  • 1951 – Early designs for the EDVAC at the Institute for Advanced Study
  • 1952 – Standards for the UNIVAC 1 mainframe computer

This momentum gave the von Neumann model outsized influence in driving computer evolution. Soon Zuse‘s more isolated work was largely overshadowed, including lack of uptake for teaching Plankalkül-based programming.

The Eventual Rediscovery of Plankalkül

It wasn‘t until the early 1970s that Plankalkül came back to light. Raúl Rojas, then a junior professor at University of Freiburg, stumbled across a copy of Konrad Zuse‘s long-lost 1945 Plankalkül manuscript. Reading through this dense 400+ page technical paper, Professor Rojas slowly came to a realization – he was looking at perhaps the earliest high-level programming language, even predating well-known languages like Fortran.

"It was an absolutely wonderful discovery to find Zuse‘s manuscript from the 1940s," recalls Rojas. "The ideas were so forward-thinking about how computers should work while computers were still just in prototype stage."

At last, Rojas could recognize the genius of Plankalkül‘s innovation given decades of perspective on programming language development. Through publications starting in 1972, Rojas helped bring Plankalkül to modern attention and earned Konrad Zuse credit as a computing pioneer. Other historians helped preserve and republish copies of the recovered Plankalkül manuscript and Zuse‘s 1948 paper.

With the documentation now preserved, a few enthusiasts also began efforts to resurrect Plankalkül itself. Implementing the ideas required building the first ever Plankalkül compilers to transform its language statements into executable machine code:

  • In 1998, German software architect Thomas Schultz wrote a compiler for a Plankalkül subset
  • In 2000, Joachim Hohmann completed a more fully featured compiler for his PhD dissertation.
  • In 2003, programmer André Spiegel released jplank, an open source Java-based compiler and simulator still used today.

So while rarely applied for practical software development, these reconstruction efforts have exposed Plankalkül‘s precocious vision to new generations of programmers and historians.

The Lasting Conceptual Impact of Plankalkül DNA

While Plankalkül itself faded soon after its 1948 academic publication, many of its pioneering structural concepts reemerged years later in more mainstream languages, most prominently:

  • Fortran: also compiled higher-level language to efficient machine code
  • COBOL: adopted a similar variable naming scheme
  • ALGOL: copied looping and conditional concepts
  • C and Java: inherited structures ideal for engineering computation
  • Pascal and Modula: built on Plankalkül‘s structured programming approach

In retrospect, we can recognize elemental DNA strands of Plankalkül woven into future language fabric:

  • Subroutines – Encapsulate and reusing logic in functions and procedures
  • Data typing – Define variable behavior and interfaces
  • Information hiding – Limit scope access with modern OOP principles
  • Array processing – Power mathematical and statistical operations
  • Conditional logic – Enable flexible branching program flow control

So while forgotten for decades, Plankalkül planted concepts that blossomed into essential building blocks of mainstream programming. Next time you call a function, declare a typed variable, hide class state, process matrix data, or execute an if-then statement, you may be benefiting from Konrad Zuse‘s innovative thinking back in the 1940s.

Now over 110 years old, Zuse did live to see Plankalkül‘s eventual appreciation before passing in 1995. In a 1986 lecture Zuse expressed his decades-old hope:

“Perhaps now the time is ripe at last to consider Plankalkül.”

Though recognition tragically came late, we can now celebrate Plankalkül‘s enormous influence guiding the evolution of computer programming.