ALGOL

ALGOL — ALGOrithmic Language — is the programming language that taught computing how to write itself down. Designed by an international committee between 1958 and 1960, it introduced block structure, nested scopes, begin/end, and a formal grammar so precise that the language could be defined mathematically. ALGOL never sold a million machines or ran the weather — but its ideas run inside essentially every language written since, including Pascal, C, Ada, and AdaLogic BASIC.

A committee instead of a company

Where FORTRAN was IBM's product and LISP was McCarthy's solo design, ALGOL was a diplomatic achievement: an international committee — Americans and Europeans, manufacturers and academics — meeting to design one universal language for expressing algorithms. The joint effort produced ALGOL 58 (originally called IAL), then the refined ALGOL 60, whose report — written in Backus–Naur Form, the first formal grammar notation for a programming language — became the single most influential language document ever published. "Here is a language so far ahead of its time," Tony Hoare said, "that it was not only an improvement on its predecessors but also on nearly all its successors."

What it invented

ALGOL 60's feature list is a catalog of what programming became:

• Block structure and lexical scope — begin … end blocks with variables that exist only inside them. Every { } and every indentation rule in modern code descends from this.
• Nested control flow — if … then … else, for loops as structured constructs rather than bare jumps.
• BNF — the Backus–Naur Form grammar in the ALGOL 60 report was the first time a language's entire syntax was written as formal rules. Every language standard since — including ALB's own specification style — is written in its descendant notations.
• Pass by name vs. pass by value — the parameter-passing question every language designer still has to answer, first posed clearly here.
• Recursive procedures — brought recursion into mainstream procedural programming (LISP had it, but ALGOL made it the default expectation).
• Publication language — the committee intended ALGOL to be the language in which algorithms were published in journals, and for a generation it was exactly that.

begin
    integer n;
    n := 0;
    for i := 1 step 1 until 10 do
        n := n + i;
    outinteger(1, n)
end

Readable, structured, scoped — this is 1960, and it looks like programming.

The dialects and the schism

• ALGOL 58 (1958) — the committee's first draft, rushed but real
• ALGOL 60 (1960) — the classic; the report, the grammar, the model
• ALGOL 68 — the ambitious, complex successor whose design-by-committee fight famously caused Edsger Dijkstra and others to walk out — the "ALGOL 68 schism" that is still held up as the cautionary tale of language design by committee
• ALGOL W — Niklaus Wirth's saner take on the 68 effort; it became Pascal (1970), which carried ALGOL's ideas into every classroom on Earth

The dynasty

ALGOL's direct descendants are most of what the world programs in:

• Pascal → Modula → Oberon — Wirth's teaching dynasty
• CPL → BCPL → B → C — the systems line; C's {} blocks and if/else are ALGOL syntax with braces
• Simula 67 — an ALGOL superset that invented classes and objects — object-oriented programming was born inside an ALGOL compiler
• Ada — the DoD language named for Ada Lovelace, built by people steeped in ALGOL and Pascal; and through Ada's influence, the lineage reaches AdaLogic BASIC

It is not an exaggeration: pick a mainstream language, trace its grammar, and you will find an ALGOL 60 report in the ancestry.

Legacy

• "ALGOL languages" became the name for the entire dominant family of structured imperative languages — C, Java, JavaScript, Python's control flow, Go, Rust, Ada — versus the LISP family on the other branch
• The structured programming it pioneered made the 1968 "Go To statement considered harmful" debate winnable — Dijkstra's famous letter presumes ALGOL-style control flow as the alternative
• It set the template for language standards: formal grammar, reference report, international committee — the process every standardized language now follows
• Machine ALGOL implementations live on in niche spots — but its true survival is genetic, not runtime

See also

• FORTRAN
• LISP
• Ada Lovelace
• History of Programming
• History of Language — BNF descends from Pāṇini
• AdaLogic BASIC

References

1. Naur, Peter, ed. "Report on the Algorithmic Language ALGOL 60." Communications of the ACM 3(5), 1960; Revised Report, CACM 6(1), 1963.
2. Naur, Peter. "The European Side of the Development of ALGOL." In Wexelblat (ed.), History of Programming Languages (Academic Press, 1981).