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

Deploy ABC to Europe — Lambert Meertens 🇳🇱 + Leo Geurts 🇳🇱 (CWI Amsterdam), the Language That Taught Python Everything on EU Infrastructure in 2026

In 1991, Guido van Rossum 🇳🇱 released Python 0.9.0 to the Usenet group alt.sources. He had been working on it since Christmas 1989, while on holiday from his job at CWI Amsterdam — the Centrum Wiskunde & Informatica, the Dutch national research institute for mathematics and computer science. Python was, as van Rossum later described it, "a scripting language with a syntax halfway between C and ABC."

ABC is not a footnote. It is the direct intellectual predecessor of Python — the language that van Rossum spent five years implementing, debugging, and improving before he sat down to design his own. The indentation-based syntax that defines Python's visual identity comes from ABC. The interactive workspace that makes Python's REPL feel natural comes from ABC. The high-level data structures — Python's lists, dictionaries, and sets — are direct descendants of ABC's displays, tables, and bags. Python did not emerge from nothing. It emerged from ABC.

ABC was designed at CWI Amsterdam by a team led by Lambert Meertens 🇳🇱, Leo Geurts 🇳🇱, and Steven Pemberton 🇬🇧, working through the early 1980s and releasing ABC 1.0 in 1987. CWI is the same institution where Edsger Dijkstra 🇳🇱 developed structured programming and wrote A Discipline of Programming, and where Adriaan van Wijngaarden 🇳🇱 designed ALGOL 68 and invented W-grammars. The Netherlands produced, from a single research institute in Amsterdam, two of the most consequential contributions to programming language design in the twentieth century: ALGOL and ABC (which became Python).

CWI Amsterdam and the Dutch School of Programming Language Design

The Centrum Wiskunde & Informatica was founded in 1946 as the Mathematical Centre, with Edsger Dijkstra 🇳🇱 joining in 1952 as the Netherlands' first professional programmer. It became CWI in 1983. For four decades, CWI was where Dutch computer science happened — where the ideas that shaped modern programming were worked out in detail, implemented, and published.

Lambert Meertens 🇳🇱 is one of the central figures of twentieth-century programming language theory. At CWI he worked on ABC's design from its earliest stage, contributing the core ideas about teachability and high-level data abstractions that made ABC distinctive. Alongside ABC, Meertens developed the Bird-Meertens Formalism (also called Squiggol) — a calculational approach to algorithm derivation, where programs are transformed algebraically from specifications to efficient implementations. The Bird-Meertens Formalism influenced the design of array languages, parallel computing libraries, and the theoretical foundations of functional programming. Meertens later worked at the National Institute for Standards and Technology (NIST) in the United States, but his foundational contributions to programming language design were made at CWI.

Leo Geurts 🇳🇱 led the practical implementation work on ABC, producing the interpreter that van Rossum would spend years maintaining and extending. Geurts brought engineering rigour to ABC's design — ensuring that the language's ideals of simplicity and teachability translated into a working, distributable system that researchers and students could actually use.

Steven Pemberton 🇬🇧 worked at CWI on ABC's syntax, documentation, and standardisation. He later became chair of the W3C HTML working group and led the development of XHTML — applying the same commitment to clean, well-specified syntax that he had developed while working on ABC. Pemberton was also the principal author of the ABC book (An Introduction to the ABC Programming Language, Prentice-Hall, 1987) that made the language accessible to a generation of European students.

Guido van Rossum 🇳🇱 joined CWI in 1983, shortly after completing his master's degree at the University of Amsterdam. He was assigned to work on ABC — first as an implementor contributing to the interpreter, later as a maintainer. He spent five years with ABC, learning what worked, identifying what frustrated users, and forming clear opinions about what he would do differently. When he designed Python in December 1989, he was not starting from scratch. He was building on five years of ABC.

What ABC Invented That Python Kept

ABC's most visible contribution to Python is the one every programmer encounters first: significant indentation. In most languages of the 1980s, blocks were delimited by keywords (BEGIN/END, DO/END) or braces ({}). ABC used indentation levels — the visual structure of the code was the structure of the program. When van Rossum designed Python, he kept this. Python's indentation is not an aesthetic choice imported from a formatter. It is ABC's syntax, preserved intact.

HOW TO RETURN sorted lst:
   PUT {} IN result
   FOR item IN lst:
      PUT item IN result
   RETURN result

The HOW TO keyword defines a procedure. The body is indented. The FOR loop's body is indented further. There are no braces, no BEGIN, no END. The indentation is the syntax.

Python:

def sorted_list(lst):
    result = []
    for item in lst:
        result.append(item)
    return result

The structural logic is identical. Python replaces HOW TO with def, PUT {} IN with = [], and FOR item IN with for item in, but the indentation model — the fundamental commitment that the visual nesting of code lines is the nesting of the program's structure — is ABC's.

ABC also introduced the workspace model of interactive programming. In ABC, a workspace is a persistent, interactive environment where the programmer defines procedures and works with data at a command prompt. Variables defined at the top level of a workspace persist between commands. The workspace is inspectable — you can list all defined procedures, all stored values, all active data. This is the model that Python's interactive interpreter (python3 or IPython or Jupyter notebooks) implements. The REPL — the Read-Eval-Print Loop that has become standard in modern programming — was ABC's workspace, generalised.

ABC's data structures were high-level in a way that contemporary languages were not. In 1987, most languages required the programmer to choose between arrays, linked lists, hash tables, and other low-level data structures, and to manage their memory explicitly. ABC offered:

PUT {<} IN sorted.bag
PUT {} IN display
PUT "hello" IN greeting

FOR word IN ["apple", "banana", "cherry"]:
   INSERT word IN sorted.bag

WRITE sorted.bag /

Python's list, dict, set, and str types are direct descendants of these ABC types. The conceptual architecture — that the language should provide rich, general-purpose data structures as built-ins rather than requiring the programmer to import or implement them — is ABC's.

The Python Lineage in Detail

Guido van Rossum has spoken and written extensively about ABC's influence on Python. In his essay "The History of Python" he describes ABC as "a beautiful language" that had a "profound influence" on Python, and lists specific features that Python took directly:

What Python changed from ABC:

The module system and C extensibility were the two changes that made Python usable as a systems programming language and not just a teaching language. Everything else that makes Python feel like Python traces to ABC.

ABC's Design Philosophy: Teaching by Constraint

ABC was designed explicitly as a teaching language — a language for people who needed to program but were not professional programmers. The design goals were clarity, immediate usability, and the elimination of unnecessary complexity.

This explains features that distinguish ABC from contemporary languages:

No declarations: In ABC, you do not declare variables. Writing PUT 42 IN x both creates and assigns the variable x. There is no int x = 42;, no var x = 42;, no let x = 42;. The value's type is determined by the value, not by a declaration. Python adopted this exactly.

Error messages as first-class design concerns: ABC's designers believed that beginner programmers would make errors and that the error messages they received should be helpful, not cryptic. They spent considerable effort on ABC's error messages — making them describe the problem in plain language, point to the relevant location, and suggest what the programmer might have meant. This attention to the beginner programmer's experience was unusual in 1987 and influenced Python's approach to error reporting.

Workspace persistence: ABC kept all defined procedures and variables between sessions, in a workspace file. There was no import, no source file to run — just a workspace where everything you had ever defined was always available. This lowered the barrier to interactive exploration and made it easier to build programs incrementally.

>> PUT 100 IN n
>> HOW TO RETURN factorial x:
       IF x = 0: RETURN 1
       RETURN x * factorial(x-1)
>> WRITE factorial n /
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

The >> prompt is ABC's interactive workspace. Variables defined (n) and procedures defined (factorial) persist in the workspace and are available in subsequent commands.

The ABC Interpreter on EU Infrastructure

ABC's primary implementation is the ABC interpreter, maintained and distributed through the ABC project and available on Debian/Ubuntu as the abc package:

# Install ABC interpreter on EU Linux server:
sudo apt-get install -y abc

# Run ABC interactively:
abc

# Run an ABC script:
abc script.abc

For deployment in a container on EU infrastructure:

FROM ubuntu:24.04 AS base
RUN apt-get update && apt-get install -y abc ca-certificates

WORKDIR /app
COPY *.abc ./

# ABC scripts run directly via the interpreter
CMD ["abc", "main.abc"]

A complete ABC data processing script:

HOW TO RETURN word.count text:
   PUT {} IN counts
   FOR word IN text:
      IF word in counts:
         PUT counts[word] + 1 IN counts[word]
      ELSE:
         PUT 1 IN counts[word]
   RETURN counts

HOW TO RETURN top.words counts, n:
   PUT {} IN result
   PUT 0 IN i
   FOR word IN counts:
      IF i < n:
         INSERT word IN result
         PUT i + 1 IN i
   RETURN result

PUT "the quick brown fox jumps over the lazy dog" IN text
PUT word.count text IN wc
WRITE top.words wc 5 /

EU Regulatory Angles

GDPR Art. 25 — Data Protection by Design and by Default: ABC's design philosophy — making correct use the path of least resistance — is the computational expression of Art. 25. A language designed to eliminate unnecessary complexity and make misuse difficult is a tool for writing GDPR-compliant software. ABC's workspace model, where data is managed in a named, inspectable workspace rather than scattered across modules, makes data inventories — required for GDPR compliance — natural rather than retrofitted.

GDPR Art. 5(1)(b) — Purpose Limitation: ABC's clean type system and workspace model make it straightforward to isolate data processing pipelines — each workspace handles one category of data for one purpose. The absence of global mutable state (ABC's workspace is intentionally isolated) supports purpose limitation by design.

EU AI Act Art. 13 — Transparency and Traceability: ABC's high-level data structures and readable syntax make programs inspectable. The Bird-Meertens Formalism — developed alongside ABC at CWI — provides a mathematical framework for reasoning about program correctness, which is directly relevant to the auditability requirements of AI systems under the EU AI Act.

NIS2 — Critical Infrastructure Software Resilience: The teachability principles behind ABC — that programs should be understandable, that errors should produce helpful messages, that data structures should be obvious — are principles that reduce software defects in critical infrastructure. Software written in a style influenced by ABC is more likely to be readable, maintainable, and auditable by regulators.

Dutch-EU Heritage: CWI Amsterdam operates under the Dutch government and the Netherlands Organisation for Scientific Research (NWO), both EU-funded bodies. The work that produced ABC — and through ABC, Python — was publicly funded European science. Lambert Meertens 🇳🇱, Leo Geurts 🇳🇱, Guido van Rossum 🇳🇱, and Edsger Dijkstra 🇳🇱 represent a single Dutch institution's contribution to global programming, funded by European public research investment and freely given to the world.

Deploy ABC on sota.io

sota.io's container-based deployment model supports any language that runs on Linux. An ABC application deployed on sota.io runs on EU infrastructure (Hetzner, Germany or Scaleway, France) with managed PostgreSQL and GDPR-compliant data processing:

sota deploy --region eu-west

The platform provisions EU infrastructure, injects managed PostgreSQL credentials as environment variables, configures TLS termination, and assigns a .sota.io subdomain. All data stays within the European Economic Area.

FROM ubuntu:24.04
RUN apt-get update && apt-get install -y abc ca-certificates libpq-dev

WORKDIR /app
COPY *.abc ./
EXPOSE 8080

# ABC scripts can call C extensions via ABC's foreign function interface
# for database access and HTTP handling
CMD ["abc", "server.abc"]

For ABC applications that require database access, the standard approach is to use ABC's C extension mechanism to call libpq directly, or to use a lightweight HTTP + PostgreSQL wrapper written in ABC's C extension interface.

The language that Lambert Meertens 🇳🇱 and Leo Geurts 🇳🇱 designed at CWI Amsterdam — that Guido van Rossum 🇳🇱 implemented and improved, and that he then transformed into Python — is still distributable, still interpretable, and still the clearest statement of what a programming language owes to the people who will use it: clarity, immediacy, and the elimination of every obstacle that stands between an idea and its expression in code. Python carries that debt forward, in every indented block and every interactive prompt, to this day.

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 ABC application to EU servers in minutes at sota.io.