Diff — 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]]

[[Category:History]]

[[Category:Languages]]