The Flight

It was a clear but gusty day, and all of a sudden the right wing wanted to be much higher than the left. I jammed the wheel to the right, maneuvering the rouge wing level to the horizon. Seconds later, the wing again jerked upward. The plane’s nose wanted to drift up too, so I pushed the wheel for a few moments until it dropped. My feet jabbed at the rudder pedals to keep pointed straight. It was a fast dance in three directions, knees and elbows moving like mad.

Low over Oklahoma City and headed to Will Rogers World Airport, the tower was about to call my base leg, the turn just before the turn to land. There was a larger passenger jet lined up to land on runway 17R, the same runway my passenger and I were going to arrive at.

This memory isn’t so vivid because of the wind or the fact that I was landing at such a large airport in a Bonanza F33, a small, single-engine, general aviation plane. The unique thing about this particular trip was the passenger: Niklaus Wirth.

Our adventure began with a Friday afternoon email. Paul, a British friend, mentioned that he was planning a visit to San Diego to attend a talk Wirth was giving on the Oberon programming language. He was speaking at the History of Programming Languages conference, HOPL III.

Paul wasn’t so sure that the new folks’d be so supportive of Wirth. The software world seemed to be abandoning the good professor’s tenants and the languages being covered at the conference were a far cry from the clean lines of Wirth’s languages - Pascal, Modula-2, and at the time Oberon, one that Paul and I had a passion for. (I would eventually learn that Paul and I needn’t have been worried.)

I was looking for a boondoggle, a way to get away for a few days, anyway. Borrowing a friend’s Bonanza to fly across the country sounded like a great trip.

Wirth had taken flying lessons himself. He was a professor of informatics at ETH in Zurich but would take sabbaticals to Xerox Palo Alto. While in the US, he’d always take a flying lesson for the fun of it. Back home in Zurich, the mountainous landscape made all uncontrolled airspace cumulogranite, too risky to fly responsibly. But in the US, even the Bay Area airspace, as crowded as it was, seemed spacious compared to the Alps.

I knew all this because I met him at the Joint Modular Programming Languages conference held in Oxford the year before. We hit it off, maybe because I truly understand Wirth’s values (or think I do, anyway). For thirty years, I used his step-wise way to guide my every development project.

I discovered Oberon after creating the PIX Firewall’s Finesse OS and was pleasantly surprised to find they had similarities. I wrote in C, of course, and Finesse didn’t need loadable code modules due to the embedded nature of the PIX. The rest of the system, though, was very similar.

Oberon and Finesse were each a single threaded system based on the idea of a task, that each unit of work only required a few microseconds. The firewall, for example, was just a series of small tasks done completely before the next one was accomplished. Wirth’s Oberon OS was structured the same way.

I also fully grokked the Oberon programming language. It’s the evolution of his famous line of languages, starting with Pascal. I learned Pascal early in my career, as many in my generation did after it took the world by storm in the 70s. Every CS book was written using it as the language and every University was teaching with it. Much of the research done on compiler construction used Pascal as a lab rat, poking it in some manner, changing one aspect, adding another. All these modifications were studied quantitatively down to the smallest detail. Pascal was the language of the moment.

In the days of PL/I’s complexity, FORTRAN’s lack of control structures, and COBOL (what can I say about COBOL?), Pascal stood out by its demonstration that sophistication in data and control structures could exist in a language that was elegant and simple. Step-wise refinement could lead to beautiful and lean technology.

Wirth preceded Oberon with his Modula-2 language. Modula-2 was a bit more complicated but elegantly solved the problem of separate compilation. Since the early days of assemblers, programs werecompiled in small units and put together by a loader of some kind. Modula-2 did this while also preserving a strong type checking of the procedures and data types across the separately compiled translation units.

Oberon was Wirth’s third language, the third decade of his work in languages. It started as Modula-2 and evolved into a language with something called type-extension, similar to object-oriented inheritance, only without all the redefined language. His compiler for the language was only 5,000 lines! That took Oberon source and produced ready to execute binaries. His compiler for Oberon represents thirty years of craft, thirty years of refinement, step-wise, of course, and thirty years of learning what can be made simpler.

For example, in earlier compilers, we used a hashing table to find variables. In Oberon, Wirth used a simple linked list for each scope of the language. The observation was that the number of variables in a well-written language in any given scope would be small. The extra complication of hashing just wasn’t worth it. This is just one of a bunch of wise judgments Wirth made with the Oberon language. Magnificent.

So when Paul reached out to me, I decided to fly across the country to hear Wirth speak and get a chance to visit again. I dashed off a few lines in an email to let him know that, thanks to Paul’s suggestion, I was looking forward to meeting him once more. He sent a nice reply and that was that. Or so I thought.

The next morning, I arrived at my office, checked email and there was yet another email from Wirth. This one was apologetic. He wrote that he didn’t mean to be forward, but asked if I needed a co-pilot for the trip. But the rest of this adventure I’ll save for another blog post.