ALGOL 60

Overview

ALGOL 60 (short for Algorithmic Language 1960) is one of the most influential programming languages in computing history. While never achieving widespread commercial adoption, ALGOL 60’s innovations became the foundation for nearly every major programming language that followed, including Pascal, C, C++, Java, and Python.

Tony Hoare famously remarked about ALGOL 60: “Here is a language so far ahead of its time that it was not only an improvement on its predecessors but also on nearly all its successors.”

Historical Significance

The Paris Meeting

ALGOL 60 was defined during a historic meeting in Paris from January 11-16, 1960. The international committee that created it included some of the greatest names in computer science:

From Europe:

• Friedrich L. Bauer (Germany)
• Peter Naur (Denmark) - Editor of the Report
• Heinz Rutishauser (Switzerland)
• Klaus Samelson (Germany)
• Bernard Vauquois (France)
• Adriaan van Wijngaarden (Netherlands)
• Michael Woodger (United Kingdom)

From the United States:

• John Backus (IBM)
• Julien Green
• Charles Katz
• John McCarthy (MIT)
• Alan J. Perlis (Carnegie Mellon)
• Joseph Henry Wegstein (NBS)

The Birth of BNF

The ALGOL 60 Report introduced Backus-Naur Form (BNF), a formal notation for describing the syntax of programming languages. This contribution alone would have made ALGOL 60 historically significant, as BNF became the standard way to define programming language grammars and is still used today.

The First Compiler

The first implementation was X1 ALGOL 60, developed by Edsger Dijkstra and Jaap Zonneveld for the Electrologica X1 computer. This compiler was remarkably sophisticated for its time and demonstrated the practical viability of the language.

Key Features

ALGOL 60 introduced many features that programmers now take for granted:

• Block Structure: Nested scopes with begin and end delimiters
• Lexical Scoping: Variables are resolved based on their textual location in the code
• Recursive Functions: Functions that can call themselves (revolutionary for its time)
• Call-by-Name: A unique parameter passing mechanism (in addition to call-by-value)
• Nested Procedures: Procedures defined within other procedures
• Dynamic Arrays: Arrays with bounds determined at runtime
• Formal Syntax Definition: The first language with a formal grammar (BNF)

The I/O Problem

One notable quirk of ALGOL 60 is that it deliberately did not define input/output operations. The language designers wanted to focus on algorithmic expression and left I/O to individual implementations. This meant that no ALGOL 60 program using I/O was truly portable between different compilers.

Modern implementations like GNU MARST use the I/O procedures from the Modified Report (1976), which include outstring, outinteger, outreal, and similar procedures.

Language Influence

ALGOL 60’s influence on programming language design cannot be overstated:

• Pascal (1970): Niklaus Wirth designed Pascal as a direct descendant of ALGOL 60
• C (1972): Through the chain ALGOL 60 → CPL → BCPL → B → C
• Simula (1967): Extended ALGOL 60 with object-oriented concepts
• PL/I (1964): Combined features from ALGOL 60, FORTRAN, and COBOL
• ALGOL 68 (1968): An ambitious but controversial successor

The basic structure of most modern imperative languages—with their blocks, scopes, conditionals, and loops—can be traced directly to ALGOL 60.

Modern Status

While ALGOL 60 is not used in production today, it remains important for several reasons:

1. Historical Understanding: Learning ALGOL 60 provides insight into the evolution of programming languages
2. Algorithm Description: Many classic algorithms were first published in ALGOL 60 notation
3. Teaching Tool: Understanding ALGOL 60 helps appreciate modern language features
4. Working Implementations: GNU MARST continues to be maintained, allowing ALGOL 60 programs to run on modern systems

Why Learn ALGOL 60?

Studying ALGOL 60 today offers unique benefits:

• See the Origins: Understand where structured programming concepts originated
• Appreciate Progress: Recognize how much (and how little) languages have changed since 1960
• Read Classic Papers: Access the vast literature of algorithms published in ALGOL 60
• Learn Language Design: Understand the principles that guided ALGOL 60’s careful design

ALGOL 60 represents a watershed moment in computing history—a language created by an international committee of brilliant minds that established principles still guiding programming language design today.