Algol 60

from Wikipedia, the free encyclopedia
Algol 60
Paradigms : procedural , imperative , structured
Publishing year: 1960
Designer: John W. Backus
Developer: Backus , Bauer , Green , Katz , McCarthy , Naur , Perlis , Rutishauser , Samelson , van Wijngaarden , Vauquois , Wegstein , Woodger
Influenced by: Algol 58
Affected: most imperative languages ​​(so-called Algol-like languages), e.g. B. Simula , CPL , Pascal , Ada , C

Algol 60 is a programming language of the ALGOL family. It was developed from 1958 to 1963 under the leadership of the Association for Computing Machinery (ACM) and the Society for Applied Mathematics and Mechanics (GAMM), and later the International Federation for Information Processing (IFIP). Those involved included John W. Backus , Friedrich L. Bauer , John McCarthy , Peter Naur , Alan J. Perlis , Heinz Rutishauser and Klaus Samelson . The name Algol is an abbreviation for Algorithmic Language , 60 stands for the year of "almost completion" (a draft discussion became known as International Algorithmic Language (IAL) or Algol 58 ; the final version (titled "Revised Report") dates from the year 1963).

The language draft

As an internationally developed, portable , procedural programming language that was independent of commercial interests, it was primarily intended for scientific, i.e. numerical , purposes at the time . But there were also important non-numeric applications. Their simplicity, and the freedom from restrictions that were extensive for the time, made them pleasant to use.

The operating system was Burroughs - B5000 machines in an Algol version (ESPOL) programmed. Another example is a library catalog system for the mainframe computer Telefunken TR 4, which was available from 1962 . See also the JOVIAL language , derived from ALGOL 58, which was used for decades to program process computers in the aerospace industry (avionics).

Algol 60 was a milestone in the history of programming languages:

  • With it began the exact definition of language properties independent of (and before) each implementation (unlike LISP ).
  • The Algol 60 Report introduced the formal definition of syntax using the Backus-Naur form , which soon became commonplace.
  • ALGOL demonstrated the value of a clear and simple language core, an experience that soon inspired Peter Landin to design his ISWIM language and thus influence most of the programming languages ​​developed according to ALGOL.
  • Against the trend of the times, ALGOL prescribed runtime checks , a decision that was only slowly being appreciated and imitated.
  • The distinction between the language itself and its technical (input) representation (which had to take into account existing devices) met with approval, but only a few successors.

It turned out to be an (unexpectedly) big problem that the input / output was not regulated, so that their implementations vary greatly between the compilers. For example, a text is output once with the OUTSTRING and once with the WRITETEXT command (for example with the Electrologica X1 ).


The method of sequential formula translation by Bauer and Samelson made it possible to dispense with many restrictions such as those used by Fortran . The idea of ​​the stack memory contained therein also made recursive procedures possible ( Edsger W. Dijkstra ).

The possibility of internal procedure definitions (" block structure ") was inspired by the λ-calculus . 'Begin' blocks (anonymous procedures) were mainly used to create fields with variable limits in the stack . The visibility and scope of the variables were correctly lexically defined. 'Own' variables were also planned, the lifespan of which should be the program run (cf. 'static' in C ); however, this concept was often not implemented.

The parameter transfer modes were also taken from the λ-calculus :

  • Value parameters (keyword 'value' ) were evaluated before the call ( strict evaluation - »evaluate first, then insert«).
  • For name parameters , default , the semantics of a textual substitution was prescribed ( non-strict (lazy) evaluation - "insert first, then evaluate"). This led to certain difficulties in connection with memory variables, but in principle allowed an elegant formulation of integrals and similar tasks:
   integriere (alpha*x*x, x, a, b)
( Jensen's device ). To implement it, they used thunks , closures of anonymous functions (and named "after the sound they made on the 7090").

With Lisp, Algol introduced the principle of freedom of format in programming languages. A keyword always has the same meaning, regardless of its position in the program. In addition, the beginning of a new line is equivalent to a space. In the then predominant languages Fortran and COBOL, however , the positioning of the instructions on the punched cards was decisive - a keyword could have a different meaning depending on its position. The division of lines in these languages ​​was also not free.


The following (complete) Algol-60 program outputs Hallo, Welt!on output channel 2 :

begin comment Hallo-Welt-Programm in Algol 60;
    outstring (2, ʿHallo, Welt!ʾ)

Effects / meaning / successor

"ALGOL was a step forward over most of its successors."

In practice, Algol was less used than Fortran or COBOL ; but that did not reduce its long-term influence (see above). For a long time, Algol 60 was exemplary in the academic field. However, it suffered from the unwillingness of major computer manufacturers to implement it. From 1964, IBM wanted to replace the three "big" languages ​​COBOL, Fortran and Algol 60 with PL / I.

The most important successor was Simula 67 .

The American computer scientist John Charles Reynolds claimed that most languages ​​did not follow Algol 60, but the (never implemented) ISWIM ; he himself presented with Forsythe a further development in the Algol tradition.

Despite its name, Algol 68 was a completely new design that met with mixed feedback. Alternatively, Niklaus Wirth developed Algol W , which was to become Pascal in the further development .

See also


  • HT de Beer: The History of the ALGOL Effort . (PDF; 1.2 MB) 2006. - vi, 97 pp. (M.Sc. thesis, TU Eindhoven)
  • Heinz Rutishauser: Description of Algol 60 . Basic teaching of mathematical sciences , Springer, Berlin 1967. (Handbook for automatic computation; 1, a)
  • Albert A. Grau , Ursula Hill , Hans Langmaack : Translation of Algol 60 . Basic teaching of mathematical sciences, Springer, Berlin 1967. (Handbook for automatic computation; 1, b)
  • Rudolf Herschel: Instructions for the practical use of ALGOL 60 . 4th edition. R. Oldenbourg Verlag, Munich 1969
  • FEJ Kruseman Aretz: The Dijkstra-Zonneveld ALGOL 60 compiler for the Electrologica X1 . In: ReportRapport SEN Software Engineering . SEN-N0301. Stichting Centrum voor Wiskunde en Informatica, 2003, ISSN  1386-3711 ( [PDF]).

Web links

References and comments

  1. According to Friedrich L. Bauer, the name was coined in 1957 (at least in Germany) by Hermann Bottenbruch ( Friedrich L. Bauer ( Memento from April 22, 2012 in the Internet Archive )).
  2. It only changed with Scheme ; later in Common Lisp of birth defects of the dynamic scope ( dynamic scope ) corrected.
  3. JW Backus et al., Revised Report on the Algorithmic Language Algol 60 , Numerische Mathematik 4, pp. 420–453 (1963)
  4. Fortress, for example . See ISWIM and Pepper, Hofstedt: Functional Programming (2006), Beyond ASCII (p. 4)
  5. CiteSeerX