ALGOL's Influence

The ALGOL 60 Report made BNF the standard way to define syntax.

40.1 BNF and formal language definition

The ALGOL 60 Report made BNF the standard way to define syntax. Every language specification since — Pascal, C, Ada, Java, Python's grammar files, SQL, the RFCs that define Internet protocols (ABNF) — uses a BNF descendant. Parser generators (yacc, Bison, ANTLR) consume BNF-like grammars directly. ALGOL 68's W-grammar inspired attribute grammars and formal semantics research.

40.2 Structured programming

ALGOL 60's block structure, nested scopes, and compound statements made it possible to write programs as nested structures instead of flat jumps.

Dijkstra's "Go To Statement Considered Harmful" (1968) and *Notes on Structured Programming* (1970), Wirth's stepwise refinement (1971), and Hoare's axiomatic semantics (1969) were all expressed in ALGOL-like notation.

"ALGOL-like" became the default pseudocode of computer science textbooks — including Knuth's and Cormen et al.'s styles.

40.3 Pascal and the Wirth family

Pascal (1970) took ALGOL W's ideas — records, pointers, case, while, repeat — added user-defined types and sets, removed call by name (value and var parameters), and became the dominant teaching language of the 1970s–80s. Wirth continued with Modula (1975), Modula-2 (1978, modules and coroutines) and Oberon (1987). Borland's Turbo Pascal and Delphi (Object Pascal) carried the line into industry.

40.4 C and its descendants

C descends from ALGOL 60 via CPL (1963) → BCPL (Martin Richards, 1967) → B (Ken Thompson) → C (Dennis Ritchie, 1972). ALGOL contributed block structure, lexical scope, recursion and free-format syntax ({ } are BCPL's $( $), ultimately ALGOL's begin end). Ritchie acknowledged ALGOL 68 influence on C's type system: the words void, struct, union, long/short, casts, and compound assignment (+=, which ALGOL 68 writes +:=) all appear in ALGOL 68. C++, Java, C#, JavaScript and Go inherit all of this.

40.5 Simula and object orientation

Simula 67 (Dahl & Nygaard) extended ALGOL 60 with classes, objects, inheritance and virtual procedures — the origin of object-oriented programming. Bjarne Stroustrup built C++ ("C with Classes") on Simula's ideas; Alan Kay cited Simula as an inspiration for Smalltalk.

40.6 Ada

Ada (1980, standardized 1983) descends from Pascal (the winning "Green" design by Jean Ichbiah's team was Pascal-based), and so from ALGOL W and ALGOL 60: block structure, strong typing, nested procedures, in/out/in out parameter modes (compare ALGOL W's value/result), and tasking ideas related to ALGOL 68's parallel clauses. ALGOL 68 influenced Ada's operator overloading and its attention to formal definition.

40.7 ALGOL 68's visible fingerprints

ALGOL 68 feature Where you see it today IF... FI, CASE... ESAC, DO... OD

Bourne shell (if ... fi, case ... esac; do ... done) — Steve Bourne worked on ALGOL 68C

VOID, STRUCT, UNION, casts, LONG/SHORT +:= compound assignment

C's += and almost every language since user-defined operators with priorities Haskell, Scala, Swift, C++ overloading tagged unions + conformity case

ML/Haskell algebraic data types, Rust enum + match, Swift enums everything is an expression

Rust, Ruby, Scala, Kotlin if expressions garbage-collected heap + stack nearly all modern managed languages orthogonality as a design principle discussed in every language design course

40.8 Other lasting ideas

Recursion and the run-time stack as standard machinery (ALGOL 60).

Call by name → lazy evaluation, thunks, by-name parameters in Scala.

Dynamic arrays sized at run time → variable-length arrays, alloca, managed arrays.

Stack machines (Burroughs B5000) → the JVM, .NET CLR, WebAssembly evaluation stacks.

Language-independent algorithm publication → today's pseudocode conventions.