ABC

ABC is an interactive programming language and environment developed at CWI (Centrum Wiskunde & Informatica) in Amsterdam by Leo Geurts, Lambert Meertens and Steven Pemberton. It was designed as a structured, high-level replacement for BASIC. ABC offered just five powerful data types, no variable declarations, unlimited-precision arithmetic, block structure by indentation, and a programming environment where your procedures and variables simply persisted between sessions. It was meant for teaching and for everyday personal programming, the kind of work people then did in BASIC, Pascal or AWK. It was not meant for systems programming.

ABC never found the audience its designers hoped for, but its ideas did. Guido van Rossum spent several years on the ABC team at CWI before creating Python there. Much of what makes Python easy to read and learn can be traced back to this language.

History & Origins

Teaching artists to program

ABC’s roots go back to programming workshops that Geurts and Meertens, both then at the Mathematical Centre (MC) in Amsterdam, ran for artists, composers and architects through the Computer Arts Society around 1970. They taught in TELCOMP, an unstructured BASIC-like “conversational” language. It was easy to learn, but even small projects quickly turned into spaghetti code. ALGOL 60 was far better structured but had not been designed for interactive use. In Meertens’s words, the question became: “Why is there no language that combines the best of two worlds: the power and simple elegance of ALGOL 60 with the modest size and suitability for conversational use of BASIC and TELCOMP?”

B: a language designed in iterations

In 1975 the two started a project to design such a language. Meertens had watched ALGOL 68’s design and revision up close and saw obvious improvements rejected for arriving “too late”, so they planned for several design iterations from the start. They also refused to name the language before they were satisfied with it. As a placeholder they used B, in italics, as if it were an uninitialised variable holding the name. B was the first letter of “beginner”.

Pemberton’s 1987 IEEE Software article summarises the iterations:

Two ideas from those early years survived every revision. The first was multiple assignment in one command (PUT a, b IN b, a swaps two variables). The second was mandatory indentation. The designers took that idea from P. J. Plauger’s 1975 paper “Signal and Noise in Programming Languages”, which suggested letting the compiler “read the same signal as we human beings, and let the indenting control grouping.”

The biggest change came from New York. During a stay at NYU, Meertens had worked with Jack Schwartz’s SETL, and Dewar persuaded him that B₁’s integer-only array indices meant “designing for the past, not the future”. The type system was redesigned on ease-of-learning and ease-of-use grounds alone, and the result came out remarkably close to SETL’s. Meertens used a program written in SETL to shortlist the candidate type systems. That type system became B₂’s and never changed again.

From pilot to product

Meertens wrote a throwaway pilot implementation in 1981, a one-person job of about two months. It was slow but usable, and it let the team gather feedback from teaching. While Meertens spent a year at NYU, the MC brought in Steven Pemberton to lead a serious implementation effort. Van Rossum joined the team on 1 November 1982, straight out of university. According to Pemberton, the team then built a production system in about a year with four people, by modularising the pilot and replacing it module by module so that a working system existed at all times.

The name problem was settled in 1985. A contest in the B Newsletter produced suggestions such as “Bravo”, “Best”, “QUI” (sounds like CWI) and “Lingo”. The team rejected “Lingo” to avoid another name clash. In the end Meertens announced, “counting noses (including those of our own), we decided on ‘ABC’”, and dubbed the change PUT "ABC" IN B. Van Rossum later recalled that none of the public submissions made the cut and “the internal back up candidate prevailed.”

In January 1987, Pemberton’s IEEE Software article introduced ABC to a wider audience. It reported that a portable Unix implementation had been distributed to several dozen sites and that an MS-DOS version was available. The book-length language description followed as The ABC Programmer’s Handbook (Prentice-Hall; the book and CWI’s own pages date it 1990, while an ABC newsletter gives 1989). In December 1990, CWI posted the Unix sources to comp.sources.unix in 25 parts. Versions for the Atari ST, Macintosh and MS-DOS went to the matching binaries newsgroups the same week.

Design Philosophy

ABC’s designers did not start with a fixed philosophy. Meertens says it grew out of patterns in their decisions, which they then wrote down as design rules:

• Uniformity Rule: similar things should be said in similar ways.
• Fair-Expectation Rule: if a user could fairly expect a construct to be valid and mean something, based on similar constructs, then it is valid and means that.
• Economy-of-Tools Rule: different tools should do genuinely different jobs, and tools that overlap should be unified.
• Logic-Error Rule: Meertens does not spell it out in his essay, but he says Python’s “Errors should never pass silently” and “In the face of ambiguity, refuse the temptation to guess” correspond to it.

Behind the rules sat two convictions spelled out in the Handbook’s preface: “simple to use” is not the same as “simple to implement”, and as computers grow more powerful, programmer time matters more than computer time. ABC deliberately gave up machine efficiency to give beginners powerful, restriction-free tools. Pemberton noted in 1987 that the implementations needed at least 128K of memory on Unix and 256K on MS-DOS, which some people found surprisingly large at the time.

Meertens later pointed out how these rules resurfaced in Tim Peters’s “Zen of Python”. “Errors should never pass silently” echoes the Logic-Error Rule, “Special cases aren’t special enough to break the rules” the Fair-Expectation Rule, and “There should be one – and preferably only one – obvious way to do it” the Economy-of-Tools Rule.

Key Features

Five data types

The Handbook contrasts ABC’s five data types with 13 in Pascal and 19 in C. The five are numbers (exact and approximate), texts, compounds, lists and tables. Compounds are records without field names. Lists are sorted collections of items of one type (bags or multisets). Tables are generalised arrays mapping keys of one type to items of one type, and they are kept sorted by key. Together they cover what other languages build by hand as sets, dictionaries, records and trees. There are no size limits apart from available memory:

>>> WRITE 2**1000
10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376

Exact arithmetic is part of the language definition, not an implementation detail. Meertens’s example (10**999 + 1) - 10**999 gives exactly 1.

No declarations, but still type-safe

ABC variables are never declared, yet the language is strongly typed. Meertens’s POPL 1983 paper “Incremental Polymorphic Type-Checking in B” describes how the system infers types and catches type errors that declarations would otherwise catch. Commands and functions are polymorphic, so one sorting routine works on numbers or texts.

Indentation, keywords and HOW TOs

Blocks are marked by a colon and indentation. Keywords are upper case, and user-defined commands, functions and predicates are all introduced with HOW TO. The CWI introduction’s classic example collects the set of words in a document:

HOW TO RETURN words document:
   PUT {} IN collection
   FOR line IN document:
      FOR word IN split line:
         IF word not.in collection:
            INSERT word IN collection
   RETURN collection

Meertens compared a bubble sort in ABC with its Python equivalent. The family resemblance is obvious:

FOR i IN {1..#a-1}:
   FOR j IN {1..#a-1}:
      IF a[j] > a[j+1]:
         PUT a[j+1], a[j] IN a[j], a[j+1]

1
2
3
4

for i in range(len(a)-1):
    for j in range(len(a)-1):
        if a[j] > a[j+1]:
            a[j], a[j+1] = a[j+1], a[j]

Refinements for top-down programming

ABC has no GO TO. Instead it supports refinements: named sub-parts of a command or function, written below the main body, that let you write a program top-down in something close to executable pseudo-code. This example from ABC Newsletter 8 (1995) defines which, leap and day.in.year as refinements of today:

HOW TO RETURN today:
   PUT now IN (year, month, day, hour, minute, second)
   RETURN day.name[which]^"day"
which:
   RETURN (day.in.year - dominic) mod 7
leap:
   IF (year mod 4 = 0 AND year mod 100 <> 0) OR year mod 400 = 0:
      RETURN 1
   RETURN 0

(The original goes on to define dominic, day.in.year and day.name the same way.)

Program size

The designers claimed ABC programs are typically a quarter to a fifth the size of equivalent Pascal or C. That figure comes from their own rewrites, not a controlled study. Pemberton’s 1987 examples were a 1,000-line Pascal program that became 200 lines of ABC, a 110-line Pascal cross-reference program that became 24 lines, and a 284-line Pascal program from the November 1984 issue of Byte whose ABC equivalent was also 24 lines.

An environment, not just a language

ABC was always used inside its own integrated environment:

• No files: commands, functions and global variables stay in a workspace after you log out, and you can keep several workspaces.
• A structure editor: the editor understands ABC syntax and suggests completions as you type. It lets you edit structurally or as plain text without switching modes. Meertens, Pemberton and van Rossum described it in CWI report CS-R9256 (1992).
• One consistent interface for running commands, editing, and typing input to a running program, plus a general undo.

The same closed world was ABC’s biggest limitation. Programs could not easily reach the file system or the operating system, and the monolithic implementation was hard to extend.

Evolution

After the formal release, development slowed. Releases in the 1.0x series appeared on Unix, MS-DOS, Macintosh and Atari ST, and programs and workspaces could move between the four without changes. Unix patches followed on Usenet into January 1991, and a user letter in Newsletter 8 quotes “ABC Release 1.01.07”. By August 1995 the newsletter reported that ABC was no longer a funded research group. Plans for a windowing version, graphics and system extensions were left waiting for spare time. A later test version added workspace pack/unpack archives (-p and -u flags) and a shared central workspace. The 32-bit Unix source tree that van Rossum put on GitHub in 2025 identifies itself as release 1.05.03 (“central workspace”).

The 32-bit sources assumed integers and pointers were the same size, which kept ABC off modern 64-bit systems for years. In 2026 that finally changed. Students at Delft University of Technology (Alexandra Gâlmeanu, Bauke Limburg, Boldi Koller, Malou van Elburg and Mateusz Gilowski) updated the sources, and CWI released ABC version 1.06.00 with 64-bit builds for Linux (Intel and Arm), Arm Macs, Raspberry Pi, Chromebook and Windows (Cygwin-based), plus portable sources. The older 32-bit implementations remain available.

Current Relevance

ABC is a historical language with a small afterlife. Steven Pemberton still maintains its CWI home page, which offers the full Programmer’s Handbook online, a quick reference, program examples, notes on Unicode, and an ixml grammar of the syntax. The 2026 64-bit release means ABC runs natively on current hardware again. Van Rossum’s GitHub copy of the original sources has also renewed interest among Python programmers curious about where their language came from.

No official or widely used Docker image exists for ABC. The practical way to try it is to download a CWI binary for your platform or build the sources.

Why It Matters

ABC is a textbook case of a language that failed in its own niche and still changed programming. Its designers blamed their limited reach partly on circumstance. Distribution was mostly by floppy disk to “a few hundred people”. CWI’s directors refused to advertise in Dr. Dobb’s Journal and insisted on a copyright banner on the startup screen that discouraged copying. And Dutch schools taught office software rather than programming.

Its influence on Python is documented by both sides. Van Rossum’s own account in the Python FAQ says ABC was “the origin of many Python features, including the use of indentation for statement grouping and the inclusion of very-high-level data types”. The FAQ also credits ABC’s usability experiments for the colon before an indented block. In his 2009 History of Python blog he wrote that he set out to “borrow everything I liked from ABC while at the same time fixing all its problems”, above all ABC’s lack of extensibility and its isolation from the operating system. Meertens concluded that “Python now occupies the niche for which ABC was designed.”

ABC’s lasting contribution, then, is a way of designing languages: iterate before you freeze the design, write down consistency rules and follow them, put programmer time ahead of machine time, and choose a few powerful, general data types over many special-purpose ones. Through Python, those principles now reach millions of programmers.