Irreal

Many years ago, I did a stint as a compiler writer. I don’t do that
anymore but I’ve continued practicing what I learned by implementing
several little languages for various tasks. Mostly, I’ve leveraged
lex and yacc for those chores but my first little languages were
implemented using the simpler recursive descent technique for
parsing. Yacc is more powerful in the sense that it can parse LR(1)
languages in addition to the more restrictive LL(1) languages but
many or even most languages are LL(1) and certainly any reasonable
little language will be.

I mention all this because Hanspeter Mössenböck’s paper Compiler
Construction—The Art of Niklaus Wirth popped up in my RSS feed. Most
readers are probably familiar with Wirth as the designer (and
implementer) of Pascal and Modula{23} but he implemented many
compilers and is an expert on language and compiler design. The paper
is a retrospective on Wirth’s philosophy of language and compiler
design.

One of the things that popped out as me was his belief that compilers
should be simple, reliable, and fast and that he preferred that over
the heavy complexity that aggressive optimization brings. Ironically,
according to the paper Wirth’s compilers generated code that was
nearly as fast and those that did heavy optimization. He achieved that
by focusing on generating good code to begin with rather than
generating bad code and letting the optimizer fix things up.

He also preferred parsing with recursive descent because he felt it
forced the language designer to keep the language approachable and
simple. He believed that C would have been a better language if
Ritchie had restricted its grammar to LL(1) because it would have
avoided some of the syntactically dubious constructs that made their
way into the language.

If you have any interest in (computer) language translation—even if
only for little languages or DSLs—the paper is worth a few minutes of
your time. Also, Wirth’s book Compiler Contruction is available as a
PDF in many places such as here. The book expands on some of topics
that Mössenböck discusses in the paper.

The other day, I wrote that C++ is not my favorite language and that
it’s eliminated most of what’s useful about C while retaining most of C’s
disadvantages. Then I saw this post, which says that the 2018 C++
committee is planning the deprecation and later removal of pointers
from the language. My immediate thought was that that proved what I
wrote.

Of course, the post is almost certainly an April Fools joke but here’s
the thing: No one seems to be sure. There’s a long discussion over at
Hacker News where half the commenters are sure it’s a joke and the
other half are convinced it’s true. I asked DuckDuckGo and it didn’t
know either.

It speaks volumes about the language that this should be so. The
language is so full of cruft and has made so many dubious decisions
that knowledgeable people can’t decide if this is another dubious
decision or a joke even though the discussion is happening on April
first.

I’m sure lots of Irreal readers have coded in
C++—I’ve coded in C++—and many of them
probably like the language but its appeal escapes me. These days there
are better alternatives for almost any project so it baffles me that
folks continue to choose C++. No doubt that’s begging to be ruthlessly
schooled on why folks do choose C++ but that’s part of what make the
Irreal community so much fun.