feature article
Subscribe Now

Niklaus Wirth: Computer Language Pioneer and Educator, 1934-2024

Niklaus Wirth, a potent force in the development of programming languages since the 1960s, passed away on January 1. The programming languages that Wirth either developed or influenced include Euler (the language he developed for his PhD thesis), Algol, Pascal, Modula, and Oberon. He became a professor, helped to develop and then headed the computer science department, and taught computer science at the Swiss Federal Institute of Technology (ETH) in Zurich from 1968 through his retirement in 1999. Along the way, Wirth also led teams that developed hardware, including the Lilith and Ceres graphical workstations, and created one of the earliest university courses in FPGA application development. He created a hardware description language called Lola for use with FPGAs as part of the FPGA course development.

Algol was and is a second-generation high-level software programming language. The first-generation languages developed in the 1950s, including FORTRAN and MATH-MATIC, attempted to abstract the underlying computer hardware so that programmers could deal with just the algorithms and data structures needed to solve computational problems. IBM became a strong advocate for FORTRAN, while Remington-Rand preferred MATH-MATIC. However, these first-generation programming languages weren’t universal and early computer scientists had a field day creating new programming languages for nearly every new computer architecture.

In the late 1950s, the Association for Computing Machinery (ACM) president, under petition, organized an ad hoc committee to develop a universal programming language that could be adapted to any computer architecture. The committee rejected FORTRAN and MATH-MATIC because, at the time, they were considered proprietary languages, as they were heavily endorsed and supported by IBM and Remington-Rand respectively. The ad hoc committee met in Zurich during 1958 and defined a new programming language, dubbed the International Algebraic Language (IAL). The language definition stuck but the name did not and IAL became Algol in 1959. The specification produced by the ad hoc committee became Algol-58 and was quickly followed by a revised and improved specification known as Algol-60. A growing list of perceived shortcomings in the definition of Algol-58 and Algol-60 prompted continuing development of the language.

Meanwhile, Niklaus Wirth was on the road to becoming a computer scientist. He earned a BSEE from ETH Zurich in 1959, followed by a Master of Science degree from Quebec’s Université Laval in 1960. Then, in 1963, he earned a PhD in EECS from the University of California, Berkeley. For his PhD thesis, Wirth, under the supervision of Stanford University’s Helmut Weber, developed a simplified version of Algol called Euler. Wirth wrote that Euler was an attempt “to generalize and extend some of the concepts of ALGOL thus creating a language which is simpler yet more flexible than ALGOL-60.”

After earning his PhD, Wirth joined the newly formed Computer Science Department at Stanford, and, based on his Euler experience, he became involved in the International Federation for Information Processing’s (IFIP’s) ongoing development of the Algol programming language. Wirth proposed Euler as a successor to Algol-60 in 1965. Two other proposals were submitted the same year. IFIP did not choose Wirth’s proposal. Apparently, the IFIP committee wasn’t looking for a simpler and more flexible language. Instead, it chose a proposal from Dutch mathematician and computer scientist Adriaan van Wijngaarden.

The accepted language definition was far more complex than Algol-60, and, in 1970, it was adopted and became known as Algol-68. Meanwhile, Wirth implemented Euler on IBM 360 computers, and it became known as Algol-W. Several universities with IBM 360 computers successfully used Wirth’s Algol-W to teach software programming. (On a side note, I started my freshman year at Case Western Reserve University in 1971 and Algol-68 was already being taught by the university’s Computer Science Department just a year after its publication. Case had a long association with Algol. I wish Wirth’s proposal had been accepted so that I wouldn’t have wasted two years trying to learn Algol-68 as a first programming language under the stern eye of Professor Frederick Way III. I can personally attest to the opacity and baroque nature of Algol-68, and I consider it to be far too complex to be used as an introductory programming language. I’m just a BASIC kind of guy.)

After parting ways with the IFIP Algol effort, Wirth joined ETH Zurich as a professor and continued to develop Algol-W. It evolved into Wirth’s next programming language, which he named Pascal, aiming it at university students who were fledgling programmers. The first Pascal compiler became operational in 1970 and ran on one of ETH Zurich’s CDC 6000 series computers.

ETH Zurich used Wirth’s Pascal language to teach software programming beginning in 1971, and Pascal soon became one of the leading teaching languages for computer science students at the university level around the world. The language later broke out of the university setting when Phillippe Kahn’s Borland International introduced the Turbo Pascal compiler, first for CP/M machines based on the Intel 8080 and Zilog Z80 microprocessors, and then for the IBM PC. UCSD’s Pascal compiler and operating environment became one of the three operating systems IBM originally sold with its PC, along with Digital Research’s CP/M-86 and Microsoft’s MSDOS. The UCSD Pascal system used pseudo code or “p-code,” which Wirth had developed in 1975 for his Pascal-S compiler. Wirth didn’t create the p-code concept, but he did popularize it with Pascal. Today, the p-code concept is still used for implementing programming languages such as Python and Java.

Next, Wirth tackled the challenge of developing a programming language for concurrent processing, because multi-processor systems were beginning to appear. Wirth started an investigation in 1973 that developed the basic concepts for programming concurrent processing systems. The project produced a set of guidelines for creating language constructs that generate and synchronize concurrent computing activities. Wirth also developed a concurrent programming language called Modula, which was first implemented on interconnected Digital Equipment Corporation PDP-11 minicomputers.

While on sabbatical to the Xerox Palo Alto Research Center (PARC) during 1976 and 1977, Wirth was exposed to the Alto workstation with its groundbreaking graphical user interface and Ethernet network. He quickly became an advocate for personal workstations and, by the fall of 1977, had decided to build a similar workstation at ETH Zurich, because Xerox wouldn’t allow him to take an Alto workstation back to Switzerland after his sabbatical ended. The resulting project produced the Lilith graphical personal workstation based on a processor built from AMD 2901 bit-slice ICs that executed between 1 and 2 million instructions per second.


Lilith workstation. Image credit: ETH Zurich

The Lilith workstation’s operating system, graphical user interface, and system software, including a relational database, text editor, and graphical line drawing editor were all written in Modula-2, which Wirth created for the Lilith workstation by adapting and simplifying his Pascal programming language and adding Modula’s concurrent programming constructs. The resulting structured procedural programming language subsequently saw some commercial success with embedded software development for microprocessors, including the satellite based GLONASS global navigation system. On a side note, Lilith’s custom designed mouse (shown in the above image) inspired Logitech’s first commercial mouse, the P4. Logitech was founded in Switzerland in 1981.

Shortly after becoming a professor at ETH Zurich, Wirth, along with colleague Professor Carl August Zehnder, proposed creating a Computer Science Department at the university. Their proposal finally succeeded after only eleven years. The department was founded in 1981, and Wirth headed the department from 1982 to 1984 and again from 1988 to 1990.

After spending a second sabbatical at Xerox PARC during 1984 and 1985, Wirth again returned to ETH Zurich and developed the Ceres personal workstation, based on National Semiconductor’s NS16032 microprocessor (later and confusingly renamed the 32016). As he’d done in the past, Wirth adapted his existing Modula-2 language to the needs of this new workstation, producing the Oberon programming language. ETH Zurich built three generations of Ceres workstations based on multiple generations of National Semiconductor’s Series 32000 microprocessor family.

While he’s best known for creating several influential programming languages, as listed above, Wirth always stayed closely attuned to the underlying computer hardware. He innately understood the need for a close marriage between a computer’s hardware and software. Consequently, Wirth became an early FPGA advocate and educator. By 1990, he’d initiated FPGA research at ETH Zurich. He equipped 25 third-generation Ceres-3 workstations in a student laboratory with FPGA development capabilities, which were used intensively in digital design classes.

True to form, Wirth formulated a hardware description language (HDL) called Lola for these classes. Lola was specifically designed for teaching digital hardware design to university students. Similar to Euler’s simplification of Algol, Lola was a simplified version of commercial HDLs, and the language dispensed with much of the ephemera in existing HDLs. The Lola tool set consisted of an editor, a compiler, and a checker. Lola’s compiler converted Lola HDL code for use with existing Verilog compilers, which did the actual logic compilation. For teaching purposes, Lola was made specific to the SRAM-based Atmel AT6000 FPGA, which had 1024 to 6400 logic cells. (Atmel entered the FPGA market after acquiring Concurrent Logic in 1991, and the Atmel AT6000 FPGA started life as the Concurrent Logic Cli6000 FPGA. Microchip now owns Atmel.)

Throughout his long career, various organizations recognized Wirth’s many contributions with awards. Three of the most prestigious of these awards include the ACM’s Turing Award in 1984, the IEEE Computer Society’s Computer Pioneer Award in 1988, and his election as a Computer History Museum Fellow in 2004. Many of Wirth’s artifacts and lecture recordings reside in the collection at the Computer History Museum in Mountain View, California. Unfortunately, there seems to be no online access to these materials. However, Wirth published several books that are still in use, including “Algorithms + Data Structures = Programs,” “Algorithms and Data Structures,” “Compiler Construction,” “Systematic Programming: An Introduction,” “Digital Circuit Design for Computer Science Students: An Introductory Textbook,” “PASCAL User Manual and Report,” “Programming in Modula-2,” and “Programming in Oberon: Steps Beyond PASCAL and Modula.”


EULER: A Generalization of Algol, and its Formal Definition, Niklaus Wirth and Helmut Weber, Technical Report CS20, April 27, 1965, Computer Science Department, School of Humanities and Sciences, Stanford University

Summary of projects by N. Wirth, 1962 – 1999

History of Programming Languages, Richard L Wexelblat, Academic Press, 1981

9 thoughts on “Niklaus Wirth: Computer Language Pioneer and Educator, 1934-2024”

  1. Thank you for sharing this Steve — I find the history behind hardware and software to be fascinating — I used FORTRAN and BASIC at university — Pascal was the first high-level language I learned when I got out of university in 1980 — I loved it!

  2. Thanks Max. I’m glad you liked the article. Basic is the first language that won me over. Then I switched to HPL, a proprietary language for HP’s 9825 desktop computer. I contributed to that language in a small way. It was the first and only software product I developed as an engineer.

  3. The first computer languages I learned were punched-card FORTRAN in college in 1967, and Dartmouth BASIC in graduate school at Dartmouth College in 1971-1973. Dartmouth BASIC was incompatible with later microprocessor BASICs, as Dartmouth BASIC was a compiler running on a mainframe computer with hard-disk drives, while microprocessor BASICs were interpreters running on diskless microcomputers.

    When UCSD Pascal was new in the 1970s, I wore a kilt to a university lecture about Pascal enumerated types. The lecturers used colors of kilts as his enumeration example. As an embedded-systems programmer, I remember being disappointed that UCSD Pascal had only primitive input/output capabilities.

    My later work was in assembly language, Ada, VHDL, and C.

  4. Great article! I started with CDP1802 machine code as my “learning” language. Then added Basic, Pascal and C after I gained access to more than a single board CPU. Pascal was my favorite of the bunch. I do remember also being disappointed in Pascal’s I/O.

    1. Thanks duanebenson. As a teaching language, I suspect I/O was low on the list of critical features for Pascal. I’m an I/O guy from day one as an engineer, so I have a deep appreciation for languages with superlative I/O capabilities. In that respect, assembly-level code is hard to beat. It can do anything, but it’ll take you a while to write the code.

      1. Assembly-level code also has the advantage of specified execution time, so I could design hardware to be fast enough for my math-heavy hard-real-time signal-processing assembly code running all by itself on the bare metal.

        Thanks Steven for this article.

  5. I too am fascinated with the history behind hardware and software. In college, I started off with punched-card Algol, simulating a processor architecture executing assembly language. At MMI, I wrote PALASM, a programmable logic device Hardware Description Language boolean assembler/simulator. The trick was getting the high level language, FORTRAN, to parse single characters and output fuse maps to a PAL programmer. Later, I graduated to BASIC, Turbo Pascal, C, Verilog, VHDL, HTML, Javascript and Python.
    Also, thanks Steven, for this article.

  6. What a coincidence, jbirkner. I too studied Algol in college and one semester’s assignment for my computer science class was to write an assembly language emulator for the Univac 1108 mainframe computer in Algol, which then compiled and ran on the university’s Univac 1108 mainframe. Later, while working for HP, I took a graduate extension course in operating systems from Colorado State University and taught by Professor Denny Georg, who later joined HP. The assignment there was to write a multitasking operating system, which I did in HPL for the HP 9825 desktop computer. We had a lot of those around. Glad you liked the article.

Leave a Reply

featured blogs
Feb 22, 2024
The new Cadence training website is online! This newly redesigned website provides an overview of our well-respected training methods and courses, plus offerings that might be new to you. Modern design and top-of-the-page navigation make it easy to find just what you need'”q...
Feb 15, 2024
This artist can paint not just with both hands, but also with both feet, and all at the same time!...

featured video

Tackling Challenges in 3DHI Microelectronics for Aerospace, Government, and Defense

Sponsored by Synopsys

Aerospace, Government, and Defense industry experts discuss the complexities of 3DHI for technological, manufacturing, & economic intricacies, as well as security, reliability, and safety challenges & solutions. Explore DARPA’s NGMM plan for the 3DHI R&D ecosystem.

Learn more about Synopsys Aerospace and Government Solutions

featured paper

How to Deliver Rock-Solid Supply in a Complex and Ever-Changing World

Sponsored by Intel

A combination of careful planning, focused investment, accurate tracking, and commitment to product longevity delivers the resilient supply chain FPGA customers require.

Click here to read more

featured chalk talk

Battery-free IoT devices: Enabled by Infineon’s NFC Energy-Harvesting
Sponsored by Mouser Electronics and Infineon
Energy harvesting has become more popular than ever before for a wide range of IoT devices. In this episode of Chalk Talk, Amelia Dalton chats with Stathis Zafiriadis from Infineon about the details of Infineon’s NFC energy harvesting technology and how you can get started using this technology in your next IoT design. They discuss the connectivity and sensing capabilities of Infineon’s NAC1080 and NGC1081 NFC actuation controllers and the applications that would be a great fit for these innovative solutions.
Aug 17, 2023