Winterthur, Switzerland, February 15 1934.


Bachelor’s degree in Electronics Engineering (Swiss Federal Institute of Technology Zürich—ETH Zürich, 1959); M.Sc. (Université Laval, Canada, 1960); Ph.D. in Electrical Engineering and Computer Science (EECS) (University of California, Berkeley, 1963).


Assistant Professor of Computer Science (Stanford University, 1963—1967); Assistant Professor (University of Zurich, 1967—1968). Professor of Informatics (ETH Zürich, 1968—1999) (one-year sabbaticals at Xerox PARC 1976–1977 and 1984–1985).


ACM Turing Award (1984); IEEE Computer Society, Computer Pioneer Award (1988); IBM Europe Science and Technology Prize 1988 (1989); Member, Swiss Academy of Engineering (1992); Foreign Associate, US Academy of Engineering (1994); Orden Pour le merite (1996); ACM SIGSOFT, Outstanding Research Award in Software Engineering (1999); Leonardo da Vinci Medal, Societe Europeenne pour la Formation des Ingenieurs (1999); Eduard-Rhein Technology-Prize, München (2002); Fellow of the Computer History Museum (2004). Ten honorary doctorates (  University of York, England, 1978;  Ecole Polytechnique Federale, Lausanne, Switzerland, 1978; Université Laval, Quebec, Canada, 1987;  Johannes Kepler Universitaet Linz, Austria, 1993; University of Novosibirsk, Russia, 1996; The Open University, England, 1997; University of Pretoria, South Africa, 1998; Masaryk University, Brno, Czech Republic, 1999;  Saint Petersburg State University of Information Technologies, Mechanics and Optics, Russia, 2005; State University of Ekaterinburg, Russia, 2005).

Niklaus E. Wirth

Switzerland – 1984

For developing a sequence of innovative computer languages, EULER, ALGOL-W, MODULA and PASCAL. PASCAL has become pedagogically significant and has provided a foundation for future computer language, systems, and architectural research.

Niklaus Wirth grew up in Switzerland, and he spent most of his professional life at the Swiss Federal Institute of Technology (ETH) in Zürich. After earning his first degree there in 1959, he left for graduate study in North America and earned his Ph.D. in 1963 from the University of California, Berkeley. After a stint on the Stanford faculty, he returned to ETH in 1968. He was a driving force behind the creation in 1981 of what quickly became one of the world’s leading computer science departments, serving as its head for much of the 1980s. Wirth retired in 1999, but remained a frequent presence on its beautiful hilltop campus.

Wirth began his rise to prominence in computer science by creating two languages: Euler (based on his dissertation work), and the systems programming language PL360 (for the IBM System/360 series of computers). This early work broke new ground in formal separation of syntax and semantics, in novel implementation techniques, and in careful language design for efficient implementation with specific parsing methods.

Both languages were heavily influenced by Algol. Wirth was part of the elite international group centered on the Algol project, which collaborated to define and implement a series of language standards. The first high level languages, such as FORTRAN, were popular because they made it much easier to write and maintain application programs. But they were hard for computer companies to implement because the hardware was so limited, compiler techniques were poorly understood, and the languages themselves were clumsy or overly complex. Algol 60, the most important creation of the Algol group, introduced recursive functions, structured code blocks, and local variables. It also pioneered the formal description of programming language syntax.

Starting in 1957, when academic departments and regular conferences for computer scientists did not yet exist, the Algol project laid a vital foundation for the emerging discipline. Through Algol, Wirth collaborated with other future Turing Award winners including C.A.R. (Tony) HoareEdsger Dijkstra, and Peter Naur. Like Wirth, all had joined the group after showing early promise as designers of compilers and other systems software, production of which was the major practical challenge facing computer scientists during this era.

In 1966 the Algol group voted against a proposal by Wirth to make its next language an extension and improvement of Algol 60 influenced by his own language EULER. Instead, it chose for the Algol 68 proposal a rival design of great complexity, full of novel and hard-to-implement features. Wirth resigned from the group in 1968. He worked instead with Tony Hoare to turn the rejected proposal into a new unofficial Algol version, Algol-W [1].

Wirth used Algol-W as the basis for what would prove his most influential creation, the language Pascal. Following his personal aesthetic, Pascal was simple, flexible and designed for rapid compilation into efficient code. It retained Algol’s code structures, logical completeness, and support for recursion, but stripped away some of its complexity and added support for complex and user-defined data types. Wirth later wrote that the “single most important guideline” was “to include features that were well understood, in particular by implementors, and to leave out those that were still untried and unimplemented.” [10]

Pascal was adopted in 1971 for teaching at ETH, and it spread rapidly to other universities. To help implement Pascal on computers of all kinds, Wirth created a new kind of compiler which was written for, and generated code to run on, a virtual machine. Simulating this virtual machine on a new computer made it easy to port his compiler. Pascal’s great leap into mainstream use came a few years later, with the spread of personal computers. The simplicity and efficiency of Pascal made it a natural fit to their limited memory and disk space. Borland’s cheap and fast Turbo Pascal compiler cemented Pascal’s position as the leading high level computer language of the 1980s for serious personal computer software development.

During the 1970s Wirth shared the interest of other veterans of the Algol project, such as Edsger Dijksta and Tony Hoare, in programming methodologies and formal methods. He participated in the IFIP Working Group on Programming Methodology, proposing the idea of stepwise refinement of code as a complement to the various visions of “structured programming” they put forward. His books Systematic Programming [3] and Algorithms + Data Structures = Programs [5] are among the most influential contributions to the literature on programming methods and concepts.

Unlike many of his colleagues, Wirth remained a generalized hands-on system builder. He struggled, with remarkable success, against narrow niches for academic work, and the resulting separation of language design, operating systems, hardware, graphics, and networking into distinct specializations.

During the 1950s and early 1960s, many influential software systems had been created by small academic or industrial groups dealing with practical problems. But by the 1970s and 1980s, the scale of industrial software development increased, and computer science in universities and corporate labs focused more on theory and basic research. It was increasingly unusual for a top computer scientist, particularly within a university, to attempt to create entire production quality systems as Wirth did.

In 1976, influenced by his exposure to the new workstation technology he used while on a sabbatical leave at Xerox’s Palo Alto Research Center (PARC), he led a project at ETH to build a new graphical workstation. Named Lilith, it was a complete computing environment, with an operating system (Medos), high speed local area networking, applications such as text and graphics editors, and laser printers. Its new programming language, Modula- 2, extended Pascal with support for concurrency and greater modularity of code. The first Lilith systems were working by 1980, making these capabilities standard at ETH (and several other universities) years before they were matched by commercial products.

A few years later he repeated the trick, leading development of the Ceres workstation, its operating system, and the new object-oriented Oberon programming language and operating system. These were used, in several revisions, at ETH from the mid-1980s well into the 1990s. Modula-2 and Oberon were transferred to commercial machines and were used for computer science teaching applications, though neither had the widespread impact of Pascal. Oberon was implemented for quite different machines, achieving the kind of program portability later made famous by Java.

Wirth’s involvement in hardware design deepened during the 1980s. Computer scientists know that hardware and software design are similarly challenging, but most tend to focus on one or the other. Wirth did both. He seized on the new Field Programmable Gate Array (FPGA), a special chip that can be reprogrammed for a particular application, and developed languages and tools to configure them efficiently from a high level specification.

Decades after pioneering computer science groups at MIT and the Universities of Cambridge and Manchester stopped building their own computers and operating systems, Wirth made ETH a place where computer science students and faculty used internally produced hardware, operating systems, and programming tools. He believed that students should read and understand the code of real systems before trying to write their own. He had a life-long drive for simple, elegant, and efficient systems as part of a broader commitment to the integration of theory and practice.

As Wirth put it in his 1984 Turing Award lecture [9], one must “distinguish early between what is essential and what ephemeral” and ensure that “the ephemeral never impinge on the systematic, structured design of the central facilities.” He observed that:

…every single project was primarily a learning experiment. One learns best by inventing. Only by actually doing a development project can I gain enough familiarity with the intrinsic difficulties and enough confidence that the inherent details can be mastered.

The effectiveness of his systems, and his ability to build complex systems with small teams, relied on his constant search for elegant simplicity—for what could be left out. Over time his language designs and compiler techniques became, in some respects, simpler and more efficient rather than, as is almost universal, slower and more complex. In 1995 he warned that “The plague of software explosion is not a ‘law of nature.’ It is avoidable, and it is the software engineer's task to curtail it.”

Author: Thomas Haigh