ACCU On Sea 2026 - Talks Worth a Mention

There were plenty of talks that don’t slot neatly into a single theme, but were absolutely worth a mention in their own right. Here are a few of my favourites.

In the beginning: A genesis of our craft - Walter Brown

Sadly this one wasn’t recorded, which is a real shame, because it was a wonderful whistle-stop tour through the origins of our craft.

Walter started with John McCarthy and the idea that, with a set of operators and some function notation, you can define a programming language. He talked about how the most influential paper of all was arguably the 1946 paper on the Von Neumann machine; something we all take completely for granted now, despite it being the de facto model for 80 years.

A big chunk of the talk was about LISP, and Walter posed the question of why it is still studied after 75 years. His answer was that it is rooted in maths (and maths doesn’t get stale), it was designed to evolve, and in that sense it is a bit like Latin. He gave a rundown of LISP itself: the fact that it really is just all parentheses, car and cdr for working with lists (car for the head, cdr for the tail), and cons for concatenating atoms and lists. I learned that car and cdr come from “contents of address register” and “contents of data register”, which is a great bit of trivia.

The bit I loved most was learning that unnamed functions in LISP were given the placeholder name lambda, influenced by Alonzo Church’s lambda calculus. So that, presumably, is where our lambdas come from! This led to an early form of the callback.

He rounded things off with a tour of the giants whose shoulders we all stand on, from Ada Lovelace and George Boole, through Dijkstra and Knuth, with particular emphasis on Emmy Noether and Grace Hopper.

16 years doing C++ Standardization work - Nevin Liber

This was a lovely, human talk about what it is actually like to be part of the C++ standards committee (which, I learned, has 540 members).

Nevin has been around a while. He worked at Bell Labs back in 1988, and was the first to call attention to the bug that loop variables were valid after the scope of a for loop. That behaviour was originally left in for backwards compatibility, but he managed to get people convinced to fix it. He was also behind getting the space between double closing angle brackets sorted out in C++11. He had some great war stories too, including working on slot machines, where (as you would expect) the RNG code is exceptionally important.

What I really took from this talk was Nevin’s honesty about confidence. He originally didn’t think he was smart enough to attend conferences, and was intimidated by all the experts. In his first standards meetings he never spoke, because he was too shy. Over time he gained more confidence, started pointing out little issues with proposals, and eventually felt able to argue his disagreements properly. He talked about how he tried to get optional into C++14 (it got pulled out over comparison operator debates), and worked with Matt Godbolt on variant, before both finally landed in C++17. His point was that there are a lot of battles, and the language is better because of those battles.

Post Modern Programming - Tony Van Eerd

I am very happy I got to see this one live. Tony delivered a big chunk of the talk in rhyme, which was as fun as it sounds. Beneath the fun, though, it was genuinely insightful; one example showing how separating state from decision making led to noticeably better code has stuck with me. A funny talk with a real point to it.

The Performance Mindset - Mathieu Robert

This one started out being about optimizing the initial load of Europa Universalis 4, but grew into something much broader. Mathieu spent a good chunk of time on profiling tools, and made a lot of points that echoed my own talk: performance leaks from expensive queries, bugs that go unnoticed for years, and reviews that don’t catch everything.

A couple of bits of wisdom I am keeping hold of: it is really valuable to have a rough sense of how long things should take (loading a gig from disk, reading a million integers, rendering a million triangles, and so on), and that approximations are usually fine. You don’t always have to do the expensive thing; take the shortcuts. There was a lot of truth packed into this talk.

Microarchitecture: What lies Beneath - Matt Godbolt

This was easily the most heavily attended talk I went to. The room was completely full, with people sitting on the floor and standing along the sides because there simply weren’t enough seats. Easily over 100 people.

Matt’s talk was all about Skylake’s out-of-order execution. Something I learned from this is that Matt has done a hell of a lot of researching into Intel micro architecture, and was even cited in some early papers around Spectre and Meltdown. e.g. Reading privileged memory with a side-channel. He also has a pretty cool video on Spectre and Meltdown on his channel here.

I learned a lot from this talk. E.g. Register Alias Table (RAT), and how it dynamically assigns registers. This explains some lovely tricks:

• xor eax, eax does nothing in the way you might think. The hardware just points RAX at register P00, a real register that is never written to and always holds zero.
• A mov works similarly. It just renames the register to the new one, so no actual move happens.

This is one of those talks that was so loaded with information that I couldn’t keep up with my notes, so I will be watching again when it comes out on YouTube.