sota.io
2026-04-02·9 min read·sota.io team

Deploy ALGOL to Europe — Peter Naur 🇩🇰 Copenhagen + The Language That Invented Structured Programming on EU Infrastructure in 2026

In 1958, representatives of two scientific societies met in Zürich, Switzerland, to design a universal programming language. The meeting was organised jointly by the ACM (Association for Computing Machinery, United States) and GAMM (Gesellschaft für Angewandte Mathematik und Mechanik, Germany). The language they produced — ALGOL, the Algorithmic Language — became the foundation on which the entire structure of modern programming rests. Every language you use today descends from decisions made by that European-majority committee.

ALGOL gave programming the block structure that makes nested scopes possible. It gave the world BNF — Backus-Naur Form, the notation used to specify the syntax of every programming language since 1960, and the notation used in every EU technical standard that defines a formal grammar. It introduced recursive procedures as a standard feature. It established lexical scoping as the default semantics for variable resolution. It drew the conceptual boundary between algorithm and machine, between the idea of computation and its hardware execution.

The designers were European and American in roughly equal measure. But the intellectual leadership — the editing, the clarification, the formal rigor — came overwhelmingly from Europe: from Copenhagen, from Amsterdam, from Munich, from Zürich.

Peter Naur and the ALGOL 60 Report

The document that defined ALGOL 60 — the Revised Report on the Algorithmic Language ALGOL 60, published in 1963 — was edited by Peter Naur 🇩🇰. Naur was born in 1928 in Frederiksberg, Copenhagen, Denmark. He studied astronomy at the University of Copenhagen and worked as a computational astronomer before becoming interested in programming languages. He received the ACM Turing Award in 2005 — at age 77, one of the oldest recipients in the award's history — specifically for his work on ALGOL and his contributions to the formal specification of programming languages.

The reason Naur's name is attached to BNF — Backus-Naur Form — is that while John Backus invented the notation, Naur substantially revised and extended it for use in the ALGOL 60 report, making it practical as a specification tool. BNF is the language for describing languages. Every parser generator (Yacc, Bison, ANTLR, PEG.js), every language reference manual, every RFC and ISO standard that specifies a syntax, uses a notation derived from the work Naur did editing the ALGOL 60 report in Copenhagen in the early 1960s.

Naur remained at the University of Copenhagen for most of his career. He never moved to the United States. He argued, throughout his life, that programming was a human intellectual activity that required understanding over formalism — that languages should be designed to serve programmer thinking, not compiler convenience. He died in 2016.

Edsger Dijkstra, Adriaan van Wijngaarden, and CWI Amsterdam

The Centrum Wiskunde & Informatica (CWI) in Amsterdam — the Dutch national research institute for mathematics and computer science — was one of the most productive computing research institutions of the twentieth century. It is where the two most influential Dutch contributors to ALGOL worked.

Adriaan van Wijngaarden 🇳🇱 (1916–1987) directed the Mathematical Centre (later CWI) from 1947 and led the Dutch contribution to ALGOL 60. He then led the design of ALGOL 68 — the most powerful and most formally rigorous version of ALGOL — published in 1968. ALGOL 68 was designed according to van Wijngaarden's two-level grammars (also called W-grammars), which could express the context-sensitive syntax of programming languages in a way that BNF could not. ALGOL 68's type system — orthogonal, fully composable, supporting procedures as first-class values — was decades ahead of what mainstream languages would eventually adopt.

Edsger W. Dijkstra 🇳🇱 (1930–2002) was a research associate at the Mathematical Centre in Amsterdam when ALGOL 60 was being designed. He wrote the first ALGOL 60 compiler — the first implementation of the language — while still in his twenties. He received the ACM Turing Award in 1972 for fundamental contributions to programming as a high, intellectual challenge. His Turing Award lecture, The Humble Programmer, argued that the purpose of programming languages is to make it possible to express correct programs and impossible — or at least difficult — to express incorrect ones. ALGOL's block structure, he argued, was the first step toward that goal.

Dijkstra later formulated the semaphore as the synchronisation primitive for concurrent systems, developed the concept of structured programming (making GOTO harmful), proved the correctness of concurrent algorithms, and developed the THE operating system at Eindhoven University of Technology — the first layered operating system with formal correctness proofs for each layer. NIS2's requirements for critical infrastructure software to use formal design methods descend, intellectually, from the tradition Dijkstra established at CWI and Eindhoven.

Friedrich Bauer, Heinz Rutishauser, and the GAMM Committee

The GAMM (German Society for Applied Mathematics and Mechanics) side of the original ALGOL committee included some of the most rigorous European computing researchers of the era.

Friedrich L. Bauer 🇩🇪 (1924–2015) was a professor at the Technische Hochschule München (TH Munich). Together with Klaus Samelson, he developed the stack principle for expression evaluation — the algorithm that every compiler and every CPU uses to evaluate arithmetic expressions and manage procedure calls. Bauer remained a professor at Munich throughout his career and was one of the founders of the Gesellschaft für Informatik, the German computer science professional society. He received the IEEE Computer Pioneer Award in 1988.

Heinz Rutishauser 🇨🇭 (1918–1970) was a professor at ETH Zürich. He had designed one of the first higher-level programming languages — Superplan (1949) — before ALGOL existed, and his work on automatic computation influenced the ALGOL committee's design decisions. ETH Zürich, which would later produce Niklaus Wirth's Pascal, Modula-2, and Oberon, was already contributing to the foundations of structured programming through Rutishauser's committee membership. The Swiss academic tradition — formal rigor, correctness over convenience — runs from Rutishauser through Wirth to the present day.

ALGOL's Invention: Block Structure and Lexical Scoping

ALGOL 60's most lasting contribution was block structure: the ability to nest scopes, to declare variables with limited lifetimes, to compose programs from hierarchical units that encapsulate their internal names. A block in ALGOL 60 begins with begin and ends with end. Variables declared inside a block exist only within that block. Procedures can be nested inside other procedures, inheriting the variables of their enclosing scope according to the rules of lexical scoping — the name refers to the textual position of the declaration, not the dynamic call stack.

BEGIN
  INT count := 0;
  STRING name := "data-subject";

  PROC process = (INT id, STRING email) VOID:
  BEGIN
    # Inner block: variables scoped here only #
    BOOL gdpr_consent := TRUE;
    INT timestamp := seconds since epoch;

    IF gdpr_consent
    THEN
      count +:= 1;
      print(("Processing ", name, " #", id, newline))
    FI
  END;  # gdpr_consent and timestamp end here #

  process(42, "user@example.eu")
END

The gdpr_consent and timestamp variables do not exist outside the inner BEGIN...END block. This is not a convention — it is enforced by the language's semantics. The variable cannot be accessed, cannot be leaked, cannot be accidentally retained after the block exits. ALGOL 60 made this guarantee in 1960. Modern languages are still discovering its value.

Lexical scoping means that when a procedure references a variable, the compiler looks for that variable in the textual scope where the procedure was defined — not in the dynamic scope of where it is called. This makes programs referentially transparent: the meaning of a name is determined by its position in the source text, not by runtime state. Every functional programming language, every modern language with closures, every JavaScript module system implements lexical scoping. ALGOL 60 introduced it.

BNF: The Notation That Defines All Languages

The Backus-Naur Form was developed to specify the syntax of ALGOL 60 in a precise, machine-readable way. Before ALGOL 60, programming language syntax was described in English prose — ambiguous, inconsistent, difficult to implement correctly. The ALGOL 60 report introduced a formal notation in which production rules of the form <identifier> ::= <letter> | <identifier><letter> | <identifier><digit> precisely specified what strings of characters constituted valid programs.

BNF is now used everywhere that precise syntax specification is required:

When regulators write technical standards that computers must parse — for financial messages (ISO 20022 for SEPA), for healthcare data (HL7 FHIR), for telecommunications protocols (3GPP) — they use syntax specification languages whose lineage traces directly to the BNF notation Peter Naur 🇩🇰 refined in Copenhagen for the ALGOL 60 report.

ALGOL 68 in 2026: algol68g on Ubuntu

The most practical ALGOL implementation available today is Algol 68 Genie (algol68g), maintained by Marcel van der Veer 🇳🇱 at the University of Amsterdam — continuing the Dutch ALGOL tradition that van Wijngaarden and Dijkstra established at CWI sixty years earlier. algol68g is available in standard Ubuntu and Debian repositories.

FROM ubuntu:24.04 AS builder

RUN apt-get update && apt-get install -y \
    algol68g \
    libpq-dev \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY service.a68 /app/service.a68

# Compile ALGOL 68 to native binary
RUN a68g --compile service.a68 -o service

FROM ubuntu:24.04
RUN apt-get update && apt-get install -y \
    libpq5 \
    && rm -rf /var/lib/apt/lists/*
COPY --from=builder /app/service /app/service
EXPOSE 8080
CMD ["/app/service"]

An ALGOL 68 HTTP service with PostgreSQL integration:

BEGIN
  # ALGOL 68 HTTP service — deploy on sota.io EU infrastructure #
  # algol68g on Ubuntu 24.04: apt install algol68g                #

  MODE DATASUBJECT = STRUCT(
    INT id,
    STRING email,
    INT consent_ts,
    BOOL retained
  );

  PROC insert subject = (DATASUBJECT ds) BOOL:
  BEGIN
    # GDPR Art. 25: data minimisation enforced by mode declaration #
    # Only fields in DATASUBJECT mode are accessible here           #
    STRING query = "INSERT INTO subjects VALUES ($1,$2,$3,$4)";
    pg execute(query, id OF ds, email OF ds, consent ts OF ds, retained OF ds)
  END;

  PROC erase subject = (INT id) BOOL:
  BEGIN
    # GDPR Art. 17: right to erasure — explicit procedure          #
    pg execute("DELETE FROM subjects WHERE id = $1 AND retained = FALSE", id)
  END;

  PROC handle request = (STRING method, STRING path, STRING body) STRING:
  BEGIN
    IF method = "DELETE"
    THEN
      INT subject id = parse int(path[9:]);
      IF erase subject(subject id)
      THEN "{""status"":""erased""}"  # GDPR Art. 17 confirmed     #
      ELSE "{""status"":""not found""}"
      FI
    ELSE "{""status"":""ok"",""server"":""sota.io EU""}"
    FI
  END;

  print(("ALGOL 68 service — CWI Amsterdam tradition", newline));
  print(("Van Wijngaarden 🇳🇱 1968, running on EU infrastructure", newline));
  http serve(8080, handle request)
END

The MODE DATASUBJECT declaration is ALGOL 68's type system at work: only the fields declared in the mode are accessible to code that holds a DATASUBJECT value. ALGOL 68's orthogonal type system — where any type can be composed from any other type, where procedures are values, where rows (arrays) of procedures of modes of references are all valid — anticipated by decades the type systems that Haskell, OCaml, and Rust would eventually popularise.

GDPR and EU Regulatory Compliance

GDPR Article 25 — Privacy by Design via Block Scoping

ALGOL 60's block structure is the original architectural realisation of data minimisation. Variables declared inside a block — a GDPR consent processing routine, a personal data transformation, an audit logging procedure — do not exist outside that block. They cannot be retained, cannot be accidentally exposed, cannot persist beyond the operation that required them.

When GDPR Article 25 requires "data protection by design and by default," the principle it describes is precisely what block-scoped variables implement: data exists only for the duration and in the scope where it is necessary. Every modern language that implements block scoping — which is every language — implements this principle because ALGOL 60 defined it in 1960.

GDPR Article 17 — Auditability Through Explicit Procedures

ALGOL 68's mode system and procedure declarations create an auditable trail of data operations. An erase subject procedure is a named, typed, explicitly declared unit of GDPR compliance. Static analysis tools can verify that every code path that accesses personal data is reachable only through declared procedures with documented semantics. There are no implicit data flows, no hidden field accesses — the mode system prevents them.

EU AI Act Article 9 — Structured Correctness

Dijkstra's structured programming — which ALGOL's block structure made possible — is the foundation of formal program verification. The EU AI Act requires high-risk AI systems to demonstrate correctness properties. The chain from ALGOL's block structure through Dijkstra's program correctness proofs through Hoare logic (Tony Hoare 🇬🇧 developed Hoare logic directly inspired by ALGOL) through modern formal verification tools (Why3, Frama-C, SPARK Ada) is direct and documented.

NIS2 — BNF and Formal Protocol Specification

NIS2 requires critical infrastructure operators to document their communication protocols formally. BNF — invented for ALGOL and now used in every RFC, every ISO standard, every ETSI specification — is the standard notation for that formal documentation. When a NIS2 audit requires a formally specified communication protocol, it implicitly requires BNF, which traces to Peter Naur 🇩🇰 and the ALGOL 60 committee.

The Complete ALGOL Family Tree

ALGOL's influence on modern programming is total. Every language in production today descends from decisions the ALGOL committee made:

The European committee that met in Zürich in 1958 built the conceptual infrastructure on which the entire software industry runs. Block structure, recursion, lexical scoping, formal grammars, structured programming — these are not ALGOL features that modern languages decided to adopt. They are the foundation that makes modern languages possible.

Deploy ALGOL on sota.io

sota.io supports any language that compiles to a Linux binary or runs in a standard container. An ALGOL 68 application built with algol68g and containerised as shown above deploys with:

sota deploy --region eu-west

The platform detects the container, provisions EU infrastructure on Hetzner (Germany) or Scaleway (France), injects managed PostgreSQL credentials as environment variables, configures TLS termination, and assigns a .sota.io subdomain. All infrastructure runs within the European Economic Area.

algol68g generates native binaries on Linux. The compiler's output links against standard C libraries, so integration with libpq (PostgreSQL) and other system libraries is straightforward through ALGOL 68's C foreign function interface. The resulting binary is a standard ELF executable — no runtime required.

The language Peter Naur 🇩🇰 edited in Copenhagen, that Edsger Dijkstra 🇳🇱 first implemented in Amsterdam, that Adriaan van Wijngaarden 🇳🇱 extended at CWI, that Friedrich Bauer 🇩🇪 and Heinz Rutishauser 🇨🇭 specified in committee — is still compilable, still deployable, still correct. The ideas it introduced in 1960 are still the foundation of every language written since.

sota.io is the EU-native platform-as-a-service for developers who need European infrastructure, GDPR compliance by default, and managed PostgreSQL without the operational overhead. Deploy your ALGOL application to EU servers in minutes at sota.io.

See Also