3 Facts about Plankalkül Programming Language
- Plankalkül was the first high-level computer programming language to be designed.
- The initial years of the language saw poor reception by the people, inhibiting its implementation.
- Plankalkül was comprehensively published in 1972.
What is Plankalkül: Explained
Plankalkül is a programming language ideal for engineering purposes. The language was developed by Konrad Zuse, a German engineer and computer pioneer in the 1940s, and stood out as the first high-level computer programming language to be created.
Basically, the name Plankalkül builds from the German term Kalkül, which means formal system. Therefore, Plankalkül stands for Formal System for planning.
Quick Facts
- Creator (person)
- Konrad Zuse
- Operating System
- Computer Programming Language
When Zuse created his Plankalkül language, the world was fighting the Second World War. At the time, everyone’s focus was on the war, which made it hard for the language to gain attention and momentum. Due to that, the implementation of the programming language idea flopped, making it remain only on paper.
Besides, Zuse himself had developed a Z3 computer during the same time and was busy commercializing it. Therefore, he put less effort into implementing the Plankalkül programming language, which contributed to its failure.
Later on, John Backus came in with his Fortran programming language, which became the world’s first-ever successful computer programming language to be widely used.
Using modern programming terminology, Plankalkül is a typed high-level imperative programming language with the following main features:
- Programs are reusable functions, and functions are not recursive
- Variables are local to functions (programs)
- The fundamental data types are arrays and tuples of arrays, but there are also floating points, fixed point, complex numbers; records; hierarchical data structures; lists of pairs.
- The type of the variables does not need to be declared in a special header
- There is no GOTO construct
- Assignment operation (e.g., V1 + V2 => R1).
- Conditional statement (e.g., V1 = V2 => R1. This means: Compare the variables V1 and V2: If they are identical, then assign the value true to R1; otherwise, assign the value false. Such operations could also be applied to complicated data structures.)
- Possibility for defining sub-programs.
- Possibility for defining repetition of statements (loops) WHILE constructing for iteration.
- Logical operations (predicate logic and Boolean algebra).
- Arithmetic exception handling.
How to Use Plankalkül Programming Language
To use Plankalkül Programming Language, you need to know a few basics. To start with here is how to write Hello World in Plankalkül:
R1.1(V0[:SIG]) => R0
R1.2(V0[:M X SIG]) => R0
0 => I | M + 1 => J
[W [ I < J -> [ R1.1(V0[I: M X SIG]) => R0 | I + 1 => I ] ] ] END
R1.3() => R0
‘H’;’E’;’L’;’L’;’O’;’,’;’ ‘;’W’;’O’;’R’;’L’;’D’;’!’ => Z0[: M X SIG] R1.2(Z0) => R0
END
Plankalkül uses a Boolean or single bit, which is the only primitive data type of the language. It is denoted by an identifier SO. Other composite data types are based on the primitive data type through records and arrays.
Modern computing with an eight-bits sequence is denoted by 8 xSO. You can define the Boolean matrix as m x n xSO.
The language also has identifiers for its variables. These are alphanumeric characters containing a number. They include:
- Input values denoted with the letter V
- Temporary, intermediate values, symbolized with the letter Z
- Output values, marked letter R
- Constants marked with the letter C
Subprograms and programs in Plankalkül are denoted with the letter P, followed by the program type, and later, subprogram, which is optional. For instance, p14, p6.8.
This programming language also enables access to separate elements through a component index. The modern language describes it through a notation same as V0[0], V0[0][i], V0[0][i][j]
Another vital part to understand in Plankalkül is the Two-dimensional syntax. Each Plankalkül instruction involves multiple rows for it to write. That’s because the language writes indexes of variables vertically.
In the first row, you get variable kind, followed by variable number denoted by the letter V, then variable indexes subcomponents marked K, and finally, variable type marked with S.
How to Learn Plankalkül
Even though the online materials for learning Plankalkül are limited, you can still benefit from the few tutorials and books available. If you don’t know where to start, check out these materials:
- https://web.archive.org/web/20060501175521/http://www.zib.de/zuse/Inhalt/Programme/Plankalkuel/Plankalkuel-Report/techreport.pdf
- https://www.computer.org/csdl/magazine/an/1997/02/man1997020017/13rRUIJcWqp
- https://web.archive.org/web/20090220012346/http://delivery.acm.org/10.1145/370000/361515/p678-bauer.pdf?key1=361515&key2=3342588511&coll=&dl=acm&CFID=15151515&CFTOKEN=6184618
The Difference Between Plankalkül and Fortran
While Plankalkül was the first-ever high-level programming language to be developed for a computer, the ideas remained only on paper. That’s because the world was fighting at the time, causing it not to attract much attention.
On the other hand, Backus’s Fortran became the first programming language to be commercially successful and used widely across the globe. Its success was attributed to the rising need for scientific and mathematical computations.
Unlike Zuse’s language, Backus’s programming language gained acceptance, as it would replace manual hand-coding, which was tiresome and time-consuming.
Regarding data types, Fortran delivers five essential data types; integer type, complex type, character type, logical type, and real type. On the contrary, Plankalkül has one primitive data type; a Boolean or single bit. All the other composite data types rely on the primitive through records and arrays.
Plankalkül Release History
Konrad Zuse, a German engineer and computer pioneer, is the mind behind the famous Plankalkül computer programming language. The inventor also developed the first relay computer and its successors.
Phase 1: 1938-1940
When Zuse started developing computing machines, he was unaware of any other existing mechanical computing machines at the time. But later on, when building his Z3 computer, he was inspired by Hilbert’s book on elementary mathematical logic.
Zuse decided to invent his notation system and diagram to define logical circuits. He named his invention combinatorics of conditionals. In 1938, after developing his Z1 computer, Zuse found out that the calculus he had created already existed under the name proportional calculus. But what Zuse wanted was something more powerful.
In 1939, the German inventor came up with an idea to develop something that later became Plankalkül.
Phase 2: 1941-1948
When it came to 1942, while handling his doctoral dissertation, Zuse invented his first formal algorithm notation system. The system could handle loops and branches. This Ph.D. dissertation is where Zuse initially described his Plankalkül language.
In 1945, Zuse wrote an unpublished book describing his Plankalkül. Unfortunately, he didn’t submit his manuscript following the collapse of Nazi Germany.
During that time, only two computers were working in the entire world; Harvard Mark I and ENIAC. None of the two computers made use of a compiler. In fact, the only way to reprogram ENIAC for every task was to change the wire connections.
The allied bombing in Germany in 1945 saw most of Zuse’s computers destroyed. Luckily, he salvaged one computer, dubbed Z4, and took it to Hinterstein.
Following an order by the allied powers forbidding the building of computers, Zuse remained with no choice but to devote his time to something else. For that reason, he started developing a high-level programming language model.
The language was designed to create procedures, store code chunks to repeatedly revoke the codes for routine functions and structure data like database recording. Furthermore, the language had conditional statements for modification of program executions.
In 1948, Zuse had an opportunity to publish his paper in the Archiv der Mathematik, and also gave a presentation about it at the GAMM’s Annual General Meeting. Unfortunately, his work didn’t attract much attention.
Phase 3; 1957-2000
When giving a lecture in 1957, Zuse was positive and expressed hope that his Plankalkül would someday come back to life. However, he was disappointed that ALGOL designers failed to acknowledge the positive impact of Plankalkül on their work.
And finally, a comprehensive publication of the Plankalkül programming language happened in 1972. Even so, the implementation of its first compiler was done in 1995 by Joachim Hohmann in his dissertation paper. Thereafter, other independent applications took place in 1998 and then in 2000 at the University of Berlin.
Plankalkül: End of development
When Zuse created his Plankalkül language, the world was fighting the Second World War. At the time, everyone’s focus was on the war, which made it hard for the language to gain attention and momentum. Due to that, the implementation of the programming language idea flopped, making it remain only on paper.
NEXT UP…
- Grace Hopper – Complete Biography, History, and Inventions
- Complete History of the Operating System
- Meet Angela Ruiz Robles – Complete Biography, History and Inventions
