RIP: Software design pioneer and Pascal creator Niklaus Wirth

Probably more than any other, for myself, it was the works of this pioneer and their derivatives that served as a vehicle for learning.


UCSD Pascal was arguably my second programming language after BASIC, and not counting 6502 assembler.

I’ve never understood the hate for it. It was an excellent educational language as designed, and its successors fixed a lot of the issues while remaining considerably more safe than C.


Here is the statement from ETH ZĂĽrich announcing the death of Prof. Wirth.

Computer pioneer Niklaus Wirth has died

Computer pioneer Niklaus Wirth died on 1 January 2024, just weeks before his 90th birthday. The long-​serving ETH Professor of Computer Science achieved world fame by developing the Pascal programming language in the 1970s. In 1984, he became the only German-​speaking computer scientist yet to have received the Turing Award, which is regarded as the Nobel Prize for computer science.

Turing Award winner, computer pioneer, inventor of influential programming languages: Niklaus Wirth’s achievements and accomplishments in the field of computer science are far-​reaching. He is probably best known for the programming language he developed, Pascal. However, his impact extends far beyond that. Wirth’s work and passion played a fundamental part in developing the world of IT. To this day, his achievements have had a decisive influence on computer science and generations of programmers. According to his family, Wirth passed away peacefully on 1 January 2024.

Wirth had a key role in establishing computer science in Switzerland. He succeeded in bringing computer science innovations from the United States, then the country at the forefront of computer development, to Switzerland and helped computer science achieve a breakthrough as a separate research field and profession in the country, as ETH President Joël Mesot recalls: “In Niklaus Wirth, ETH Zurich has lost one of its greats: someone who not only did pioneering work in the development of programming languages, but was also one of the founding fathers of computer science in Switzerland and at ETH.”

Wirth was a professor at ETH Zurich from 1968 to 1999. It was thanks to his persistence, and that of his companions, that ETH established an independent Department of Computer Science and the associated degree programme in 1981.


I only just learned that there’s an asteroid named after him.


I was one of the primary “haters” of UCSD Pascal back in the day, but it had nothing to do with the Pascal language or that particular implementation of it. My problem with UCSD Pascal is that it was developed by a taxpayer-funded California public university (University of California San Diego) based upon a software package which Niklaus Wirth and ETH (the Swiss Federal Institute of Technology at Zürich) made available for free, but was then sold as a commercial product. It was not made generally available for use by computer users and manufacturers, even those who were California taxpayers and paid for its development. I expressed my view of using taxpayer funds to develop a commercial product not available to taxpayers at the time, saying, “It may be legal, but it’s not right.”

As a California computer manufacturer at the time seeking programming languages for my machines, I was enraged that this language implementation, funded by my taxes, was not available for use on my machines. I ended up porting Brinch Hansen’s Sequential Pascal, which was freely available, to my machine. It out-performed UCSD Pascal by a substantial margin.

The original Pascal, as defined by Wirth, had many drawbacks as a systems programming language for application and system software development. In particular, it did not support separate compilation, so large programs could not be developed in a modular fashion, any change required recompiling the entire application (which on small computers of the time could take almost forever), and there was no way to break a large program into overlays to fit into machines with limited memory. Character strings were supported only as arrays of characters with fixed length, and two arrays with different lengths were different data types: it was impossible to write a function which input or output variable length strings, which made text processing almost impossible and hideously inefficient. Dynamic memory allocation was not defined, and there was no standard way to do binary input/output. Many of these limitations were worked around by extensions and machine-language libraries in various implementations of Pascal, but each in its own way, so programs that used these extensions were not portable from one version of Pascal to another.

C, by comparison, however ugly and dangerous, had all of these facilities “out of the box” and demonstrated this capability by having its own compiler and operating system being written in C with a bare minimum of machine-language code. C also provided access to the “bare metal” of the computer hardware, running many times faster than Pascal systems which were often implemented as an interpretive stack machine.

UCSD Pascal, as shipped for the IBM PC, was laughably slow, and restricted programs to one 64 Kb code and 64 Kb data segment, which meant it was limited to writing “toy programs”, fine for education, but not real-world applications. A commercial version of UCSD Pascal sold by a company called SofTech allowed larger code segments but retained the single 64 Kb data segment and was still extremely slow.

As it happened, one of AutoCAD’s primary competitors in the early days, VersaCAD from T&W Systems, was implemented in UCSD Pascal, and suffered from the very poor performance of the interpretive system and the constraints of running under an operating system entirely different from MS-DOS or CP/M, and thus unable to exchange files with other applications without convoluted work-arounds. AutoCAD’s faster performance and compatibility with many more computers and peripherals gave it a substantial advantage in the market.


I was referring more to the hate on Pascal in general, than the unfortunately performance limited Pascal P-machine. A lot of the hate centered around how it wasn’t a systems programming language, when it wasn’t supposed to be one. It’s like complaining your driving instructor’s car can’t be used to dig a trench without extensive modification. Wirth’s solution was to move on to the next languages (Modula, Modula-2, various Oberons) once using Pascal gave him a better sense of where he wanted to go. Theoretically the industry could have standardized on a set of extensions, but few understood the value of that then.

I am all too aware of how slow the P-machine could be. My first job, in late high school, was to write a microscope simulator in Apple Pascal on an Apple ][+ so the teachers could more easily show how measuring things you saw in the scope worked. I was paid in a A for the CS course I wasn’t actually registered in. Drawing the little circles and ellipses, even using Minsky’s tricks, was quite painfully slow.

But in first year at UBC, I used IBM Pascal/VS [1] on a System/360-clone (Amdahl 470/V6 running MTS) for classes and it was plenty fast, as you would expect with it compiling to ok-ish machine code. (My friends and I checked, writing a matrix multiply in a bunch of languages amd optimization levels and comparing the generated code.) I wouldn’t do systems programming in it, the Pascal in the spec was always an educational language. OTOH, I wouldn’t have used C there either. For a later project I had to use Scott Kristjanson’s port of PCC(?), and the segments and base+displacement architecture of System/360 made C pointers tricky (nevermind EBCDIC breaking a bunch of assumptions).

I agree with you on the issues with the monetization of UCSD Pascal. If the public pays for it, it should require a really exceptional explicit reason to take it private commercial. Fortunately we now have Free Software and Open Source licenses to avoid some of that issue.

[1] Index of /pdf/ibm/370/OS_VS/pascal


I’ve did a programming competition back in early 90’s with a group of my classmates that thought C is a superior programming language. I told them that Turbo Pascal is good enough. So I proposed a time-benchmark printing out all the prime numbers lower than 100000, each in a new line.

I won, even though I just used a very simple algorithm. This is because I knew the bottleneck wasn’t the prime numbers algorithm, but the scrolling. I optimized that by just scrolling the first 5 columns.

They were stunned by the speed. I never explained the trick to them.

A bad worker blames his tools.


Starting with v5.5, Turbo Pascal became a viable platform for building applications and was used to build a number of commercially successful apps at the time. I was able to take it and its successor Delphi to levels that earlier implementations of Pascal could probably never have gone without significantly- more effort and migraines. There was probably nothing that irked Bill Gates more than Borland’s development tools.


Martin Odersky, one of Niklaus Wirth’s Ph.D. students and now lead designer of the Scala programming language, has posted “Some Memories of Niklaus Wirth”.

Niklaus Wirth passed away on the first day of this year. He was one of the most important pioneers of computer science, probably the one who had the biggest practical impact while maintaining at the same time rigorous scientific and engineering principles. Niklaus described himself as an engineer, and that’s what he was. As an engineer, he applied scientific discoveries and principles in the development of useful products, which included programming languages, compilers and other systems software. But he had to create a large chunk of the science himself, since it did not yet exist at the time.


The work in Wirth’s group was quite special. I realized how different the workplace was only after I had moved on. You see, everything we worked with was “homebrew” stuff, but at the same time was advanced way beyond the standard of the time. It started with the computer: A screen that could show a full a A4 page on a bitmapped display, and a mouse for interacting with it. This at least 5 years before a commercial computer with these characteristics came out. It continued with the fonts. Since there were no bitmapped displays there were no fonts for such displays either. So one member of the group was a professional font designer, and another member was a designer for font-designing tools! It continued with the operating system, and the programming tools. We had a simple but powerful text editor which was configurable to be a very productive IDE. We also had a simple and beautiful debugger that showed a thread-dump with full memory exploration in a set of tiled windows. I forgot to mention, of course the windowing system was also developed in house, everything was.

Now you might think that there would have been an army of developers doing these things. But no, it was Niklaus Wirth with 6 doctoral students, as well as some researchers in the associated groups of Jürg Gutknecht and Peter Mössenböck. The best thing was, if you had a question or suggestion, you would just walk into the office next door and talk to the person who wrote the software.


Bertrand Meyer has posted his own memorial of Wirth: Niklaus Wirth, or the Importance of Being Simple

I am still in shock from the unexpected death of Niklaus Wirth eight days ago. If you allow a personal note (not the last one in this article): January 11, two days from now, was inscribed in my mind as the date of the next time he was coming to my home for dinner. Now it is the date set for his funeral.

The emphasis simplicity and elegance carried over to his book on compiler construction. Another book with the stunning title Algorithms + Data Structures = Programs presented a clear and readable compendium of programming and algorithmic wisdom, collecting the essentials of what was known at the time.

And then, of course, the programming languages. Wirth’s name will forever remained tied to Pascal, a worldwide success thanks in particular to its early implementations (UCSD Pascal, as well as Borland Pascal by his former student Philippe Kahn) on microcomputers, a market that was exploding at just that time. Pascal’s dazzling spread was also helped by another of Wirth’s trademark concise and clear texts, the Pascal User Manual and Report, written with Kathleen Jensen. Another key component of Pascal’s success was the implementation technique, using a specially designed intermediate language, P-Code, the ancestor of today’s virtual machines. Back then the diversity of hardware architectures was a major obstacle to the spread of any programming language; Wirth’s ETH compiler produced P-Code, enabling anyone to port Pascal to a new computer type by writing a translator from P-Code to the appropriate machine code, a relatively simple task.


Brian W. Kernighan, head of the Computing Structures Research Department, Bell Laboratories. Dr. Kernighan is the co-author of several books, including The C Programming Language and The UNIX Programming Environment:

Why Pascal is Not My Favorite Programming Language