CppCon 2017: trip report

01.11.2017 Giuseppe D'Angelo No comments

During the last week of September I attended the 2017 edition of CppCon, in Bellevue, WA. Unusually late due to my presence at Qt World Summit which took place just after it, here’s my trip report.

In a sentence: the conference was absolutely stellar. The technical content was of the highest quality, and with up to 6 tracks running all day for 5 days, one really was spoilt for choice. I also truly enjoyed the other session formats, such as the panels, the conference dinner(s) and the lightning talks. You can see the complete conference program here.

Something has to be said about the people attending this event. It felt fantastic to see such a vibrant community, made of extremely open-minded people, very welcoming to newcomers and willing to engage in all sorts of discussions. Someone said that “CppCon is the Woodstock of C++” — I couldn’t express it with better words.

The sessions’ videos are already being published on the CppCon YouTube channel; if you can’t find the recording for a session you’re interested in, re-check after a couple of days. Having all the talks professionally recorded, edited and published in just a few weeks is a great service to both the conference attendees (who obviously had missed 75% of the conference, given the 5-6 parallel tracks), as well as the overall C++ community, which benefits immensely from such content.

A big thank you goes to the CppCon organizers for running such a great conference.

Here’s a short summary of some of the talks I attended to. I still have have so many to catch up with!

Pre-conference class: Programming with Qt/Widgets

As part of the pre-conference classes, I delivered a 2-day version of our Programming with Qt Widgets training class. For conference attendees, it’s certainly a great deal, combining a great conference with KDAB’s excellent Qt training.

Keynotes

• Learning and Teaching Modern C++ (video), by Bjarne Stroustrup. In this keynote Bjarne talks about the struggle of teaching the most up-to-date C++ features and techniques, in a world where most of the content obviously still refers to the “older” principles. Being one of KDAB’s professional C++ trainers, this talk’s subject was very close to my heart, and it definitely is still making me think about how I can further improve the way I teach C++.
• C++ as “Live at Head” (video), by Titus Winter. Titus works on Google’s C++ core libraries, and his challenge is how to keep the massive Google codebase working and maintainable for the next decade(s). This keynote explains the approach taken at Google: “living at head”, that is, using the latest versions for every available library and dependency.
• Meta: thoughts on generative C++ (video), by Herb Sutter. Herb’s quest is making C++ simpler and more powerful by adding metaclasses to C++ — ways to have our compilers enforce constraints on our datatypes (e.g. an abstract class should not have data members), as well as automatically implement “boilerplate” code. Qt’s moc was mentioned as an example of tool that is necessary in today’s C++ world, but in the future could be replaced by such metaclasses.
• Qt as a C++ framework: History, Present State and Future (video), by Lars Knoll. Yes, Qt’s Chief Maintainer was invited to a C++ conference to talk a bit about Qt: where it comes from, where it is and where it’s going to.
• What Has My Compiler Done for Me Lately? Unbolting the Compiler’s Lid (video), by Matt Godbolt of godbolt.org‘s / Compiler Explorer fame. A very funny talk about what sorts of crazy optimizations compilers are able to achieve, as well as some “behind the scenes” of what powers the Compiler Explorer website.

Some other talks that I attended

In no particular order:

• constexpr ALL the things!, by Ben Deane and Jason Turner. If you like TMP and want to understand the full power of constexpr, this talk is for you. Fun and cleverly done.
• An allocator model for std2, by Alisdair Meredith. Allocators were a big deal at this year’s conference, with lots of talks for them. This one goes through the limitations of the current allocator model, and proposes fixes for a “new” allocator model (and since we can’t break the existing one, the new one has to go in the a new Standard Library namespace).
• C++ atomics, from basic to advanced – what do they do and what do they really do?, by Fedor Pikus. Yep, a talk about the atomics and the memory model.
• Design Patterns for Low-Level Real-Time Rendering, by Nicolas Guillemot. A good introduction on how modern GPUs work, and how we’re supposed to program them these days (also thanks to the “new” low-level graphic libraries such as Vulkan, D3D12 and Metal).
• Postmodern C++, by Tony Van Eerd. This wasn’t exactly a talk, this was a mystical experience. I’m afraid that the video won’t do it justice.
• Designing A Feature That Doesn’t Fit, by Patrice Roy. A talk about how the contribution process to the Standard works: even though you may think you’ve just got the best thing ever since sliced bread, things work differently in the Committee…
• 10 Core Guidelines You Need to Start Using Now, by Kate Gregory. A must watch introduction to the Core Guidelines, with ten examples that are applicable immediately.
• C++ Templates revisited, by Nicolai Josuttis. Some clever observations on modern template programming and metaprogramming, touching areas where C++17 is going to make a difference.
• A Soupçon of SFINAE, by Arthur O’Dwyer. Even MOAR template metaprogramming, this time about how to use various tricks to have SFINAE work in certain scenarios.
• Building C++ Modules, by Boris Kolpackov. C++ modules are “coming soon”: what are they, and what kind of support should come from the buildsystems to support them?
• The Asynchronous C++ Parallel Programming Model, by Hartmut Kaiser. I would definitely recommend to watch this great talk about building asynchronous computations in C++, by comparing the solutions available from the Standard Library, the capabilities from the HPX library, and how things are going to change with post-C++17 language/library features (e.g. coroutines).
• C++17 Parallel Algorithms, by Dietmar Kühl. Another take on the upcoming parallel algorithms, with quantitative analysis for several of them (depending on what they do). My gut feeling with the current state of them is that, while useful in certain scenarios, their API seems to be a bit too limited (cannot abort, no progress, always block the calling thread instead of returning futures, no control whatsoever on the threading…).
• Understanding the runtime behaviors of C++ programs using uftrace tool, by Honggyu Kim. uftrace is an application tracer, able to let you investigate what applications really do at runtime (for both profiling and debugging purposes). If you’re using Linux for developing C++, you should definitely add uftrace to your bag of tools.
• End-to-end Deadlock Debugging Tools at Facebook, by Kenny Yu. Some of the techniques used at Facebook to debug deadlocking problems in their massive codebase. Tricks include running ThreadSanitizer on “some” production machines (combined with replaying of historical data, for testing), gdb extensions to examine mutexes’ state and detect deadlocks, custom eBPFs tools and usage of folly::synchronized to avoid forgetting acquiring locks when accessing shared resources.
• Going Nowhere Faster, by Chandler Carruth. A very funny talk about low-level performance optimization (including taking live coding to another level by writing assembly code). The “surprise” part was that, thanks to how a modern CPU works, code with a branch worked faster than similar code without.

Effective Qt (2017 edition)

On Wednesday afternoon yours truly gave a talk about the current best practices to approach the core C++ classes in Qt, mostly containers and strings. You can watch the recording here on YouTube.

The slides (including bonus slides I didn’t have time to go through) are available here.

Lightning talks

I also delivered two lightning talks in the evenings:

• Solving a bug via lateral thinking (video, slides), describing my little journey at fixing a bug in QML’s JavaScript engine (I’ve blogged about it here); and
• F.21 (video, slides), a criticism to the F.21 Core Guideline, which I think should be amended from its current form.

This should be everything for now; I truly hope to get the chance to go CppCon once more next year (the dates are already announced!). Thanks for reading so far!