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

Deploy ALGOL W to Europe — Niklaus Wirth 🇨🇭 + Tony Hoare 🇬🇧 (Stanford 1966), the Language Between ALGOL and Pascal, on EU Infrastructure in 2026

In the history of programming languages, some transitions are well-known and others are invisible. Everyone knows that Pascal begat Modula-2, that Modula-2 begat Oberon, and that Robert Griesemer — who wrote his PhD dissertation under Niklaus Wirth at ETH Zürich — co-designed Go with Rob Pike and Ken Thompson at Google. What is less well known is the bridge between ALGOL 60 and Pascal: a language designed at Stanford University in 1966, submitted to the ALGOL committee as a proposal for ALGOL X, rejected, and then rebuilt almost entirely as Pascal four years later at ETH Zürich.

That language is ALGOL W. Designed by Niklaus Wirth 🇨🇭 and C.A.R. (Tony) Hoare 🇬🇧 in a Stanford technical report published in June 1966, ALGOL W is the missing link in European computing history. It is where the record type was invented. Where the string type first appeared in a general-purpose language. Where while loops and case statements first took their modern form. Where Tony Hoare, building the record type's variant mechanism, quietly introduced what he would later call his billion-dollar mistake — the null reference.

Every programming language you use today that has structs, strings, while loops, and null — which is to say every programming language — descends intellectually from a 38-page Stanford technical report written by a Swiss engineer and a British computer scientist in 1966.

Niklaus Wirth 🇨🇭 at Stanford: The European Who Changed American Computing

Niklaus Wirth was born in 1934 in Winterthur 🇨🇭, a city in the canton of Zurich. He studied electrical engineering at ETH Zürich (Eidgenössische Technische Hochschule Zürich), then completed his Master's degree at Université Laval in Québec and his PhD at the University of California, Berkeley (1963), supervised by Harry Huskey, one of the original ENIAC engineers. His dissertation was on the implementation of EULER, an extension of ALGOL 60.

From 1963 to 1967, Wirth was on the faculty of Stanford University, in the Computer Science department (then part of Mathematics). It was during this Stanford period — at the crossroads of ALGOL 60, the nascent field of programming language theory, and the practical demands of real system implementation — that Wirth produced ALGOL W.

Wirth returned to ETH Zürich in 1967 as a full professor and would spend the rest of his career there. His subsequent languages — Pascal (1970), Modula (1975), Modula-2 (1978), Oberon (1987), and Oberon-07 — are all continuations of intellectual threads begun in ALGOL W. When Wirth died on 1 January 2024 at age 89, the tributes that came from across the computing world were testimony to a career whose influence touched every corner of the discipline — from embedded systems to formal methods to language design pedagogy.

ETH Zürich 🇨🇭, where Wirth spent four decades, is one of Europe's greatest technical universities. It has produced 22 Nobel laureates and numerous Turing Award winners. Wirth himself received the ACM Turing Award in 1984 for developing "a sequence of innovative computer languages, EULER, ALGOL-W, Modula and Pascal." ALGOL W is explicitly named in his Turing Award citation. It is not a footnote — it is a chapter.

C.A.R. Tony Hoare 🇬🇧: From Quicksort to Formal Methods

Charles Antony Richard Hoare was born in 1934 in Colombo (now Sri Lanka), grew up in England, and read Greats (Classics) at Merton College Oxford before switching to philosophy and then statistics. He learned programming at Moscow State University in 1959–1960, during a British Council scholarship, studying under Andrei Kolmogorov — one of the founders of modern probability theory. On returning to England, he joined Elliott Brothers Ltd, a British computing company based in Borehamwood, Hertfordshire 🇬🇧.

At Elliott Brothers in 1960, at age 26, Hoare invented Quicksort — still the most widely used comparison sorting algorithm in production software, 65 years later. The algorithm emerged from his attempt to implement a Russian-to-English translation programme that required a fast way to sort words into alphabetical order. He published the algorithm in the Communications of the ACM in 1961 and it became one of the most-cited papers in computer science history.

Hoare joined Stanford University in 1962 as a visiting researcher, where he encountered Wirth and the ALGOL community. The intellectual collaboration between Wirth and Hoare that produced ALGOL W represents one of the most productive pairings in programming language history: Wirth's systematic, engineering-oriented approach to language design (clarity, implementability, economy of mechanism) combined with Hoare's mathematical rigour and interest in formal properties of programmes.

After Stanford, Hoare joined Queen's University Belfast 🇬🇧 (1968), where he developed Hoare Logic — the axiomatic basis for formal program verification. He then moved to Oxford University 🇬🇧 as Professor of Computing in 1977, where he remained until 1999, building the Oxford University Computing Laboratory's Programming Research Group into one of the world's leading centres for formal methods. He was knighted in 2000 (Sir Antony Hoare KBE FRS) and moved to Microsoft Research Cambridge 🇬🇧 in 1999, continuing research on formal methods and concurrency theory.

Hoare received the ACM Turing Award in 1980 "for his fundamental contributions to the definition and design of programming languages." The citation covers Quicksort, Hoare Logic, and CSP — but the record type in ALGOL W, from which Hoare Logic directly grew, is the conceptual root.

ALGOL W: The Technical Report That Changed Everything

In June 1966, Wirth and Hoare published "A Contribution to the Development of ALGOL" as Stanford Computer Science Technical Report CS 66-1. It was submitted to the ALGOL committee as a proposal for ALGOL X — the intended successor to ALGOL 60. The report described a language that retained ALGOL 60's core structure (block structure, lexical scoping, recursion, call by value, call by name) while adding several new facilities that ALGOL 60 had conspicuously lacked.

Records with Variant Fields: The First Struct

ALGOL 60 had arrays, but no structured record types — no way to group heterogeneous data fields under a single named variable. Every subsequent language had to invent this independently. ALGOL W formalised it as a language primitive.

An ALGOL W record was declared with a type name and a list of typed fields:

RECORD PERSON (
  STRING(20) NAME;
  INTEGER AGE;
  LOGICAL EMPLOYED
)

Records could be allocated dynamically (heap allocation) and accessed via references — pointers, in modern terminology. This gave ALGOL W the ability to build linked data structures: linked lists, trees, graphs. ALGOL 60 had no heap allocation; it was a stack-only language.

Variant records allowed a single record type to have different field layouts depending on a discriminant tag:

RECORD SHAPE (
  INTEGER TAG;
  CASE TAG OF
    1: (REAL RADIUS);           (* circle *)
    2: (REAL WIDTH, HEIGHT)     (* rectangle *)
)

This is the discriminated union — today called a tagged union, sum type, or enum with data (Rust), algebraic data type (Haskell), or sealed class (Kotlin/Scala). Every functional programming language's ADTs descend from this mechanism. Hoare's contribution to ALGOL W was specifically in the design and formalisation of this record variant mechanism.

The Null Reference: Hoare's Billion-Dollar Mistake

When ALGOL W introduced reference types for records, it needed a way to represent "no reference" — a pointer that points to nothing. Hoare introduced NULL (or NONE in the ALGOL W implementation) as a special value assignable to any reference type.

At the 2009 QCon London conference, Hoare gave a talk titled "Null References: The Billion Dollar Mistake":

"I call it my billion-dollar mistake. It was the invention of the null reference in 1965. At that time, I was designing the first comprehensive type system for references in an object oriented language [ALGOL W]. My goal was to ensure that all use of references should be absolutely safe, with checking performed automatically by the compiler. But I couldn't resist the temptation to put in a null reference, simply because it was so easy to implement. This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years."

Hoare was not merely speaking colloquially. The null pointer dereference is the single most common class of software defect in C, C++, Java, C#, Python, and virtually every other language that adopted null references from ALGOL W's precedent. Modern languages — Rust, Kotlin, Swift, TypeScript — have spent decades designing around the problem that Hoare acknowledged he introduced in 1965.

The intellectual honesty of Hoare's retrospective is characteristic. The same rigour that produced Hoare Logic — the formal system for reasoning about program correctness — is the rigour that led Hoare to examine the consequences of his own design decisions sixty years later.

Strings: The First Built-In String Type

ALGOL 60 had no string type. Strings were represented as arrays of characters, with no built-in operations. ALGOL W introduced STRING(n) as a first-class type: fixed-length strings with built-in comparison, assignment, and substring operations.

STRING(20) FIRSTNAME, LASTNAME;
FIRSTNAME := "NIKLAUS";
LASTNAME := "WIRTH";
IF FIRSTNAME < LASTNAME THEN ...  (* lexicographic comparison *)

This was the first general-purpose language to include strings as a native type — predating Pascal's string type, C's char* convention, and BASIC's string variables by several years.

While Loops and Case Statements

ALGOL 60 had a for statement but no while loop in the modern sense. Its for loop was powerful but baroque. ALGOL W introduced:

WHILE loop — iterate while a condition holds:

WHILE I > 0 DO BEGIN
  I := I DIV 2;
  BITS := BITS + 1
END

CASE statement — branch on an integer expression:

CASE OPCODE OF
BEGIN
  1: ADD(A, B);
  2: SUB(A, B);
  3: MUL(A, B)
END

These are both so commonplace today that it requires historical perspective to appreciate that they did not exist before ALGOL W. Every programming language you know — C, Java, Python, Go, Rust — has these control structures in direct or near-direct descent from ALGOL W.

Call by Value-Result

ALGOL 60 used call by name (Algol's famous but treacherous Jensen's Device) and call by value. ALGOL W added call by value-result: the parameter is passed by value (a copy is made on entry) and the final value of the copy is written back to the actual parameter on return. This is distinct from call by reference (which passes the address of the actual parameter). Call by value-result is the "safe" analogue of call by reference — it avoids aliasing problems.

Wirth would later simplify this in Pascal to a clean distinction between value parameters and VAR (reference) parameters, abandoning value-result entirely. But the ALGOL W mechanism was an important step in making parameter passing semantics explicit and reasoning about it formal.

The Committee Rejected ALGOL W. Wirth Built Pascal.

The ALGOL committee — the international body responsible for ALGOL's successor — met in 1966 to evaluate proposals for ALGOL X. Two competing proposals existed:

ALGOL W (Wirth + Hoare): clean, implementable, conservative extension of ALGOL 60
ALGOL 68 (Adriaan van Wijngaarden 🇳🇱, CWI Amsterdam): radical redesign with orthogonal semantics, a two-level grammar (W-grammars), and extraordinary complexity

The committee chose ALGOL 68. The reasons were partly political (the European computing establishment was heavily invested in van Wijngaarden's work) and partly philosophical (ALGOL 68 was theoretically more elegant, even if practically harder to implement).

ALGOL 68 was a disaster in practice. Its specification was so complex that only a handful of compilers were ever successfully built. The most notable was the British ALGOL 68R (Royal Radar Establishment, Malvern 🇬🇧). ALGOL 68 never achieved the commercial adoption its creators hoped for. Van Wijngaarden, one of the greatest computer scientists of the twentieth century, had designed a language that was intellectually magnificent and practically unusable.

Wirth was frustrated. He believed — correctly, as history would confirm — that simplicity and clarity in language design were more important than theoretical elegance. He returned to ETH Zürich in 1967, and in 1970 published Pascal — essentially ALGOL W, refined and extended, with the committee noise removed.

Pascal's direct descent from ALGOL W is not a matter of speculation. The core innovations are identical: records, strings, while loops, case statements, clean parameter passing. Wirth simply took the language he and Hoare had designed at Stanford, polished it over three years of teaching and implementation experience, and released it to the world.

The world used it. Pascal became the dominant teaching language of the 1970s and 1980s. Turbo Pascal (Anders Hejlsberg 🇩🇰, Copenhagen, Borland, 1983) brought Pascal to millions of PC programmers. Hejlsberg went on to design Delphi, then C#, then TypeScript — and in TypeScript's optional static type system, structural types, and interface declarations, you can still trace the ghost of ALGOL W's typed record mechanism.

Hoare Logic: From Record Types to Formal Verification

The variant record mechanism in ALGOL W — where a record has different field layouts in different states — is precisely the kind of construct that demands formal reasoning. How can you prove that a programme accessing a circle's radius field never executes when the discriminant tag says "rectangle"? You need a logic of programme states.

This is exactly what Hoare built. In 1969, at Queen's University Belfast, Hoare published "An Axiomatic Basis for Computer Programming" in the Communications of the ACM. This paper introduced what is now called Hoare triples: assertions of the form {P} S {Q}, where P is a precondition, S is a statement, and Q is a postcondition. The Hoare triple asserts: if P holds before executing S, then Q holds after.

{x > 0} y := x * 2 {y > 0 ∧ y = 2x}

The system includes axioms for assignment, conditional, while loop, and procedure call — the exact control structures in ALGOL W. The intellectual connection is direct: Hoare built the formal verification framework for the language he had just designed.

Hoare Logic in 2026:

The EU Artificial Intelligence Act (Regulation (EU) 2024/1689), which came into force in August 2024, mandates formal verification for high-risk AI systems under Article 9 (Risk Management System) and Article 15 (Accuracy, Robustness, and Cybersecurity). The specific requirement is for technical documentation demonstrating that the AI system has been tested and validated to ensure it meets the required accuracy and robustness levels.

Hoare Logic — and its descendants, including Separation Logic (Peter O'Hearn 🇬🇧 + John Reynolds 🇺🇸, 1999–2001), Abstract Interpretation (Patrick Cousot 🇫🇷 + Radhia Cousot 🇫🇷, INRIA, 1977), and Model Checking (Edmund Clarke 🇺🇸 + E. Allen Emerson + Joseph Sifakis 🇬🇷🇫🇷, Turing Award 2007) — are the primary tools used for formal verification of software safety properties. When a medical device manufacturer submits DO-178C Level A evidence for airborne software (Airbus A350, Boeing 787), or when a railway operator submits EN 50128 SIL 4 evidence for traction control software (TGV, ICE, Thalys), or when an AI system developer submits EU AI Act Art. 9 conformity documentation — Hoare Logic is in the toolchain.

The intellectual chain is unbroken: ALGOL W (Wirth + Hoare, Stanford 1966) → Hoare Logic (1969) → Separation Logic (O'Hearn 2001) → EU AI Act formal verification (2024).

The ALGOL W Implementation: Stanford to Oxford

ALGOL W was implemented as a compiler at Stanford in 1966–1967. The compiler was bootstrapped — written in ALGOL W itself, with an initial handwritten bootstrap. This self-hosting bootstrap is itself notable: bootstrapping a compiler is a technical challenge that requires careful staging, and doing it for a new language in 1966 was not trivial.

The Stanford implementation was subsequently taken to the Oxford University Computing Laboratory 🇬🇧 by the Programming Research Group. The Oxford ALGOL W compiler became the primary reference implementation and was used to teach programming and formal methods at Oxford through the 1970s and into the 1980s.

Modern ALGOL W:

A modern ALGOL W implementation is available at github.com/gungwald/algol-w. It is based on the Stanford/Oxford specification and compiles to C, which means ALGOL W programs can run on any platform with a C compiler — including Linux servers and Docker containers.

# Clone and build
git clone https://github.com/gungwald/algol-w
cd algol-w
make

# Run the classic ALGOL W hello
./alw hello.alw

The primary use cases in 2026 are historical computing education, language research, and formal methods pedagogy. ALGOL W is taught in programming language theory courses as the bridge between ALGOL 60 and Pascal, and as the historical origin of record types and variant records.

Deploying ALGOL W to Europe with sota.io

sota.io is EU-native PaaS built on German infrastructure: zero-DevOps deployments, managed PostgreSQL 17, automatic TLS, GDPR-compliant data residency, and container-based execution. An ALGOL W programme compiled via GCC (through the C backend) deploys identically to any other native binary.

Docker-based deployment:

FROM ubuntu:22.04

RUN apt-get update && apt-get install -y \
    git \
    build-essential \
    gcc \
    && rm -rf /var/lib/apt/lists/*

# Build the ALGOL W compiler
RUN git clone https://github.com/gungwald/algol-w /algolw && \
    cd /algolw && make

# Copy your ALGOL W source
COPY src/ /app/src/
WORKDIR /app

# Compile ALGOL W to C, then to native binary
RUN /algolw/alw -c src/main.alw -o main.c && gcc -O2 -o main main.c

CMD ["./main"]

Example ALGOL W programme — computing Fibonacci:

BEGIN
  INTEGER PROCEDURE FIBONACCI (INTEGER VALUE N);
  BEGIN
    IF N <= 1
      THEN FIBONACCI := N
      ELSE FIBONACCI := FIBONACCI(N - 1) + FIBONACCI(N - 2)
  END;

  INTEGER I;
  FOR I := 0 UNTIL 15 DO
    WRITE(FIBONACCI(I))
END.

Example using records (ALGOL W's distinctive contribution):

BEGIN
  RECORD PERSON (
    STRING(30) NAME;
    INTEGER AGE;
    REFERENCE(PERSON) NEXT
  );

  REFERENCE(PERSON) HEAD, CURRENT;

  (* Build a linked list of persons *)
  HEAD := NEW PERSON;
  NAME(HEAD) := "WIRTH";
  AGE(HEAD) := 32;   (* Wirth's age when he designed ALGOL W *)

  CURRENT := NEW PERSON;
  NAME(CURRENT) := "HOARE";
  AGE(CURRENT) := 32;
  NEXT(HEAD) := CURRENT;
  NEXT(CURRENT) := NULL;

  (* Traverse *)
  CURRENT := HEAD;
  WHILE CURRENT NOT = NULL DO BEGIN
    WRITE(NAME(CURRENT), AGE(CURRENT));
    CURRENT := NEXT(CURRENT)
  END
END.

sota.io deployment:

# Install the sota.io CLI
npm install -g sota-cli

# Authenticate
sota auth login

# Deploy from your project directory
sota deploy --region eu-central-1 --name algol-w-service

# Your ALGOL W service is live on EU infrastructure
# https://algol-w-service.sota.app

All data stays in the EU. PostgreSQL 17 available for persistent storage. TLS terminated at the edge. GDPR-compliant by infrastructure default.

EU Compliance: ALGOL W's Legacy in Regulation

GDPR Art. 25 (Data Protection by Design and by Default): ALGOL W's record type system enforces data structure boundaries at compile time. A PERSON record cannot accidentally contain an ORDER record's fields; the type system prevents it. This compile-time enforcement of data category separation is the architectural pattern underlying GDPR Art. 25's requirement that data controllers implement technical measures that ensure, by default, only personal data necessary for each specific purpose is processed.

Modern GDPR-compliant systems implement exactly this pattern in their data models: separate record types for PII, financial data, and operational data, with no accidental cross-contamination possible through the type system. The concept, though not the terminology, originates in ALGOL W.

EU AI Act Art. 9 (Risk Management System) + Art. 15 (Robustness): Hoare Logic — born directly from the intellectual work of ALGOL W — is a primary tool for demonstrating that an AI system or software component meets the formal correctness requirements of the EU AI Act for high-risk AI applications. Formal verification of pre/post-conditions on critical software pathways is achievable through Hoare Logic toolchains (Dafny, Frama-C, SPARK/Ada), all of which implement Hoare's 1969 framework.

NIS2 Directive (Directive (EU) 2022/2555) — Software Supply Chain: The variant record mechanism — a discriminated union where you know at all times which variant is active — eliminates an entire class of type confusion vulnerabilities. Modern security research shows that type confusion in C (where a union's tag is ignored or corrupted) is a primary attack vector. Languages that enforce discriminated unions at the type system level — Rust's enum, Kotlin's sealed class, TypeScript's discriminated unions — provide NIS2-relevant security guarantees. The design pattern traces back to ALGOL W 1966.

The Wirth Lineage: One Continuous Thread

Plankalkül (Zuse 🇩🇪, Berlin 1942)
    ↓
ALGOL 60 (Naur 🇩🇰, Dijkstra 🇳🇱, van Wijngaarden 🇳🇱, Bauer 🇩🇪, 1960)
    ↓
ALGOL W (Wirth 🇨🇭 + Hoare 🇬🇧, Stanford 1966) ← YOU ARE HERE
    ↓                       ↓
Pascal (Wirth 🇨🇭,         Hoare Logic (Hoare 🇬🇧,
 ETH Zürich 1970)           Queen's Belfast 1969)
    ↓                           ↓
Turbo Pascal (Hejlsberg 🇩🇰,  Separation Logic, Abstract Interpretation
 Copenhagen 1983)               Model Checking, EU AI Act Art. 9
    ↓
Delphi → C# → TypeScript (Hejlsberg 🇩🇰)
    ↓
Modula-2 (Wirth 🇨🇭, 1978)
    ↓
Oberon (Wirth 🇨🇭, 1987)
    ↓
Go (Griesemer 🇨🇭 PhD under Wirth → Go co-designer, 2009)

Every link in this chain has a European address. Plankalkül: Berlin. ALGOL 60: European committee. ALGOL W: Wirth from Winterthur, Hoare educated at Oxford. Pascal, Modula-2, Oberon: ETH Zürich. Turbo Pascal: Copenhagen. Go: Griesemer PhD at ETH Zürich before joining Google Zürich.

European computing is not a footnote to American computing. It is a parallel tradition — in some respects, the older and foundational tradition — that has shaped every layer of the software stack.

Why Deploy ALGOL W on sota.io

GDPR-compliant infrastructure by default: All services run on German infrastructure. Your data does not leave the EU. No Privacy Shield concerns, no Schrems-II risk, no EU Data Act complications. Infrastructure compliance is built in.

Zero DevOps for heritage computing research: sota.io's container-based deployment means you can run ALGOL W programmes — or any compiler-to-C workflow — without managing servers. Upload a Dockerfile, get a running service.

Managed PostgreSQL 17: ALGOL W programmes that need persistent storage can connect to a fully managed PostgreSQL 17 instance with automatic backups, point-in-time recovery, and EU data residency.

EU AI Act conformance documentation: If you are running formal verification toolchains (Dafny, Frama-C, Why3, SPARK) on sota.io infrastructure for EU AI Act Art. 9 compliance documentation, your verification infrastructure itself runs in the EU — relevant for regulated industries (financial services under DORA, healthcare under MDR, aviation under EASA).