Plankalkül (German pronunciation: [ˈplaːnkalkyːl]) is a programming language designed for engineering purposes by Konrad Zuse between 1942 and 1945. It was the first high-level programming language to be designed for a computer.

Kalkül (from Latin calculus) is the German term for a formal system—as in Hilbert-Kalkül, the original name for the Hilbert-style deduction system—so Plankalkül refers to a formal system for planning.^[3]

History of programming

In the domain of creating computing machines, Zuse was self-taught, and developed them without knowledge about other mechanical computing machines that existed already – although later on (building the Z3) being inspired by Hilbert's and Ackermann's book on elementary mathematical logic (see Principles of Mathematical Logic).^{[4]: 113, 152, 216} To describe logical circuits, Zuse invented his own diagram and notation system, which he called "combinatorics of conditionals" (German: Bedingungskombinatorik). After finishing the Z1 in 1938, Zuse discovered that the calculus he had independently devised already existed and was known as propositional calculus.^[5]: 3 What Zuse had in mind, however, needed to be much more powerful (propositional calculus is not Turing-complete and is not able to describe even simple arithmetic calculations^[6]). In May 1939, he described his plans for the development of what would become Plankalkül.^{[4]: 113, 152, 216} He wrote the following in his notebook:

While working on his doctoral dissertation, Zuse developed the first known formal system of algorithm notation^[7]: 9 capable of handling branches and loops.^{[8]: 18 [4]: 56} In 1942 he began writing a chess program in Plankalkül.^{[4]: 216–217} In 1944, Zuse met with the German logician and philosopher Heinrich Scholz, who expressed appreciation for Zuse's utilization of logical calculus.^[9] In 1945, Zuse described Plankalkül in an unpublished book.^[10] The collapse of Nazi Germany, however, prevented him from submitting his manuscript.^[8]: 18

At that time the only two working computers in the world were ENIAC and Harvard Mark I, neither of which used a compiler, and ENIAC needed to be reprogrammed for each task by changing how the wires were connected.^[5]: 3

Although most of his computers were destroyed by Allied bombs, Zuse was able to rescue one machine, the Z4, and move it to the Alpine village of Hinterstein^[7]: 8 (part of Bad Hindelang).

The very first attempt to devise an algorithmic language was undertaken in 1948 by K. Zuse. His notation was quite general, but the proposal never attained the consideration it deserved.

— Heinz Rutishauser, creator of ALGOL

Unable to continue building computers – which was also forbidden by the Allied Powers^[11] – Zuse devoted his time to the development of a higher-level programming model and language.^[8]: 18 In 1948, he published a paper in the Archiv der Mathematik and presented at the Annual Meeting of the GAMM.^[4]: 89 His work failed to attract much attention.^{[citation needed]} In a 1957 lecture, Zuse expressed his hope that Plankalkül, "after some time as a Sleeping Beauty, will yet come to life."^[5]: 3 He expressed disappointment that the designers of ALGOL 58 never acknowledged the influence of Plankalkül on their own work.^{[8]: 18 [7]: 15}

Plankalkül was republished with commentary in 1972.^[12] The first compiler for Plankalkül was implemented by Joachim Hohmann in his 1975 dissertation.^[13] Other independent implementations followed in 1998^[14] and 2000 at the Free University of Berlin.^[5]: 2

Description

Plankalkül has drawn comparisons to the language APL, and to relational algebra. It includes assignment statements, subroutines, conditional statements, iteration, floating-point arithmetic, arrays, hierarchical record structures, assertions, exception handling, and other advanced features such as goal-directed execution. The Plankalkül provides a data structure called generalized graph (verallgemeinerter Graph), which can be used to represent geometrical structures.^[15]

Many features of the Plankalkül reappear in later programming languages; an exception is its idiosyncratic two-dimensional notation using multiple lines.

Some features of the Plankalkül:^[4]: 217

• only local variables
• functions do not support recursion
• only supports call by value
• composite types are arrays and tuples
• contains conditional expressions
• contains a for loop and a while loop
• no goto

Data types

The only primitive data type in the Plankalkül is a single bit or Boolean (German: Ja-Nein-Werte – yes-no value in Zuse's terminology). It is denoted by the identifier ${\displaystyle S0}$. All the further data types are composite, and build up from primitive by means of "arrays" and "records".^[16]: 679

So, a sequence of eight bits (which in modern computing could be regarded as byte) is denoted by ${\displaystyle 8\times S0}$, and Boolean matrix of size ${\displaystyle m}$ by ${\displaystyle n}$  is described by ${\displaystyle m\times n\times S0}$. There also exists a shortened notation, so one could write ${\displaystyle S1\cdot n}$ instead of ${\displaystyle n\times S0}$.^[16]: 679

Type ${\displaystyle S0}$ could have two possible values ${\displaystyle 0}$ and ${\displaystyle L}$. So 4-bit sequence could be written like L00L, but in cases where such a sequence represents a number, the programmer could use the decimal representation 9.^[16]: 679

Record of two components ${\displaystyle \sigma }$ and ${\displaystyle \tau }$ is written as ${\displaystyle (\sigma ,\tau )}$.^[16]: 679

Type (German: Art) in Plankalkül consists of 3 elements: structured value (German: Struktur), pragmatic meaning (German: Typ) and possible restriction on possible values (German: Beschränkung).^[16]: 679 User defined types are identified by letter A with number, like ${\displaystyle A1}$ – first user defined type.

Examples

Zuse used a lot of examples from chess theory:^[16]: 680

${\displaystyle A1}$	${\displaystyle S1\cdot 3}$	Coordinate of chess board (it has size 8x8 so 3 bits are just enough)
${\displaystyle A2}$	${\displaystyle 2\times A1}$	square of the board (for example L00, 00L denotes e2 in algebraic notation)
${\displaystyle A3}$	${\displaystyle S1\cdot 4}$	piece (for example, 00L0 — white king)
${\displaystyle A4}$	${\displaystyle (A2,A3)}$	piece on a board (for example L00, 00L; 00L0 — white king on e2)
${\displaystyle A5}$	${\displaystyle 64\times A3}$	board (pieces positions, describes which piece each of 64 squares contains)
${\displaystyle A10}$	${\displaystyle (A5,S0,S1\cdot 4,A2)}$	game state (${\displaystyle A5}$ — board, ${\displaystyle S0}$ — player to move, ${\displaystyle S1\cdot 4}$ — possibility of castling (2 for white and 2 for black), ${\displaystyle A2}$ — information about cell on which en passant move is possible

Identifiers

Identifiers are alphanumeric characters with a number.^[16]: 679 There are the following kinds of identifiers for variables:^[10]: 10

• Input values (German: Eingabewerte, Variablen) — marked with a letter V.
• Intermediate, temporary values (German: Zwischenwerte) — marked with a letter Z.
• Constants (German: Constanten) — marked with a letter С.
• Output values (German: Resultatwerte) — marked with a letter R.

Particular variable of some kind is identified by number, written under the kind.^[16]: 679 For example:

${\displaystyle {\begin{matrix}V\\0\end{matrix}}}$, ${\displaystyle {\begin{matrix}Z\\2\end{matrix}}}$, ${\displaystyle {\begin{matrix}C\\31\end{matrix}}}$ etc.

Programs and subprograms are marked with a letter P, followed by a program (and optionally a subprogram) number. For example ${\displaystyle P13}$, ${\displaystyle P5\cdot 7}$.^[16]: 679

Output value of program ${\displaystyle P13}$ saved there in variable ${\displaystyle {\begin{matrix}R\\0\end{matrix}}}$ is available for other subprograms under the identifier ${\displaystyle {\begin{matrix}R17\\0\end{matrix}}}$, and reading value of that variable also means executing related subprogram.^[16]: 680

Accessing elements by index

Plankalkül allows access for separate elements of variable by using "component index" (German: Komponenten-Index). When, for example, program receives input in variable ${\displaystyle {\begin{matrix}V\\0\end{matrix}}}$ of type ${\displaystyle A10}$ (game state), then ${\displaystyle {\begin{matrix}V\\0\\0\end{matrix}}}$ — gives board state, ${\displaystyle {\begin{matrix}V\\0\\0\cdot i\end{matrix}}}$ — piece on square number i, and ${\displaystyle {\begin{matrix}V\\0\\0\cdot i\cdot j\end{matrix}}}$ bit number j of that piece.^[16]: 680

In modern programming languages, that would be described by notation similar to V0, V0, V0 (although to access a single bit in modern programming languages a bitmask is typically used).

Two-dimensional syntax

Because indexes of variables are written vertically, each Plankalkül instruction requires multiple rows to write down.^{[citation needed]}

First row contains variable kind, then variable number marked with letter V (German: Variablen-Index), then indexes of variable subcomponents marked with K (German: Komponenten-Index), and then (German: Struktur-Index) marked with S, which describes variable type. Type is not required, but Zuse notes that this helps with reading and understanding the program.^[16]: 681

In the line ${\displaystyle S}$ types ${\displaystyle S0}$ and ${\displaystyle S1}$Zdroj:https://en.wikipedia.org?pojem=Plankalkül
Text je dostupný za podmienok Creative Commons Attribution/Share-Alike License 3.0 Unported; prípadne za ďalších podmienok. Podrobnejšie informácie nájdete na stránke Podmienky použitia.