Interview with Marcel van der Veer

Last Updated on September 29, 2025 by David Both

Creator of Algol 68 Genie

Having written a number of articles about using the open source Algol 68 compiler and interpreter, Algol 68 Genie, I am delighted to have had the opportunity to chat with Marcel van der Veer, its author, and share that conversation with readers…

Q: First of all, thanks very much for taking the time to speak with me, Marcel. I’m a true fan of your Algol 68 work… what motivated you to start this amazing project? For example, was there something particular in your work that led you to Algol 68? And thence to the decision to write a compiler for the language? What motivates you to keep it going?

A: I really appreciate the invitation Chris, it is a pleasure to speak with you about Algol 68 Genie.

It is I who should thank you, for publishing a series of articles on Algol 68.

Actually, I did not ‘just’ decide one day to start writing Algol 68 Genie. It was a long process going back to the early 1980’s. I was taught structured programming using Algol 68 by Kees Koster, one of the authors of the language.

I was fascinated by the language, because of its elegance and having been designed with a developer in mind. Note that ‘facilitating an average user to write code’ seems a recurrent goal in language development.

For example Algol 68 had this goal, then ABC, and later Python.

The development of Algol played an important role in establishing computer science as an academic discipline. The Algol family explored new concepts, and influenced the field of compiler construction.

For example, SIMULA 67, an early object-oriented language, is an Algol 60 superset.

Algol 68 introduced concepts that are current and relevant up to this day and had a full specification before implementation, to mitigate the problem of ambiguous semantics.

At the time the anecdote was that C had a few hundred implementation dependent ambiguities, while Algol 68 only had a handful.

Since my student years I have been drawn to the application of mathematics and computer science in chemical physics. You would have found me in the computer center, not in a laboratory.

I always have had close friends in computer science and linguistics, and that is how I developed an interest in programming languages and compiler construction.

At some point my experiments in compiler construction started to involve parts of an Algol 68 implementation. Of course, an Algol 68 parser was considered a Nemesis.¹ My CS friends considered formal methods to parse Van Wijngaarden grammars, and eventually gave up.

I followed the trail set out by Barry Mailloux, another author of the language. You see, the Algol 68 grammar allows for extraction of tags (types, identifiers, operators) before parsing. Mailloux showed that with having the tags a priori, the Van Wijngaarden grammar reduces to LALR.

I hand-coded my Algol 68 Genie parser accordingly.

At the time computer resources were being decentralized. Mainframes once ruled supreme in university computer centers, but people started acquiring their own Unix workstations. Algol 68 implementations were mainframe software, so while I was pleased to purchase an Ultrix workstation (remember DECstations?), the real price was losing access to an Algol 68 implementation.

Once I had hand-coded a parser I completed an implementation, so for the rest of my life I could program in Algol 68, anytime, anywhere!

Over all those years I have been privileged to converse with people involved in developing the language, its early implementations and text books. This group includes Charles Lindsey, Dick Grune, Andy Walker and Colin Broughton, but also Paul McJones from the Computer History Museum. This has been essential in developing Algol 68 Genie.

Q: Please tell us a bit about your background – your work career, your hobbies, your favourite cheese or chocolate or coffee, your favourite music…

A: I am a research scientist with an MSc in chemistry and PhD in applied physics, passionate to work where physics, chemistry, computer science and mathematics meet.

I work in the chemical industry, and currently my projects concern cheminformatics, which involves data science. Professionally, I do most coding in Python nowadays.

I live near Amsterdam where CWI (Centrum Wiskunde en Informatica, formerly Mathematisch Centrum Amsterdam) is located. No need to mention that this institute played an important role in the development of Algol 68, and later Python.

Besides work, I like art, movies, cooking good food and spending time with family and friends.

My favorite music is classical music, the genre depending on what I am doing and the mood I am in.

Q: Anyone who was aware of Algol 68 “back in the day” is probably aware of the substantial criticism leveled at the language design committee, perhaps mostly by people who were certain that the two-level formal grammar made it impossible to implement a compiler. Having successfully built a very good compiler, what’s your opinion on this historical criticism?

A: I was still in primary school when the Revised Report was published, so I obviously was not there when it happened. But here are my two cents.

At the time, computer science was a nascent discipline and the number of general purpose programming languages was manageable – you had FORTRAN, COBOL, ALGOL and a few more. Consider that at the time the field of compiler construction expanded while implementing those languages, so much of what we take for granted today was at the frontier then.

The Revised Report on Algol 68 still is considered one of the difficult publications in computer science.² Kees Koster encouraged students of computer science to study it at some point, to understand the two-level grammar and the influence the language had. But believe me, the Revised Report will grow on you. You will learn to appreciate the intellectual effort but also its humorous side – Koster once said that it is impossible to read out loud Algol 68’s production rules with a straight face.

Today’s plethora of programming languages suggests that there is no such thing as a grand unifying general purpose programming language. I suspect this was not realized at the time, as the goal of Algol 68 was to have much wider scope of application than Algol 60, and more rigorously defined syntax and semantics.

That goal can be approached in different ways, so when several learned people join in a room to discuss this, you’re bound to have fierce discussions and end up with disagreement.

In hindsight it is often obvious what should have been done, but that is not how the world works – we learn by experience.

Hence I guess it is understandable that the idea took hold that Algol 68 was hard to implement, considering the technology of that time.

However, the field of compiler construction developed fast enough to quickly outdate that idea. Mailloux showed us how to practically parse Algol 68 early on. The rest is straightforward compiler construction considering state of the art from the 1980’s.

If I demonstrated one thing, it is that a persistent person with access to copies of Mailloux’s PhD thesis and “Aho and Ullman” can build an Algol 68 implementation from scratch in their spare time.

Q: At what point did you decide to formally open source Genie?

A: During a reunion of chemistry alumni in Nijmegen in 2001, I discussed with Henk Keller my spare-time project. Henk was a chemist, who like me had a passion for computer science. Also, he was an early Linux advocate. He worked in Koster’s department when I was a student, and later became director of a Unix consultancy company.

You must realize that attempts to commercialize mainframe Algol 68 implementations were not very successful.³

As mentioned before, at the time computing resources became more and more decentralized and we had no idea how much interest there would still be for an Algol 68 implementation.

Henk convinced me that FOSS was a good option to bring my project to the attention of a larger audience. I contacted the FSF, at the time the FOSS authority, and got suggestions from Richard Stallman himself.

At that point, I had to think of a name for the project, before going public. I took inspiration from Douglas Hofstadter’s book ‘Metamagical Themas’ which describes a Lisp interpreter called a ‘genie’ as it grants a person’s ‘Lisp wishes’.

Thus Algol 68 Genie was born, and over the years the project got much more attention than I ever imagined. I initially estimated the number of interested people to be circa 10-100. In hindsight, my estimate appeared off by a few orders of magnitude, and I attribute that to the fact that I open sourced it.

Open-sourcing it, and people actually using it, also meant that I had to write documentation. Since Algol 68 was not unknown but at the same time not familiar, this documentation had to include extensive how-to sections. To complete the documentation, I included the Revised Report as a separate part.

Of course, the Genie has an extensive (and ever growing) regression test set, but such set is never complete. Having many users implies receiving occasional bug reports, which has improved the quality of the software.

With an implementation and extensive documentation, I had the essentials for an ‘Algol 68 Genie Project’ with the goal of preserving the language for current and future generations.

In that the project succeeds, more so now the Dutch National Library has selected my project website for frequent archiving as part of its endeavor to preserve Dutch digital heritage for future generations of researchers.

It is also gratifying to see that my parser was adopted for the recently started project to develop an Algol 68 front end to GCC.

Would I not have open-sourced Algol 68 Genie, none of this would have happened.

Q: Please tell us a bit about what’s changed in Genie over time? For example, I believe you recently moved integers from 32 bit to 64 bit. What has encouraged you to make these changes?

A: You must realize that a68g is almost 35 years old by now.

Initially, I developed the parser on a Macintosh SE, then transferred from MacOS to Linux on a PowerMac G3, once LinuxPPC became available. Now I develop a68g on Debian.

So over time, performance of my a68g development system has increased by orders of magnitude.

Algol 68 Genie versions reflect that.

Initially, I set out to develop a68g as an Algol 68 to C compiler, but eventually I made an interpreter to make a68g platform independent.

Other factors in this decision were that I noticed at the time that code generated by the ALGOL68RS compiler on a VAX8650 I worked with appeared to make abundant calls to runtime routines, and that I really liked the runtime checks from FLACC when I worked on IBM mainframes.

That made me give speed of execution a lower priority.

The choice for an interpreter also enabled precompiled binaries for use on Microsoft Windows, which has added to the popularity of the Genie.

As hardware capabilities evolved, so did Algol 68 Genie. At some point it became feasible to include a plugin compiler to speed up the interpreter. The plugin compiler is optional however, interpretation is the default.

That was release 2.

Now that 64-bit processors are commonplace and 32-bit is obsoleted by recent OSes like Windows 11 or Debian 13, I decided to upgrade to a 64-bit implementation, which is release 3.

Release 3 still builds on legacy hardware, however.

I consider Algol 68 Genie essentially feature-complete and recent releases mainly concern maintenance and additional runtime routines.

Q: Given that a lot has happened in programming language design since the 1960s and 1970s, is there anything “missing” from Algol 68 that tempts you to implement in Genie?

A: That is an interesting question, since I frequently do get feature requests.

Some are trivial, like additional runtime routines to accomplish a particular task. Such requests are easily accommodated.

Other requests are more ambitious, proposing to modernize Algol 68 itself. It should for instance be multiparadigm, support object oriented programming, and what have you.

Note that from the introduction of the language on, people have been proposing to “improve” Algol 68. An early well known example is Sietse van der Meulen’s paper ALGOL 68 might-have-beens from 1977.

I implemented one extension – Charles Lindsey’s partial parametrization proposal published in 1976. This gives the imperative language Algol 68 a functional sub-language.

But it is not my intention to arbitrarily expand the language, even though some of the ideas actually are good. I suspect it would morph Algol 68 into something that has no raison d’être among today’s programming languages.

Besides, as far as I know responsibility for Algol 68 still lies with IFIP working group WG2.1, and I will respect that. My project strives to preserve the original language for future reference.

That being said, if I understand it well the Algol 68 front end to GCC has ‘GNU extensions’ on its wish-list.

Who knows, we might see Algol 2068 after all.

Q: Do you have any advice for early-career professionals in software engineering or computer science?

A: I have to be careful since I am not a computer scientist, remember?

But there is some general advice that I can give from my experience from the Algol 68 Genie project.

Don’t be in a hurry to accept opinions on face value because people say so.

Do your own research and form your own opinion, but also learn to recognize when something indeed is unfeasible.

Also, never stop developing yourself, engage deeply in intellectual subjects outside your daily work, and contribute to the community.

For that last point, working on FOSS qualifies!

Thanks very much for taking the time to speak with us, Marcel, and best wishes going forward!

1. Thanks for using the word “Nemesis”, Marcel. I like the the Wikipedia comment in the article linked to the text above: “Later, Nemesis came to suggest the resentment caused by any disturbance of this right proportion [of both good and bad fortune], the sense of justice that could not allow it to pass unpunished”. ↩︎
2. Report: Conference on the history of ALGOL 68. 1993. Centrum voor Wiskunde en Informatica.Downloaded 2025-09-23. Provides an interesting retrospective on Algol 68, 25 years after its formal announcement. ↩︎
3. According to a late 1988 comp.lang.misc post on Algol 68 FLACC (Full Language Algol 68 Checkout Compiler), developed to run on IBM 370 mainframe hardware, one of its developers, Chris Thomson, observed: “You know, we only ever got 22 copies installed, and less than 5 of those in North America.  Even though it ran on 370’s under MVS, CMS and MTS, and was cheap and reliable.  Talk about a marketing disaster”. I suspect it was pretty hard to compete with IBM salespeople pushing PL/I, which could be used with CICS to create interactive business applications… ↩︎