Plankalkül

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

"Kalkül" means formal system – the Hilbert-style deduction system is for example originally called "Hilbert-Kalkül", so Plankalkül means "formal system for planning".[2]

Plankalkül
ParadigmProcedural
Designed byKonrad Zuse
First appeared1948 – concept first published
Major implementations
Plankalkül-Compiler by the FU Berlin in 2000
Influenced by
Begriffsschrift
Influenced
Superplan by Heinz Rutishauser,
ALGOL 58[1]

History

While working on his intended doctoral dissertation, Konrad Zuse developed a formal system of notation for algorithms because no such system was yet known.[3] This notation could only handle linear (unbranched and unlooped) calculation plans.[3] Zuse's formal system on the other hand did include branched and looped calculation[4][5]. He had intended to submit an early manuscript, written in 1944, as a PhD thesis, but the collapse of Nazi Germany made this impossible.[4]

Near the end of the Second World War, most of the computers Zuse was building were destroyed by Allied bombs. He was able to rescue one machine, the Z4, and move it to the small Alpine village of Hinterstein.[6] After the war it was not possible for Zuse to continue building his computers, so he devoted his time to the development of a higher level programming model and language for them called the Plankalkül.[4]

Notes survive with scribblings about such a plan calculation dating back to May 1939 and in 1942 Zuse began writing a computer chess program in Plankalkül.[7] In 1944 Zuse met with the German logician and philosopher Heinrich Scholz and they discussed Zuse's Plankalkül. In March 1945 Scholz personally expressed his deep appreciation for Zuse's utilization of the logical calculus.[8] Plankalkül was not published at that time owing to a combination of factors such as conditions in World War II and postwar Germany and his efforts to commercialise the Z3 computer and its successors.

In 1945, Zuse wrote an unpublished book about the Plankalkül[9] and in 1948 he published a paper in the "Archiv der Mathematik" and introduced his programming language at the Annual Meeting of the GAMM.[10] His work did not attract much attention, and for a long time to come programming a computer would only be thought of as using machine code.

The Plankalkül was more comprehensively published in 1972 and the first compiler for it was implemented in 1975 in a dissertation by Joachim Hohmann.[11] Other independent implementations followed in 1998 and then in 2000 by the Free University of Berlin.

Zuse was unhappy that the designers of ALGOL 58 did not acknowledge the Plankalkül, even though many of them had been aware of it.[4][12]

Description

Plankalkül has drawn comparisons to APL and 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.[13]

Plankalkül shared an idiosyncratic notation using multiple lines with Frege's Begriffsschrift of 1879 (dealing with mathematical logic).

Some features of the Plankalkül:[14]

  • 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, denoted by S0. Further data types can be built up from these.

Terminology

Zuse called a single program a Rechenplan (i.e. computation plan), and in 1944 he already envisioned a device that should read and then automatically translate a mathematical formulation of a program into machine readable punched film stock – a device which he called Planfertigungsgerät (i.e. plan construction device).[15]

Example

The original notation was two dimensional. For a later implementation in the 1990s, a linear notation was developed.

The following example shows a program (in a linear transcription), which calculates the maximum of three variables by calling the function max3:

P1 max3 (V0[:8.0],V1[:8.0],V2[:8.0]) → R0[:8.0]
max(V0[:8.0],V1[:8.0]) → Z1[:8.0]
max(Z1[:8.0],V2[:8.0]) → R0[:8.0]
END
P2 max (V0[:8.0],V1[:8.0]) → R0[:8.0]
V0[:8.0] → Z1[:8.0]
(Z1[:8.0] < V1[:8.0]) → V1[:8.0] → Z1[:8.0]
Z1[:8.0] → R0[:8.0]
END

Quotations

In a lecture in 1957 Zuse mentioned his hope that the Plankalkül "after some time as a Sleeping Beauty, will yet come to life".

Heinz Rutishauser, one of the founders of ALGOL:

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.

See also

Notes

  1. ^ Rojas, Raúl; Hashagen, Ulf (2002). The First Computers: History and Architectures. MIT Press. p. 292. ISBN 978-0262681377. Retrieved October 25, 2013.
  2. ^ Hector Zenil (ed.), 2012. A Computable Universe: Understanding and Exploring Nature As Computation with a Foreword by Sir Roger Penrose. Singapore: World Scientific Publishing Company. Page 791.
  3. ^ a b Knuth & Pardo 1976, p. 9
  4. ^ a b c d Giloi 1997
  5. ^ Hans Dieter Hellige (ed.): Geschichten der Informatik. Visionen, Paradigmen, Leitmotive. Berlin, Springer 2004, ISBN 3-540-00217-0. p. 56.
  6. ^ Knuth & Pardo 1976, p. 8
  7. ^ Hans Dieter Hellige (ed.): Geschichten der Informatik. Visionen, Paradigmen, Leitmotive. Berlin, Springer 2004, ISBN 3-540-00217-0. p. 216,217.
  8. ^ Hartmut Petzold,Moderne Rechenkünstler. Die Industrialisierung der Rechentechnik in Deutschland. München. C.H. Beck Verlag 1992
  9. ^ (full text of the 1945 manuscript)
  10. ^ Hans Dieter Hellige (ed.): Geschichten der Informatik. Visionen, Paradigmen, Leitmotive. Berlin, Springer 2004, ISBN 3-540-00217-0. p. 89.
  11. ^ Joachim Hohmann: Der Plankalkül im Vergleich mit algorithmischen Sprachen. Reihe Informatik und Operations Research, S. Toeche-Mittler Verlag, Darmstadt 1979, ISBN 3-87820-028-5.
  12. ^ Knuth & Pardo 1976, p. 15
  13. ^ Prof. Wolfgang Giloi: Konrad Zuses Plankalkül als Vorläufer moderner Programmiermodelle, November 1990
  14. ^ Hans Dieter Hellige (ed.): Geschichten der Informatik. Visionen, Paradigmen, Leitmotive. Berlin, Springer 2004, ISBN 3-540-00217-0. p. 217.
  15. ^ Hellige, Hans Dieter, Geschichten der Informatik. Visionen, Paradigmen, Leitmotive. Berlin, Springer 2004, ISBN 3-540-00217-0. pp. 45, 104, 105

References

  • Giloi, Wolfgang (1997), "Konrad Zuse's Plankalkül: The First High-Level "non von Neumann" Programming Language", IEEE Annals of the History of Computing, 19 (2): 17–24, doi:10.1109/85.586068
  • Knuth, Donald Ervin; Pardo, Luis Trabb (1976), The Early Development of Programming Languages (PDF), Stanford University, Computer Science Department, archived from the original (PDF) on 2017-09-12, retrieved 2017-12-28
  • Zuse, Konrad (1943), "Ansätze einer Theorie des allgemeinen Rechnens unter besonderer Berücksichtigung des Aussagenkalküls und dessen Anwendung auf Relaisschaltungen", (i.e. Inception of a universal theory of computation with special consideration of the propositional calculus and its application to relay circuits.) unpublished manuscript, Zuse Papers 045/018.
  • Zuse, Konrad (1948/49). "Über den allgemeinen Plankalkül als Mittel zur Formulierung schematisch-kombinativer Aufgaben". Arch. Math. 1, pp. 441–449, 1948/49.
  • Zuse, Konrad (1972). "Der Plankalkül". Gesellschaft für Mathematik und Datenverarbeitung. Nr. 63, BMBW - GMD - 63, 1972.
  • Giloi, Wolfgang (1997). "Konrad Zuse's Plankalkül: The First High-Level "non von Neumann" Programming Language". IEEE Annals of the History of Computing. 19 (2): 17–24. doi:10.1109/85.586068.

External links

ALGOL 58

ALGOL 58, originally known as IAL, is one of the family of ALGOL computer programming languages. It was an early compromise design soon superseded by ALGOL 60. According to John Backus

"The Zurich ACM-GAMM Conference had two principal motives in proposing the IAL: (a) To provide a means of communicating numerical methods and other procedures between people, and (b) To provide a means of realizing a stated process on a variety of machines..."

ALGOL 58 introduced the fundamental notion of the compound statement, but it was restricted to control flow only, and it was not tied to identifier scope in the way that Algol 60's blocks were.

Breadth-first search

Breadth-first search (BFS) is an algorithm for traversing or searching tree or graph data structures. It starts at the tree root (or some arbitrary node of a graph, sometimes referred to as a 'search key'), and explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level.

It uses the opposite strategy as depth-first search, which instead explores the highest-depth nodes first before being forced to backtrack and expand shallower nodes.

BFS and its application in finding connected components of graphs were invented in 1945 by Konrad Zuse, in his (rejected) Ph.D. thesis on the Plankalkül programming language, but this was not published until 1972.

It was reinvented in 1959 by Edward F. Moore, who used it to find the shortest path out of a maze, and later developed by C. Y. Lee into a wire routing algorithm (published 1961).

Heinz Rutishauser

Heinz Rutishauser (30 January 1918 – 10 November 1970) was a Swiss mathematician and a pioneer of modern numerical mathematics and computer science.

High-level programming language

In computer science, a high-level programming language is a programming language with strong abstraction from the details of the computer. In contrast to low-level programming languages, it may use natural language elements, be easier to use, or may automate (or even hide entirely) significant areas of computing systems (e.g. memory management), making the process of developing a program simpler and more understandable than when using a lower-level language. The amount of abstraction provided defines how "high-level" a programming language is.In the 1960s, high-level programming languages using a compiler were commonly called autocodes.

Examples of autocodes are COBOL and Fortran.The first high-level programming language designed for computers was Plankalkül, created by Konrad Zuse. However, it was not implemented in his time, and his original contributions were largely isolated from other developments due to World War II, aside from the language's influence on the "Superplan" language by Heinz Rutishauser and also to some degree Algol. The first significantly widespread high-level language was Fortran, a machine-independent development of IBM's earlier Autocode systems. Algol, defined in 1958 and 1960 by committees of European and American computer scientists, introduced recursion as well as nested functions under lexical scope. It was also the first language with a clear distinction between value and name-parameters and their corresponding semantics. Algol also introduced several structured programming concepts, such as the while-do and if-then-else constructs and its syntax was the first to be described in formal notation – "Backus–Naur form" (BNF). During roughly the same period, Cobol introduced records (also called structs) and Lisp introduced a fully general lambda abstraction in a programming language for the first time.

History of computer science

The history of computer science began long before our modern discipline of computer science usually appearing in forms like mathematics or physics. Developments in previous centuries alluded to the discipline that we now know as computer science. This progression, from mechanical inventions and mathematical theories towards modern computer concepts and machines, led to the development of a major academic field, massive technological advancement across Western Society, and the basis of a massive worldwide trade and culture.

History of programming languages

The first high-level programming language was Plankalkül, created by Konrad Zuse between 1942 and 1945. The first high-level language to have an associated compiler was created by Corrado Böhm in 1951, for his PhD thesis. The first commercially available language was FORTRAN (FORmula TRANslation); developed in 1956 (first manual appeared in 1956, but first developed in 1954) by a team led by John Backus at IBM.

When FORTRAN was first introduced it was treated with suspicion because of the belief that programs compiled from high-level language would be less efficient than those written directly in machine code. FORTRAN became popular because it provided a means of porting existing code to new computers, in a hardware market that was rapidly evolving; the language eventually became known for its efficiency.

Konrad Zuse

Konrad Zuse (German: [ˈkɔnʁat ˈtsuːzə]; 22 June 1910 – 18 December 1995) was a German civil engineer, inventor and computer pioneer. His greatest achievement was the world's first programmable computer; the functional program-controlled Turing-complete Z3 became operational in May 1941. Thanks to this machine and its predecessors, Zuse has often been regarded as the inventor of the modern computer.Zuse was also noted for the S2 computing machine, considered the first process control computer. He founded one of the earliest computer businesses in 1941, producing the Z4, which became the world's first commercial computer. From 1943 to 1945 he designed the first high-level programming language, Plankalkül. In 1969, Zuse suggested the concept of a computation-based universe in his book Rechnender Raum (Calculating Space).

Much of his early work was financed by his family and commerce, but after 1939 he was given resources by the Nazi German government. Due to World War II, Zuse's work went largely unnoticed in the United Kingdom and the United States. Possibly his first documented influence on a US company was IBM's option on his patents in 1946.

There is a replica of the Z3, as well as the original Z4, in the Deutsches Museum in Munich. The Deutsches Technikmuseum in Berlin has an exhibition devoted to Zuse, displaying twelve of his machines, including a replica of the Z1 and several of Zuse's paintings.

List of pioneers in computer science

This article presents a list of individuals who made transformative breakthroughs in the creation, development and imagining of what computers and electronics could do.

List of programming languages

The aim of this list of programming languages is to include all notable programming languages in existence, both those in current use and historical ones, in alphabetical order. Dialects of BASIC, esoteric programming languages, and markup languages are not included.

Non-English-based programming languages

Non-English-based programming languages are computer programming languages that, unlike better-known programming languages, do not use keywords taken from, or inspired by, the English vocabulary.

PLANC

PLANC (pronounced as "plank") is a high level computer programming language. The acronym stands for Programming LAnguage for Nd Computers.

Compilers were developed by Norsk Data for several architectures, including the Motorola 68000, 88000, x86, and the Norsk Data NORD-10 minicomputer architecture and ND-500 superminicomputer.

The language was designed to be platform independent. It was mainly used internally at Norsk Data for writing high level systems software such as the upper parts of the operating systems and compilers.

Programming language

A programming language is a formal language, which comprises a set of instructions that produce various kinds of output. Programming languages are used in computer programming to implement algorithms.

Most programming languages consist of instructions for computers. There are programmable machines that use a set of specific instructions, rather than general programming languages. Early ones preceded the invention of the digital computer, the first probably being the automatic flute player described in the 9th century by the brothers Musa in Baghdad, during the Islamic Golden Age. Since the early 1800s, programs have been used to direct the behavior of machines such as Jacquard looms, music boxes and player pianos. The programs for these machines (such as a player piano's scrolls) did not produce different behavior in response to different inputs or conditions.

Thousands of different programming languages have been created, and more are being created every year. Many programming languages are written in an imperative form (i.e., as a sequence of operations to perform) while other languages use the declarative form (i.e. the desired result is specified, not how to achieve it).

The description of a programming language is usually split into the two components of syntax (form) and semantics (meaning). Some languages are defined by a specification document (for example, the C programming language is specified by an ISO Standard) while other languages (such as Perl) have a dominant implementation that is treated as a reference. Some languages have both, with the basic language defined by a standard and extensions taken from the dominant implementation being common.

Programming language theory

Programming language theory (PLT) is a branch of computer science that deals with the design, implementation, analysis, characterization, and classification of programming languages and their individual features. It falls within the discipline of computer science, both depending on and affecting mathematics, software engineering, linguistics and even cognitive science. It is a well-recognized branch of computer science, and an active research area, with results published in numerous journals dedicated to PLT, as well as in general computer science and engineering publications.

Retrocomputing

Retrocomputing is the use of older computer hardware and software in modern times. Retrocomputing is usually classed as a hobby and recreation rather than a practical application of technology; enthusiasts often collect rare and valuable hardware and software for sentimental reasons. However, some do make use of it.

Timeline of programming languages

This is a record of historically important programming languages, by decade.

Turochamp

Turochamp is chess program developed by Alan Turing and David Champernowne in 1948. It was developed in the early history of video games as part of research by the pair into computer science and machine learning. Turochamp is capable of playing an entire chess game against a human player at a low level of play, by calculating all potential moves and all of the potential player moves in response, assigning point values to each game state, and selecting the move with the highest average possible point value.

Turochamp is the earliest known computer game to enter development, but was never completed by Turing and Champernowne, as its algorithm was too complex to be run by the early computers of the time such as the Automatic Computing Engine. Turing attempted to convert the program into executable code for the 1951 Ferranti Mark 1 computer in Manchester, but was unable to do so. Turing played a match against computer scientist Alick Glennie using the program in the summer of 1952, executing it manually step by step, but by his death in 1954 had still been unable to run the program on an actual computer. Champernowne did not continue the project, and the original program design was not preserved. Despite never being run on a computer, the program is a candidate for the first chess program; several other chess programs were designed or proposed around the same time, including another one which Turing unsuccessfully tried to run on the Ferranti Mark 1. The first successful program in 1951, also developed for the Mark 1, was directly inspired by Turochamp, and was capable only of solving "mate-in-two" problems. A recreation of Turochamp was constructed in 2012 for the Alan Turing Centenary Conference. This version was used in a match with chess grandmaster Garry Kasparov, who gave a keynote at the conference.

Von Neumann programming languages

A von Neumann language is any of those programming languages that are high-level abstract isomorphic copies of von Neumann architectures. As of 2009, most current programming languages fit into this description, likely as a consequence of the extensive domination of the von Neumann computer architecture during the past 50 years.

The differences between Fortran, C, and even Java, although considerable, are ultimately constrained by all three being based on the programming style of the von Neumann computer. If, for example, Java objects were all executed in parallel with asynchronous message passing and attribute-based declarative addressing, then Java would not be in the group.

The isomorphism between von Neumann programming languages and architectures is in the following manner:

program variables ↔ computer storage cells

control statements ↔ computer test-and-jump instructions

assignment statements ↔ fetching, storing instructions

expressions ↔ memory reference and arithmetic instructions.

Z1 (computer)

The Z1 was a mechanical computer designed by Konrad Zuse from 1936 to 1937 and built by him from 1936 to 1938. It was a binary electrically driven mechanical calculator with limited programmability, reading instructions from punched celluloid film.

The Z1 was the first freely programmable computer in the world which used Boolean logic and binary floating-point numbers, however it was unreliable in operation. It was completed in 1938 and financed completely from private funds. This computer was destroyed in the bombardment of Berlin in December 1943, during World War II, together with all construction plans.

The Z1 was the first in a series of computers that Zuse designed. Its original name was "V1" for VersuchsModell 1 (meaning Experimental Model 1). After WW2, it was renamed "Z1" to differentiate from the flying bombs designed by Robert Lusser. The Z2 and Z3 were follow-ups based on many of the same ideas as the Z1.

Z2 (computer)

The Z2 was a mechanical and relay computer completed by Konrad Zuse in 1940. It was an improvement on the Z1, using the same mechanical memory but replacing the arithmetic and control logic with electrical relay circuits.

Photographs and plans for the Z2 were destroyed by the Allied bombing during World War II. In contrast to the Z1, the Z2 used 16-bit fixed-point arithmetic instead of 22-bit floating point.

Zuse presented the Z2 in 1940 to members of the DVL (today DLR) and it was especially its member Prof. Alfred Teichmann, whose support achieved the partial funding of the successor model Z3.

This page is based on a Wikipedia article written by authors (here).
Text is available under the CC BY-SA 3.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.