CppCon, The C++ Conference

I wrote a CppCon trip report. (The reason it took a while is that I was waiting for it to be published internally at work first. At least I got ahead of most of the YouTube uploads)

CppCon, The C++ Conference 2024 - David Olsen: "Back to Basics: Generic Programming in C++" youtu.be/0_0HsEBsgPc Generic programming, better known in C++ as templates, can feel daunting and overwhelming to those unfamiliar with the paradigm. This Back to Basics talk will explain the foundations of C++ templates, covering the language rules that must be understood in order to work with template code effectively. I will provide some guidelines for how to use templates and how to write templates. While you won't come away from this being an expert in template metaprogramming--that's an impossible task for any hour-long presentation--you should have a strong enough foundation that you can correctly maintain template code while you develop your expertise in generic programming over time. This talk is designed for those who are learning C++ and want an introduction to templates and generic programming. It will also be useful for experienced C++ developers who haven't mastered templates yet and want to brush up on their understanding of how templates work. --- David Olsen has three decades of software development experience in a variety of programming languages and development environments. For the last seven years he has been the lead engineer for the NVIDIA HPC C++ compiler, focusing on running standard parallel algorithms on GPUs. He is a member of the ISO C++ committee, where he was the champion for the extended floating-point feature in C++23.

CppCon, The C++ Conference 2024 - Daniel Marjamaki: "Building Cppcheck - What We Learned from 17 Years of Development" youtu.be/ztyhiMhvrqA Cppcheck has been evolving for 17 years, guided by a clear philosophy: minimal false positives and ease of use. This presentation will share the insights we've gained during its development. Our approach to easy configuration is a double-edged sword, providing user-friendly setup while occasionally leading to lower recall. We maintain a strict definition of false positives, ensuring the tool does not warn about well-written, functional code. This principle, while challenging, drives us to fix rather than suppress false positives. A core philosophy of Cppcheck is to learn from mistakes. When an issue is identified, we strive to implement checkers to prevent similar mistakes in the future. The open-source community plays a crucial role in Cppcheck's evolution. We collaborate to enhance the tool, scanning large codebases like Debian's source code to identify inconsistent or dangerous code and measure false positives. We also explore how abstractions, compiler annotations, and contracts can improve SCA tools' precision and performance. This talk will provide a comprehensive look at the lessons learned and the continuous improvement of Cppcheck. --- Daniel Marjamäki is a software engineer from Sweden and the author of Cppcheck, a static analysis tool for C/C++ code. He created Cppcheck to help developers find bugs and improve code quality. Thanks to his work, Cppcheck has become a widely used tool in the programming community. Marjamäki is known for his contributions to improving software development practices.

CppCon, The C++ Conference 2024 - Alon Wolf: "Compile-Time Validation in C++ Programming" youtu.be/jDn0rxWr0RY C++ is often criticized for its lack of inherent memory safety, but the spectrum of potential program validations extends far beyond just memory concerns. This talk delves into the necessity of early validation, emphasizing the benefits of compile-time checks in C++. By leveraging compile-time validation, developers can catch errors and enforce constraints before the code is even executed, enhancing both safety and correctness. A functional programming approach to compile-time validation will be discussed, highlighting its benefits and demonstrating its application in ensuring code correctness. Moreover, the talk will delve into the realm of compile-time unit tests, showcasing how they enable developers to validate code behavior at compile time, paving the way for more efficient debugging and maintenance. Exploring advanced features, we'll discuss existing compile-time techniques to implement lifetimes, borrow checker, and other validation rules by leveraging template metaprogramming for memory safety and how they can be improved with the upcoming C++26 reflection proposal. Additionally, we will review language extensions and compiler-specific features that augment compile-time validation capabilities. Finally, the talk will cover the role of static analysis tools in detecting potential issues early in the development process, thus complementing compile-time techniques. Attendees will gain a comprehensive understanding of the various strategies available for enhancing program reliability through compile-time validation in C++. --- Alon Wolf is a Senior Software Engineer at Medtronic specializing in 3D and computer graphics with a passion for high performance. He has developed many custom simulation and rendering engines for different platforms using modern C++. He also writes a C++ technical blog and participates in game jams.

CppCon, The C++ Conference 2024 - Kevin Carpenter: "Back to Basics: Almost Always Vector" youtu.be/VRGRTvfOxb4 Are you a fresh face in the world of C++ development, or perhaps you've got a bit of experience under your belt? Have you ever stopped to marvel at just how often std::vector pops up? It's a thing of beauty, a structure you can just keep piling data into, effortlessly sort, search, insert, and delete from. But do you know the price you pay for all this convenience? What about when you need to expand the structure? Or when you're on the hunt for something specific? Ever dabbled with custom predicates to dynamically tweak your data? With a plethora of data structures at our disposal in the standard library, it's a head-scratcher why std::vector seems to steal the show. Join this talk to unravel the mystery behind why we almost always opt for std::vector, and learn how to wield it with maximum efficiency. --- Kevin Carpenter, an experienced Software Engineer, excels in crafting high-availability C++ solutions for Linux and Windows, with expertise in transaction software, financial modelling, and system integration. As a Lead Project Engineer, he ensures secure, high-speed credit card transactions. In his prior position, he played a lead role in developing an interest rate risk model for large credit unions, enhancing legacy code, and optimizing ERP data integration. Kevin actively engages in the C++ community, volunteering at conferences like ACCU, CppCon, C++ on Sea, and SwiftCraft, where he holds key positions such as Speaker Liaison and Volunteer Coordinator/Chair. His diverse contributions to the C++ community showcase his commitment to excellence and drive for collaborative growth, leaving a lasting impact in the tech world.

CppCon, The C++ Conference 2024 - Eduardo Madrid: "C++ Relocation - How to Achieve Blazing Fast Save and Restore and More!" youtu.be/LnGrrfBMotA Programming normal C++ leads to the use of dynamic memory, pointer chasing, and other issues that zap performance. Because there haven’t been practical solutions to those problems we seldom discuss them, creating the impression that they are unavoidable. Fortunately, the same C++ that binds us frees us to devise techniques centered around the concept of “relocatability” to solve those issues. We will explain what relocatability is and how to achieve it. Consider the example of runtime polymorphism. You may want to have interfaces and implementations of interfaces. If your object refers to a “polymorphic” member, it normally cannot be implemented as a concrete sub-object, only as a base class pointer that points to a dynamically allocated instance of a derived class. This leads to millions of small objects dispersed throughout memory, all referencing one another. This is already very expensive and other issues around object layout makes things worse. One presenter witnessed 7% of Google Search Qrewrite CPU spent on dealloc, which must chase pointers to finish! When we want to save the state of such programs, we must traverse those complex object graphs and encode them in complex file formats: serialization is required. Restore is further complicated by needing millions of small allocations which are often ephemeral. In general, working with data architected in this way is error prone and has abysmal performance. Our alternative to these complex object graphs is to lay out program data according to program design objectives, in our case allowing object moves. This is the essence of relocation. The set of techniques we will share with you is complete. Now that we can represent program state as simple, relocatable data, save and restore is simply memory mapping buffers. For runtime polymorphism, we can use “Type Erasure”, the Design Pattern behind `std::function`, tailored for relocatability. Our Type Erasure performs better than normal polymorphism. We get better performance, we have no allocations, no deallocations, and no pointer chasing; resulting in happier programming. For other issues we get benefits of the same magnitude. We will explain both well known and novel relocation techniques. The novel techniques have required the formulation of Generic Programming concepts including what we call “Value Manager”. We are presenting these for the first time. --- Eduardo Madrid has been working for many years on financial technologies, automated trading in particular, and other areas where performance challenges can be solved in C++. He contributes to open source projects and teaches advanced courses on Software Engineering with emphasis in Generic Programming

To all of you who didn't attend CppCon, The C++ Conference - for whatever reason - and love both C++ and low level implementation geekiness in all its glory, Khalil Estell has you covered. Boy does he ever have you covered 😍 https://lnkd.in/dREAg9Wn

CppCon, The C++ Conference 2024 Dave Steffen "Back to Basics: Unit Testing in C++" youtu.be/MwoAM3sznS0 Unit Testing is a big, complicated subject. With good advice coming in from books, conference talks, and blog posts beyond count, it's a daunting topic even for experienced developers. Can we make the subject more approachable? Yes we can. If we look a little deeper, there are some fundamental principles behind the advice. Further, these principles seem to belong to a small number of "domains", each addressing a very different aspect of unit testing and software development. For example, "Test error conditions separately", "Tests should be easy to read", and "Write the unit tests first" are all great advice, but each is aiming for a very different goal. In this talk, we'll survey these domains of unit testing practice, identify some of the basic practices involved in each, and put the larger discussion of unit testing into a more useful context. We will also see how some unit testing practices enhance or conflict with others, and how these controversies reveal deep philosophical questions that have real consequences for how we go about the day-to-day activity of testing our code. --- Dave Steffen completed his Ph.D. in theoretical physics at Colorado State University in 2003, and promptly changed course for a career in software engineering. He has worked primarily in defence and aerospace, and is currently a technical lead at SciTec Inc.'s Boulder office. For reasons unknown, he has turned out to be the expert, champion, and occasional street-corner evangelist for unit testing at most of the companies he has ever worked at.

It's been a month, but I'm still grateful for the enthusiasm you were able to convey. Thank you! Buona strada!

CppCon, The C++ Conference 2024 - Jeff Garland: "C++26 Preview - The Smaller Features" youtu.be/xmqkRcAslw8 Join us as we explore the cutting-edge advancements of C++26, covering both small tweaks and large-scale additions. Despite C++23 not being officially released from ISO, the C++ committee is already two-thirds through the design phase of C++26 - with less than a year left until feature freeze. In this session, we'll dive into the new features slated for inclusion in C++26, with a focus on those already present in the working draft. And particularly those already making their way into compilers and standard libraries. For sure we'll cover contracts, reflection, format, and many smaller improvements. But given the large amount of material available, we'll customize the content based on audience requests. We'll cover a variety of topics briefly, but with enough depth to get you started. From enhanced language capabilities to powerful library additions, this session will equip you with the knowledge to leverage these upcoming features in your projects. The session will be up to date with the latest from the summer C++ Committee meeting. --- Jeff Garland has worked on many large-scale, distributed software projects over the past 30+ years. The systems span many different domains including telephone switching, industrial process control, satellite ground control, ip-based communications, and financial systems. He has written C++ networked code for several large systems including the development high performance network servers and data distribution frameworks. Mr. Garland’s interest in Boost started in 2000 as a user. Since then he has developed Boost.date_time, become a moderator, served as a review manager for several libraries (including asio and serialization), administered the Boost wiki, and served as a mentor for Google Summer of Code. Mr. Garland holds a Master’s degree in Computer Science from Arizona State University and a Bachelor of Science in Systems Engineering from the University of Arizona. He is co-author of Large Scale Software Architecture: A Practical Guide Using UML. He is currently Principal Consultant for his own company: CrystalClear Software, Inc and assistant chair of the Library Working Group for the C++ standards committee.