Cppcon 2023 Trip Report
NOTE: I’m writing this in the few days after CppCon 2023, so all the thoughts are still fresh in my head. Maybe I’ll change opinions after I’ve had time to digest things a bit more, but here’s my thoughts shortly after the conference.
So Many Talks
Let’s start with my list of the best few talks at the conference (of the ones I attended). I’ve picked these for a variety of reasons - some are very thought provoking, some taught me a load of new things, and some are just plain fun. The best talks hit all 3. I’ll recommend these talks to just about any C++ developer. These are sorted by date, rather than any particular good-ness, as I think they’re all interesting in their own regard.
- 10/3: Open Content: A Grab-Bag of Useful Oddities: My favorite talk from the first couple of days. Lots of random fun tidbits about C++, like how bitfields can have 0-width fields, abusing macros to get more
constexprvalues, abusing attributes to put python in C++, etc. Not recorded, but slides available. I’ll have to keep an eye out for Ben’s future talks.
- 10/4: Coping With Other People’s Code: A decidedly non-technical talk (0 lines of code, I think?), but Laura is an incredible speaker with a ton of stage presence, and delivered a number of interesting thoughts on picking and choosing your battles, work-life balance, etc. Don’t drop the baby. Should be on YouTube soon, with slides already out.
- 10/5: Evolution of a Median Algorithm: I might be biased because Pete works at Meta, but this was just a nice, 30 minute talk going over how (or a standard library developer) might go from a simple (
int-only) implementation of
medianto a production-ready, efficient, fully generic implementation. He also suggested that it might be time to consider
- 10/6: Robots Are After Your Job: Andrei’s talks are always interesting, and this year was no exception. He talks about a better
std::binary_searchimplementation, explains that ChatGPT is a good way to do the “boring stuff” (aka implementation, testing, pictures, etc), and that you should focus your time on the interesting parts. Slides not yet available, but they’ll be here.
Talks that didn’t quite make my top list, perhaps because they’re a little more specialized (and thus not necessarily immediately applicable to most C++ developers), or because they’re not the most interesting to watch, but still contain a ton of good content to learn from later, or something else.
- 10/2 Open Content: C++ Conversation: Storage Durations, Lifetimes, and Puzzlers: No slides unfortunately, as this material is taken from Jason’s professional trainings (otherwise it would’ve made the first list). The first chunk was a bit basic / review, but I did learn a decent amount about lifetime rules for
thread_localtoward the end. My guess is that this material is also somewhat repeated in Jason’s C++ puzzlers book.
- 10/2 A Long Journey of Changing std::sort Implementation At Scale: A neat production story about how Google updated their implementation of
std::sort. The interesting bits were about the various bugs they found, e.g. around stability, floating point comparisons, strict week ordering issues, etc. They updated a few things in Clang / LLVM and provide recommendations on flags to enable to try to catch these bugs in your own codebase. Amusingly, they said they found exactly 0 instances of people using mismatched iterators in
std::sort, even though that’s one of the motivations for C++ ranges. Slides here (with a cool GitHub pages link).
- 10/3: std::linalg: Linear Algebra Coming to Standard C++: A bit more niche, but I thought this presentation contained the best introduction to
std::mdspanI’ve seen yet. It didn’t occur to me to use CTAD to simplify constructing the various
std::mdspanobjects, but that definitely makes using it easier. The
std::linalgpart is cool too ofc, with official support for the battle-hardened BLAS interface. Unfortunately, this seems primarily intended for high level host-side multiplications, and there doesn’t seem to be a way to get support for in-warp Tensor Core multiplications (with matrices split across registers). Slides.
- 10/4: Shared Libraries in Windows, in Linux, and yes - in C++: Not the most riveting presentation style-wise, but it was loaded with new (to me) information on how shared libraries, loading, a little linking, etc work. It felt a bit like a firehose, but I’m still recommending it here as it’s the most comprehensive resource I’ve found on this topic to date, and I’ll definitely come back to the slides if I ever need to worry about dynamic libraries.
- 10/5: Cooperative C++ Evolution - Toward a Typescript for C++: I’ve put Herb’s keynote here since it doesn’t directly relate to C++, but I really like the idea of pushing for a TypeScript-like C++-compatible language. He started talking about C++2 last year, and I’m glad to see it’s still progressing. The interesting parts here are identifying that there’s a small, safe subset of C++ that’s just as expressive and efficient, and that there’s a “lost decade” if you try to solve these same problems if you break compatibility with the existing stuff (a la Python 2-> 3, Rust, etc). Slides.
- 10/5: Tracy: A Profiler You Don’t Want to Miss: The speaker showed off a really cool profiler, developed by some random dude on the internet, which excels at remote debugging and real-time visualization using ImGui. The presenter had a ton of slides, with a “choose your own adventure” thing towards the end. There’s a few caveats with the software, e.g. it’ll always send profiling information if compiled in (and buffer if there’s no visualizer hooked up), so it can use a ton of memory, but overall it seems worth trying. Some coworkers have apparently used it before and found that Nsight Systems is a generally more powerful for the types of metrics it can collect (e.g. CPU perf counters, and CUDA integration), but Tracy might still make sense for remote debugging over slow connections (since you can control exactly what you measure), and for some of the more specialized features, e.g. mutex tracking. Check the slides, there’s a ton of extra material not covered in the talk.
All The Talks I Attended
Here’s everything I was able to attend. I missed a few of the evening open content sessions because of various dinner plans, and a couple of the morning ones because I slept in toward the end of the conference. I also ended up falling asleep for a little bit in the ~3pm sessions so my recollection of those isn’t fantastic.
- 10/2: Delivering Safe C++
- 10/2: Customization Methods: Connecting User and Library Code
- 10/2: Open Content: C++ Conversation: Storage Durations, Lifetimes, and Puzzlers
- 10/2: A Long Journey of Changing std::sort Implementation At Scale
- 10/2: std::simd: How to Express Inherent Parallelism Efficiently Via Data-parallel Types
- 10/2: Cache-friendly Design in Robot Path Planning
- 10/2: Safety & Security for C++
- 10/3: A Grab-Bag of Useful Oddities
- 10/3: File IO for Game Developers: Past, Present, & Future
- 10/3: Libraries: A First Step Toward Standard C++ Dependency Management
- 10/3 Open Content: Jason Turner std::move
- 10/3: Expressing Implementation Sameness & Similarity in Modern C++
- 10/3: std::linalg: Linear Algebra Coming to Standard C++
- 10/3: BehaviorTree.CPP: Task Planning for Robots & Virtual Agents
- 10/3: Fireside Chat with the Committee
- 10/4: A Journey into Non-Virtual Polymorphism
- 10/4: Coping With Other People’s Code
- 10/4: Talks That Don’t Fit Elsewhere (part 1)
- 10/4: Shared Libraries in Windows, in Linux, and yes - in C++
- 10/4: Lightning Talks
- 10/5: Cooperative C++ Evolution - Toward a Typescript for C++
- 10/5: Generative C++
- 10/5: Single Producer Single Consumer Lock-free FIFO From the Ground Up
- 10/5: Advanced SIMD Algorithms in Pictures
- 10/5: Evolution of a Median Algorithm
- 10/5: Tracy: A Profiler You Don’t Want to Miss
- 10/5: Lightning Talks
- 10/6: Optimizing Away Virtual Functions May Be Pointless
- 10/6: Designing Fast and Efficient List-like Data Structures
- 10/6: Abstraction Patterns for Cross Platform Development
- 10/6: Better Code: Contracts
- 10/6: Behavioral Modeling in HW/SW Co-design Using C++ Coroutines
- 10/6: Robots Are After Your Job
Talks I Wanted To Attend (and should watch on YouTube)
Everything else that looked interesting to me on the schedule, which I’ll probably try to watch later on YouTube when it comes out in 6 months. Most of these are here because they conflicted with stuff above. In many of the conflicting times, my decision criteria was to pick the one that’d likely be more immediately applicable, and to leave the more forward-looking stuff (e.g. stuff on ranges, which doesn’t work with CUDA 12.0 iirc) for the future.
- 10/2: Expressive Compile-time Parsers
- 10/2: Finding Your Codebase’s C++ Roots
- 10/2: Thinking Functionally In C++
- 10/2: Effective Ranges: A Tutorial for Using C++2x Ranges
- 10/2: “Distributed Ranges”: A Model for Building Distributed Data Structures, Algorithms, and Views
- 10/3: Express Your Expectations: A Fast, Compliant JSON Pull Parser for Writing Robust Applications
- 10/3: Exceptionally Bad: The Story on the Misuse of Exceptions and How To Do Better
- 10/3: Open Content: Lockless Atomic Multi Producer Multi Consumer Queue
- 10/3: Open Content: Improving fleet-wide efficiency by addressing common bad performance patterns
- 10/3: Lock-free Atomic Shared Pointers Without a Split Reference Count? It Can Be Done!
- 10/3: The Au Library: Handling Physical Units Safely, Quickly, and Broadly
- 10/3: Leveraging a functional approach for more testable and maintainable ROS2 code
- 10/3: Open Content: Towards std::quantity
- 10/4: Open Content: Safe Arithmetic: Enforce Integer Operation Correctness at Compile-time
- 10/4: Applicative: The Forgotten Functional Pattern
- 10/4: Is std::mdspan a Zero-overhead Abstraction?
- 10/4: Object Introspection: A Revolutionary Memory Profiler for C++ Objects
- 10/4: Plug-in Based Software Architecture for Robotics
- 10/4: Robotics at Compile Time: Optimizing Robotics Algorithms with C++’s Compile-Time Features
- 10/4: Symbolic Calculus for High-performance Computing From Scratch Using C++23
- 10/5: Open Content: Groov: Deigning a generic hardware register abstraction library
- 10/5: Monads in Modern C++
- 10/5: Coroutine Patterns and How to Use Them: Problems and Solutions Using Coroutines In a Modern Codebase
- 10/5: Open Content: Talks That Don’t Fit Elsewhere (part 2)
- 10/5: Open Content: Undefined Behavior: The Compiler’s Perspective
- 10/5: Can Data-oriented-design be Improved?
- 10/5: Regular, Revisited
- 10/6: Open Content: Using Fixed Precision Accumulators for Better Reproducibility
- 10/6: Iteration Revisited: A safer iteration model for C++
- 10/6: Building Effective Embedded Systems: Architectural Best Practices
- 10/6: Writing Python Bindings for C++ Libraries: Easy-to-use Performance
- 10/6: Great C++ is_trivial
There were a couple common themes / observations that stood out to me throughout the conference.
The most pervasive theme, by far, was safety. We had an entire keynote (Bjarne’s opening keynote), an entire evening session (the first evening), and part of Herb’s keynote (on 50x safer C++, as denoted by CVE count) dedicated to pushing for better safety. A number of the questions in the committee fireside chat (second evening) also touched on safety. There were even a few normal talks that I thought were largely motivated by safety, e.g. Better Code: Contracts and The Au Library: Handling Physical Units Safety, Quickly, and Broadly.
I do appreciate this trend overall. Clearly, the overall C++ community is a little shaken by the recent proliferation of Rust, but as John Carmack says (and Herb said, phrased differently), competition is A Good Thing. It’s incredibly easy to do something in C++ which will cause undefined behavior, read from / write to invalid memory, cause a data-race or a use-after-free, etc, all of which are problems that I think Rust doesn’t have. In last year’s keynote, Bjarne talked about recommendations from NIST to use languages other than C++ (a list which happens to include Rust), about how even if he doesn’t agree with the premise (because there are plenty of other ways to footgun than just memory safety), NIST is right about needing to improve safety in C++. I’m glad to see he (and many other committee & community members) have continued to push on this theme in their own various ways, with features like contracts, type-safe numerics libraries, C++-compatible safe subsets (C++2), etc.
Herb (quoting Carmack) made the point that breaking compatibility results in a “lost decade”, where, even in the most generous case of the new system being functionally superior to the old system (e.g. Python 3 vs 2, or msvc 6 vs 10, etc), it’ll still take about a decade to migrate everyone over. There’s a ton of history behind C++, which makes change difficult, but is also C++’s “superpower”, and has so far been the reason nothing has been able to displace C++. There’s been a ton of contenders in the past, of course, but this time, with Rust, things seem to be different. Only time will tell which language ends up winning the systems programming battle, but I know that in either case, we (programmers) will end up with something better, safer, and easier to use. Competition is good.
P.S. We noticed that Bjarne really doesn’t want to say the word “Rust”. There was even a fireside question which specifically asked to compare Rust and C++, and Bjarne only talked about C++ without mentioning Rust once. He’s the creator of C++, so I certainly can’t blame him, but once we noticed that he went out of his way to avoid saying Rust, we couldn’t help but continue to notice. Nothing wrong with it, I just thought it was funny.
As I learned in the “Hallway Track”, apparently the tooling track had the highest number of submissions. I didn’t get an actual number, but it was higher than the 23 that the Robotics track received. Daisy also mentioned during the banquet that there was a 30% overall acceptance rate. Evidently, lots of people care about tooling. This is good!
We had a whole keynote on tooling, which talked about a “Common Package Specification” (I think from this paper), and how it’s easy to generate with CMake thanks to new integrations, but it wasn’t really clear to me what the takeaway was supposed to be. I think the goal was to just get everyone to start using CPS to detail all of the individual parts of their software packages, which should then allow the hundreds of various packaging systems (e.g. apt, vcpkg, Meson, Conan, Conda) to reuse the data in their own way? I suppose trying to get everyone to use a common specification, but leave the overall packaging details unspecified, is a way to avoid standard fragmentation though. I’m sure this talk was more appealing to folks who directly deal with a variety of packages on a daily basis (e.g. the Bloomberg folks, with 30k+ CMake libraries), but perhaps since I’ve been spoiled by a monorepo for most of my professional career, this didn’t really click for me.
The higher level takeaway of the tooling talks is obvious though - dependency management in C++, as compared to any other modern language like Python, Rust, Go, etc, sucks, and we need to do better. Unfortunately, I think this is what prompted the proliferation of individual packaging / dependency systems (as listed above), with each individual team attempting to build their own bespoke system to solve a specific set of problems better than any existing tools out there. Perhaps what we really need is a heavy-handed approach from the C++ standards committee mandating a single package management solution. I realize this is not how the C++ committee operates (and they’ve often said packaging is outside the scope of the committee’s work anyway), but standards don’t need to be good, they just need to be universal.
For something slightly less defeatist – the Object Introspection: A Revolutionary Memory Profiler for C++ Objects talk was supposedly really good (and I’m sad I missed it), and of course the Tracy: A Profiler You Don’t Want to Miss talk turned out to be one of my favorites, as mentioned above. Outside the realm of package management (where I think we need one package manager to rule them all), I’m glad to see the proliferation of different tooling, each with its own niche uses, and features that can be cribbed for other applications. My differing opinions on these two areas (specialized tooling vs package management) stem from the ubiquity - package management is something you need almost immediately, and quite regularly, as soon as you try to integrate any 3rd party code (or even just nicely separate out your own 1st party code), but you’re able to put off things like profiling, static analysis, etc. until much later in projects (even if you shouldn’t necessarily do so). In other words, package management is on the
unhappy path for programs, and we should strive to make that as easy as possible, whereas the rest of the tooling is typically only reached for if something is going wrong (e.g. code crashes, performance issues, memory bloat, etc.).
Probably not soon …
I’ve enjoyed the last 2 years of CppCon, but at the moment, I don’t think I’ll be going back for Round 3 in 2024. Maybe I’ll be back in 2025 or 2026, as C++26 is getting closer to release. In no particular order, here’s a few brain-dumpy reasons why:
- Socializing (hallway track) is hard - I ended up spending most of my time with coworkers I knew already
- Expensive (and more every year), especially for a conference of its size (< 1000 people, SIGGRAPH is $850 for 11k people)
- Commuting (by car, since there didn’t seem to be any good public transportation) to the conference is also expensive ($30 for parking), plus Wi-Fi wouldn’t be included for you (nor would lunch credits)
- Minimal vegetarian food options at the resort. Even with the lunch credits, I ended up just getting the hummus option most days, and dinner was not worth having at the convention center at all. Last year, you could at least get fresh pizza for lunch, but since the Grand Lodge was closed, that option seemed to be gone, and you could only get (decidedly worse) pre-made pizza for dinner.
- Very little graphics / HPC / CUDA related. There’s some talks on SYCL / Kokkos / etc., but I was hoping for more talks from e.g. game engine dev and HFT folks on low latency.
- Everything’s posted on YouTube later anyway (though this was definitely a positive as a non-attendee when I was a student).
- Hard to justify a week off for a conference like this when I often can’t immediately apply the things I’m learning (since we’re typically behind in our C++ versions).
- My work doesn’t nicely translate into something I can give a talk on at CppCon, so I end up spending 5 days attempting to absorb material. I felt more engaged on Wednesday and early Thursday when I had found out I got accepted to a lightning talk, and was able to work on that in downtime between sessions. Perhaps I’d enjoy future conferences more overall if I was also preparing my own 30-min / 60-min talk at the same time.
- long conference (8am to 10pm), hard to take in the material on the last day or two
- Not enough talks focused on experts (maybe C++Now?) - though this’d still probably be language experts, not domain experts.
- Presenters banquet didn’t seem worth the ~$200 extra it cost on the registration (food-wise), especially for the vegetarian option. I would’ve also appreciated assigned seating (ideally based on previously stated topics of interest, or based on talks you’ve attended, etc), but I can see how finding a good algorithm for this would be quite challenging. The seating also ended up unbalanced, with some tables having only a few people (mine had 3 presenters + me) and some tables being full (2 presenters + ~8 people).
But you should!
Some reasons you should go though (at least once):
- It’s a nice way to timebox getting through (almost) all of the CppCon content you’d be interested in, rather than watching it piecemeal over the next 6 months as talks are released one at a time (and you also get early access).
- You get to socialize with other C++ professionals, committee members, etc., assuming you’re that type of person.
- As Laura Savino mentioned in her talk, you (as an introvert) could give a talk and force people to self-select and talk to you afterwards!
- I enjoyed giving a lightning talk, and look forward to seeing myself on the CppCon YouTube channel later.
- Meet committee members and learn how to get involved with the C++ standardization process.
- Enjoy the venue recreational things, primarily the large hot tub and (heated) lazy river. There’s also a minigolf course, basketball, gym, etc, but the hot tub and lazy river are the highlights. After this year, the Grand Lodge will probably open again as well, which should provide nice views.
- Attending the various C++ classes, which are all largely aimed at C++ beginner-ish folks, either having never programmed in C++ (but in another language), or having used C++ a long time ago and wanting to catch up. There’s a few exceptions though, like Walter Brown’s templates class (which I took last year and enjoyed) that definitely cater to intermediate+ programmers.
- Use it as an excuse to take an extra day before / after the conference to visit some fun sites in and around Denver. Go hiking or skiing or climbing or something if you’re an outdoors person, or try flying (discovery flight, or rent a plane if you have your PPL), or visit an art exhibit like Meow Wolf, or visit a nice museum like Wings Over The Rockies.
- Enjoy some new cuisine that you may not be able to find in your (small) city, like this fantastic Nepalese place we found.
- Stumbling into friends / colleagues you weren’t expecting. Admittedly, you’ve got a better shot at this at a larger conference (or at least, you can be more deliberate about it), but I’d be remiss if I didn’t mention me reconnecting with a friend from high school I hadn’t seen in nearly a decade, just randomly on the escalators on the first day’s reception.
For now, for my target of 2 conferences a year, I’ll plan on attending SIGGRAPH and then either one of the other vision conferences like CVPR, ICCV, ECCV, etc., or finally try a robotics conference like IROS, ICRA, or RSS. SIGGRAPH is in Denver next year anyway, so at least I’ll still get to enjoy the city :).
TODO (next time)
A few things I wish I had done differently, either this time or the one before:
- Taken more photos - it looks like the only photos on my phone from the conference itself are of receipts, rather than of e.g. the venue, the CppCon photo background, etc.
- Put all my notes into a single document? Might’ve been easier to view them chronologically that way, and definitely would be easier to just share at the bottom of this doc.
- More to come, maybe?