ACCU 2022 Trip Report
From April 6-9, 2022, I attended ACCU 2022, the 25th edition of the ACCU conference, in Bristol, UK. It was only my third in-person conference post-COVID (after CppCon’21 and ADC’21). It felt very special to be back in Bristol after a three-year break, and it felt as good as ever to be among real people again. With all COVID restrictions now lifted in the UK, this was the first event on the C++ conference circuit that truly felt like it was back to normal. There was no social distancing or any other measures to impact the conference experience, and the vast majority of attendees were not wearing masks.
For me, ACCU has a special place in the C++ calendar for many reasons. First, ACCU is known for its exceptionally friendly and nice community, including folks who have been attending ACCU regularly for a decade or more, but also being especially welcoming and approachable to first-timers. This year was no different – it was great to be back meeting old friends and making new ones.
ACCU is also special in that it is not only about C++ (although it has a large proportion of C++ content), so you also get content on other technologies and non-technical talks about soft skills and other interesting things. The quality of the talks is very high and the size is just right: bigger than “small” conferences like C++Now, but not as big as CppCon or MeetingC++, so you still get the chance to meet and talk to most attendees.
In pre-pandemic times, I would usually expect about 400 people at ACCU. This year however, we only had about 150 people on site, so it was noticeably quieter than usual (although the vibe was as positive as ever). In addition, there were about as many people attending online, as the conference was fully hybrid this time, with three on-site and two online tracks and the option for online attendees to watch the on-site talks and ask questions.
The organizers went to great lengths to make the online component of the conference really enjoyable, including recreating the whole conference venue (Bristol Marriott) online inside gather.town. But I have to admit that I did not engage with the online component. Why spend time in video chat rooms when you are on site at the venue and have real people to interact with? Therefore, the following trip report is focusing exclusively on the on-site component of the conference.
Not only were there fewer people on-site, but also fewer booths. I spotted the traditionally present Bloomberg booth, as well as Graphcore and SonarSource booths. And we had a #include table again, which was a very popular hangout spot. Sadly, JetBrains did not have a booth this time, as the rest of my team was unfortunately unable to attend. In fact, out of all of the ACCU conferences I’ve attended, this was the first one with no JetBrains booth! One of my most memorable conference experiences was walking up to the JetBrains booth at ACCU 2017 and asking them whether they would consider hiring me, and the following year I was working behind the very same booth. I very much hope we will be back there in full strength next year, but this time I was representing JetBrains on my own.
Conference day 1 started with Guy Davidson’s keynote “Growing Better Programmers”. Guy is a good friend of mine and this was his first proper conference keynote. I have to say he did an amazing job! Speaking from many years of experience, Guy shared many great thoughts about mentoring and supporting programmers, promoting good practices, conducting helpful code reviews, being a good manager, and much more.
I missed the talks following the keynote because I was busy practicing my own talk, how to implement a lock-free atomic shared_ptr, which I presented that afternoon. Following that, I was met with the usual dilemma at such conferences: there are multiple tracks and you can only go to one. The program is so high-quality that you end up missing a lot of fantastic talks you really want to see. My talk of choice was “Zen and the Art of Code Lifecycle Maintenance”, a very deep and insightful investigation of what we actually mean by “code quality.” The talk was given by Phil Nash, my predecessor as C++ Developer Advocate at JetBrains, who now works at SonarSource.
My first day at ACCU 2022 wrapped up with a lightning talk session moderated by Pete Goodliffe. This is the true highlight of the ACCU conference: the lightning talks are usually very entertaining, creative, funny, thoughtful, and mostly not about programming at all. In between the talks, Pete tells dad jokes, and if any speaker overshoots their 5 minute speaking limit, Pete takes away the microphone mid-sentence and pushes them off the stage. It’s hilarious!
Day 2 opened with a keynote by Hannah Dee, “Diversity Is Too Important to Be Left to Women”. I was really impressed by this talk. It covered why diversity and inclusion are important, what we should do, and what we should not do, and covered it all in a way that felt extremely well-researched and backed up by data and facts. Even though this issue was already very close to my heart before Hannah’s talk, I learned about so many new things from her, like the concepts of gender role spillover and stereotype threat, how self-efficacy affects performance, the Petrie multiplier (a very simple yet powerful mathematical model), pareidolia, and more. I highly recommend this talk as a solid, approachable, and enjoyable introduction to anyone interested in the topic of diversity in tech.
Switching gears after the keynote and diving into C++ code again, I went to “C++20 – My Favourite Code Examples” by Nico Josuttis. This talk was full of interesting C++20 code. Nico started by showing various ways to use C++20 concepts and constraints in practice. Among other things, I learned that we can use a requires-clause inside an if constexpr, like this:
void add(auto& coll, const auto& val)
{
if constexpr (requires { coll.push_back(val); })
coll.push_back(val);
else
coll.insert(val);
}
This is a very convenient way to branch on the existence of a member function, something that was a lot more cumbersome pre-C++20. Nico then showed practical examples of how to use ranges, views, the spaceship operator, and other C++20 features all working together. Along the way, I also learned how to implement your own range sentinel! Of course, it would not be a Nico Josuttis talk without a healthy dose of ranting about things that the C++ standard committee has gotten wrong in Nico’s opinion: how cbegin is utterly broken, how “forwarding reference” is a bad name, how std::views::elements<0> does not work for user-defined types unless you declare your own tuple customization points before you #include <ranges> (which is quite unfortunate indeed), and so on.
ACCU is one of the conferences that offer talk slots to sponsors, but often these can be very interesting, so I went to a sponsored session during the lunch break: “The Power of Clean Code” by the SonarSource folks. I was very happy to see CLion in action there, supplemented by their SonarLint plug-in, which looks like a very powerful tool that I definitely need to check out in more detail.
After lunch, another ACCU speciality was waiting. The normal talk length is 90 minutes, but they also have 20-minute “quick talks”, usually several of them back to back. The ones I chose were very interesting and relevant explorations of “soft” topics: a talk by Björn Fahller about burnout, a talk by Dom Davis about remote working, and a talk by Joe Pascoe about how to be a good manager.
The second day finished with another round of lightning talks, followed by the C++ Pub Quiz hosted by conference chair Felix Petriconi.
Day 3 started with a keynote by Patricia Aas about software vulnerabilities, and this was another absolute highlight of the conference. Patricia took us on a fascinating time travel journey through the last two decades. Her slides were packed with interesting code examples demonstrating vulnerabilities arising from malloc, use after free, heap buffer overflow, integer operations, and printf format strings. Among other things, I learned what a “Write-What-Where primitive” is and that format strings are an almost Turing-complete programming language! Patricia’s talk ended with the thought that we would all benefit from more cross-pollination between the systems programming community, which C++ is part of, and the binary exploitation/vulnerability community.
The next talk slot had no fewer than three coroutines-related talks scheduled against each other. I decided to listen to Björn Fahller’s talk about using coroutines for asynchronous I/O on Linux and how they really help to avoid callback hell. In C++20, we got a basic low-level API with hooks into the compiler that enable the use of coroutines, but no library facilities whatsoever on top of that to actually use them. So even for the most basic coroutine example, we need to write a lot of boilerplate code by hand – the coroutine type, the promise type, and so on. This is very hard to learn and to teach, but Björn did a good job guiding the audience through the required machinery. His talk also contained references to other helpful introductory talks about C++20 coroutines, such as Pavel Novikov’s “Understanding Coroutines by Example”.
The other highlights of Day 3 for me were Kate Gregory’s “Abstraction patterns” and another talk about coroutines, this time by Andreas Weis, showing how to use them for data processing pipelines (reading a file from the disk, compressing it, and so on). With my background in audio software development, I was fascinated by how Andreas’ data pipelines were structurally virtually identical to audio processing graphs, containing sources, sinks, filters, and buffers, with data channels exchanged in between them. This makes me think (again!) that coroutines would probably be very useful in that domain, too.
In the evening, there was a third lightning talk session hosted by Pete (they were so popular this year that Pete ran out of lightning talk slots!), which was just as much fun as the others, and finally the traditional conference dinner, which I always enjoy. The ACCU conference dinner is geared towards enabling as many conference attendees as possible to mingle with speakers. Speakers remain at the same table throughout the dinner, while everyone else changes tables after every course. This is good fun and you get to meet lots of new people. In addition, there is always a theme – this year it was film.
And now we’re at the last day of ACCU! I started the morning by attending Mathieu Ropert’s “Basics of profiling”. Mathieu delivered a really good beginner-friendly introduction to profiling, why it’s important, things you need to know such as sampling profiling vs. instrumentation profiling, and more. He then actually live-demoed profiling his video game Hearts of Iron IV with the Optick Profiler, a instrumentation profiler, and Intel VTune, a very powerful sampling profiler. He explained what to look for and how to interpret what you see, and finished off his talk with useful general tips on how to optimize a C++ program. This hands-on approach including live demoing is rarely seen in conference talks, and I really enjoyed it.
Later that day I attended John McFarlane’s talk “Contractual Disappointment in C++”, which I also highly recommend. The title would suggest that the talk was about contracts in standard C++ and how we ended up not having them, but actually it was not about that at all. Instead, John talked about contracts as a programming concept, the difference between bugs and errors, different types of contracts, and other things that every programmer should think about.
Finally, it was time for the last talk of the conference: Titus Winters’ closing keynote! Titus, the author of “Software engineering at Google,” aka the Flamingo Book, decided to fully embrace his new brand and showed up on stage in a flamingo shirt. His keynote titled “Tradeoffs in the Software Workflow” was just as high-quality and thought-provoking as I had hoped and tackled really big questions for our industry such as “What is the value of the code that you write?” and “What is the value of preventing a defect?”. This is another talk that I highly recommend. In fact, all the talks I saw this year were so good that I am very impressed once again by the quality of the ACCU conference program.
Of course, in between all the talks, there was the all-important hallway track. Even though there was no JetBrains booth this time, I was still very busy talking to people about JetBrains products in general and CLion in particular. Some noteworthy interactions involved helping a CLion user figure out how to build the LLVM project in CLion (which gave me some good ideas for putting together a “CMake in CLion” tutorial) and multiple folks asking about the new “thin client” remote development mode in CLion (which is currently still in Beta, but nevertheless already very usable, so I recommend you check it out now!).
And that was it from ACCU 2022! I am really looking forward to next year’s conference, but in the meantime, I will be attending other in-person C++ events, with the next one on the calendar being C++Now in beautiful Aspen, Colorado. See you there!
Subscribe to CLion Blog updates
