It’s February! This means I have been at the JKU for four months. Four months with teaching Compiler Construction and System Software, lots of new responsibilities (most notably signing off on telephone bills and coffee orders…), many new colleagues, and new things to learn for me, not least because of the very motivated students and PhD students here. And when I say motivated, yes, I am very surprised. While the attendance of my 8:30am Compiler Construction lectures was declining throughout the term as expected, the students absolutely aced their exam. I suspect I will have to make it harder next year. Much harder… hmmm 🤔 Much of the good results can likely be attributed to the very extensive exercise sessions run by my colleagues throughout the semester.

At this point, I have to send a big thank you to everyone from the Institute for System Software, past and present. It’s great to be part of such a team! You made my start very easy, and, well, it now gives me the time to think about my inaugural lecture.

What’s an inaugural lecture?

I have been in academia for almost two decades, but I have to admit, I don’t really remember being at an inaugural lecture. According to Wikipedia, in the Germanic tradition an inaugural lecture (Antrittsvorlesung) is these days something of a celebration. It’s a festive occasion for a new professor to present their field to a wider audience, possibly also presenting their research vision.

At the JKU, it indeed seems to be planned as a festive occasion, too.

On March 9th, 2026, starting at 4pm Prof. Bernhard Aichernig and I will give our Antrittsvorlesungen, and you are cordially invited to attend.

Bernhard will give a talk titled Verification, Falsification, and Learning – a Triptych of Formal Methods for Trustworthy IT Systems.

My own talk is titled, as is this post: Programming Language Implementation: In Theory, We Understand. In Practice, We Wish We Would.

Bernhard will start out by looking at the formal side of things, making the connection between proving correctness, testing systems in the context of where they are used, and learning models from observable data. My talk will narrow in on language implementations, but also look at how formal correctness is helping us there. Unfortunately, provably-correct systems still elude us for many practical languages. Even worse, we are at a point where we rarely understand what’s going on in enough detail to improve performance or perhaps fix certain rare bugs.

If you like to attend, please register here.

In Theory, We Understand. In Practice, We Wish We Would

Here’s the abstract of my talk:

Our world runs on software, but we understand it less and less. In practice, the complexity of modern systems drains your phone’s battery faster, increases the cost of hosting applications, and consumes unnecessary resources, for instance, in AI systems. All because we do not truly understand our systems any longer. Still, at a basic level, we can fully understand how computers work, from transistors to processors, machine language, all the way up to high-level programming languages.

The convenience of contemporary programming languages is however bought with complexity. Over the last two decades, I admit, I added to that complexity. In the next two decades, I hope we can learn to build programming languages in ways that we can prove to be correct, enable us to generate their implementations automatically, and let systems select optimizations in a way that we can still understand the implications for software running on top of it.

You may now wonder where to go from here. And that’s a very good question. I have another month to figure that out, perhaps more… 😅

So, maybe see you in March?

Until then, suggestions, questions, and complaints, as usual on Mastodon, BlueSky, and Twitter.