Niklaus Wirth and Pascal

Zusammenfassung

Niklaus Wirth spent forty years designing programming languages and arguing that software was getting worse as hardware got faster. His language Pascal (1970) taught structured programming to a generation of computer science students; his book Algorithms + Data Structures = Programs gave the discipline a compact statement of its core subject. He articulated what became known as Wirth’s Law — that software bloat outpaces hardware improvement — long before it became a universal complaint. His later languages, Modula and Oberon, were more elegant than Pascal and less successful commercially, which he considered evidence that the market’s values and computer science’s values had diverged.

From Physics to Programming Language Design

Niklaus Emil Wirth was born in Winterthur, Switzerland, on February 15, 1934. He studied electronics engineering at ETH Zürich, completed a master’s degree at Laval University in Quebec, and received his PhD from UC Berkeley in 1963, working under Harry Huskey on a programming language called Euler.

After positions at Stanford, he returned to ETH Zürich in 1967, where he would spend most of his career. He had already participated in the design of ALGOL W, a cleaned-up variant of ALGOL 60, and had developed strong opinions about what made programming languages teachable, implementable, and verifiable.

Pascal: Structured Programming Made Concrete

In 1970, Wirth published the description of Pascal — a language designed explicitly for teaching structured programming. The design goals were simple and stated clearly: Pascal should enforce good structure by making it easy to write well-organized programs and difficult to write badly organized ones. It should be implementable efficiently with a one-pass compiler. It should be small enough that students could learn all of it.

Pascal embodied Dijkstra’s structured programming principles in concrete syntax:

No GOTO (or a highly restricted one)
Clear block structure with begin...end delimiters
Strong static typing with a simple, consistent type system
Procedure and function definitions with local scope
Records, sets, arrays, and enumerated types as first-class language features

{ Pascal example — structured, typed, explicit }
program Factorial;
var
    n, result: integer;

function Fact(x: integer): integer;
begin
    if x <= 1 then
        Fact := 1
    else
        Fact := x * Fact(x - 1)
end;

begin
    read(n);
    result := Fact(n);
    writeln(result)
end.

Pascal spread rapidly through computer science education in the 1970s and 1980s. It was the primary teaching language at most universities for over a decade. Its influence on students who went on to design other languages — including Modula, Ada, Delphi, and in some respects C# — is substantial.

UCSD Pascal (1977), a portable Pascal implementation using a virtual machine (the p-machine), ran on Apple II, CP/M, and early microcomputers and brought Pascal to a wider audience. Turbo Pascal (Borland, 1983) sold for $49.95 — radically cheap at the time — and gave a generation of personal computer programmers their first taste of a compiled language with a fast development cycle.

Algorithms + Data Structures = Programs

In 1976, Wirth published “Algorithms + Data Structures = Programs” — a textbook that stated a thesis in its title: programming is the selection and combination of appropriate algorithms and data structures. The book used Pascal to implement and analyze sorting algorithms, data structures (linked lists, trees, hash tables), and language processing. It became a standard reference in computer science curricula and articulated an approach to programming as a rigorous, teachable discipline.

The book also demonstrated Wirth’s pedagogical approach: programs as mathematical objects, clarity over cleverness, simplicity over premature optimization.

Modula-2 and Oberon: The Language Trilogy

Wirth was dissatisfied with Pascal’s limitations for systems programming: it lacked modules (a mechanism for partitioning large programs into independent components), separate compilation, and facilities for low-level hardware access. In 1978, he published Modula-2, which added:

Modules with explicit import/export interfaces — a clean model for encapsulating implementation details
Coroutines for concurrent programming
Low-level facilities for memory and device access

Modula-2 influenced Ada (the US Department of Defense’s systems programming language, 1983) and was used in several research systems.

In 1987, working on the Ceres workstation at ETH (the successor to his earlier Modula-2 machine, the Lilith), Wirth published Oberon — a further simplification. Oberon removed features he considered unnecessary (variant records, with statements, enumerated types) and added a simple but powerful object extension mechanism. The Oberon system (with Jürg Gutknecht) was a complete operating system written in Oberon, demonstrating that a minimal language was sufficient for production systems software.

Wirth’s Law

In a 1995 paper, Wirth articulated what became known as Wirth’s Law (also attributed independently to Martin Reiser): software is getting slower more rapidly than hardware becomes faster.

The observation was empirical but pointed to something structural. Each generation of hardware improvements gave programmers more resources to work with; each generation of software used those resources to add layers of abstraction, frameworks, and features rather than to do the same thing faster. The net result was that applications felt roughly as responsive in 1995 as they had in 1975, despite hardware that was several orders of magnitude faster.

The Opposite of Moore’s Law

Andy Grove quipped: “Andy gives, Bill takes away” — referring to Intel’s hardware improvements being consumed by Windows bloat. Wirth’s formulation was more analytical: the economics of software development rewarded richness of features over efficiency of execution, because users evaluated software by what it could do, not by how efficiently it did it. Only when resources were genuinely constrained — embedded systems, mobile devices, high-frequency trading — did efficiency become a competitive priority.

Wirth died on January 1, 2024, in Felsberg, Switzerland, at eighty-nine — the last of the great language designers who had built the foundations of structured programming.

Dead End: Oberon as a Universal System

Wirth’s vision for Oberon was ambitious: not merely a language but a complete operating system environment that demonstrated that a single, small, consistently designed system could do everything users needed. The Oberon system was clean, fast, and intellectually consistent — and it found essentially no market.

The problem was that Oberon arrived into a market dominated by Unix and Windows, both of which had enormous installed bases of applications and programmers. A better-designed system with no existing software could not compete with a worse-designed system with all the software users needed. This is a recurring pattern in computing history — technical superiority does not transfer users — and Wirth understood it without accepting it.

The Lesson Wirth Wouldn’t Accept

Wirth continued developing Oberon variants through the 1990s and 2000s, producing Oberon-2, Component Pascal, and Zonnon. Each was technically refined. None broke out of academic computing. The contrast between Pascal’s commercial success (achieved largely by Borland, not by Wirth) and Oberon’s academic niche illustrates that language adoption is driven by ecosystem, tooling, and first-mover advantage as much as by design quality.

The structured programming movement that Pascal embodied is explored further in Edsger Dijkstra and Structured Programming. The full arc of programming language development is traced in The Evolution of Language.