CppCon 2024

Back to all conferences

Table of Contents

• Concurrency (1 videos)
• Developer Experience (37 videos)
• Performance Engineering (6 videos)

Concurrency

Introduction to Wait-free Algorithms in C++ Programming - Daniel Anderson - CppCon 2024 The talk introduces wait-free algorithms, which guarantee that all threads make progress, in contrast to lock-free algorithms where at least one thread makes progress. The speaker demonstrates the design of a wait-free counter algorithm using atomic operations and a helping mechanism to ensure collaborative progress among threads. back to top

Developer Experience

C++ Game Development - Techniques to Optimise Multithreaded Data Building - Dominik Grabiec - CppCon The talk discusses techniques to optimize multi-threaded data building in game development, focusing on strategies such as keeping threads busy, caching data, optimizing sorting of large arrays, and avoiding locking threads using job systems. The speaker shares insights from their experience in the AAA game industry and provides practical solutions to common challenges encountered during the data building process. back to top

Back to Basics: Concepts in C++ - Nicolai Josuttis - CppCon 2024 This talk explores the powerful new feature of Concepts in C++20, demonstrating how they can improve the quality and maintainability of generic code by providing a way to specify and enforce requirements on template parameters. The speaker delves into the syntax and semantics of Concepts, showing how they can be used to solve common problems in C++ programming and discussing the interactions between Concepts and other language features like type traits and the ranges library. back to top

C++ Game Development - Many Ways to Kill an Orc (or a Hero) - Patrice Roy - CppCon 2024 This talk explores various approaches to game development in C++, including the use of inheritance, templates, and variants, to create a simple game where heroes and orcs fight each other. The speaker discusses the trade-offs between different design choices, highlighting the importance of thinking carefully about the implementation before writing code. back to top

C++ Reflection Is Not Contemplation - Andrei Alexandrescu - CppCon 2024 The talk discusses the importance of code generation in C++ reflection, as opposed to just contemplation. It explores different approaches to code generation, including token strings, and highlights the potential for using reflection to customize and adapt existing types and APIs in a structured and careful way. back to top

10 Problems Large Companies Have Managing C++ Dependencies and How to Solve Them - Augustin Popa The talk discusses 10 problems large companies face in managing C++ dependencies and provides solutions, including building from source, using binary caches, managing versions with baselines, leveraging open-source package managers, and centralizing common tasks. The speaker also covers topics like security vulnerabilities, software bill of materials, and making large changes to development environments in large organizations. back to top

Taming the Filter View in C++ Programming - Nicolai Josuttis - CppCon 2024 The talk discusses the challenges and surprises encountered when using the C++ filter view, highlighting the performance implications and the need to carefully consider the behavior when iterating over and modifying elements in a filtered collection. The speaker proposes potential design alternatives and calls for community engagement to address these issues and improve the overall experience of using filter views in C++ programming. back to top

Fast and Small C++ - When Efficiency Matters - Andreas Fertig - CppCon 2024 The talk discusses efficient C++ string implementations, focusing on techniques like the empty base class optimization, compressed pair, and the small string optimization. The speaker presents and compares various string implementations from different C++ standard libraries, highlighting the trade-offs between space, time, and standard compliance. back to top

What’s New for Visual Studio Code: Performance, GitHub Copilot, and CMake Enhancements - CppCon 2024 Visual Studio Code has introduced several performance improvements, including faster symbol search, faster code intelligence, and faster startup times. Additionally, the GitHub Copilot feature has been enhanced with smarter suggestions, an integrated chat interface, and improved context handling, as well as new extensibility options for customizing the Copilot experience. back to top

Leveraging C++20/23 Features for Low Level Interactions - Jeffrey Erickson - CppCon 2024 The talk discusses leveraging C++20/23 features for low-level hardware interactions, highlighting the advantages of C++ over C, such as lifetime management and type safety. The speaker presents techniques for safely bridging the gap between C++ and C code, as well as exploring ways to fully embrace C++ in bare-metal environments. back to top

So You Think You Can Hash - Victor Ciura - CppCon 2024 The presentation explores the principles of designing effective hash functions, emphasizing the separation between the hash algorithm and the type design. It showcases techniques for hashing complex data structures and provides insights into practical implementation strategies, enabling flexible experimentation and benchmarking. back to top

Common Package Specification (CPS) in Practice: Working Implementation in Conan C++ Package Manager The presentation explores the practical implementation of the Common Package Specification (CPS) in the Conan C++ package manager. It showcases how CPS files can be generated from existing packages, used to build applications across various build systems, and discusses the challenges and future work involved in further advancing the CPS ecosystem. back to top

Reusable Code, Reusable Data Structures - Sebastian Theophil - CppCon 2024 The talk discusses techniques for writing reusable code in C++, emphasizing the importance of generalization and customization points over inheritance and runtime polymorphism. It also cautions against the overuse of language features like variants, which can lead to the inadvertent creation of polymorphic types and increased maintenance complexity. back to top

C++ RVO: Return Value Optimization for Performance in Bloomberg C++ Codebases - Michelle Fae D'Souza The talk covers the concept of Return Value Optimization (RVO) in C++, including its benefits, anti-patterns that prevent it, and how to leverage it for performance gains. The speaker provides interactive examples and hands out stress balls to engage the audience, highlighting the importance of understanding and applying RVO in C++ codebases. back to top

Back to Basics: Function Call Resolution in C++ - Ben Saks - CppCon 2024 The talk covers the intricacies of function call resolution in C++, including overloading, name lookup, default function arguments, and function templates. The speaker provides practical examples and advice on how to design flexible and easy-to-use interfaces by leveraging these language features. back to top

Back to Basics: Debugging and Testing in C++ Software Development - Greg Law & Mike Shah - CppCon 24 The talk discusses the importance of testing and debugging in C++ software development, emphasizing the need for a comprehensive testing strategy, including unit tests, integration tests, and system tests. It also highlights the challenges of debugging, such as the time elapsed between the bug and its detection, and the deterministic nature of the bug, and provides various tools and techniques to assist with the debugging process. back to top

Building Cppcheck - What We Learned from 17 Years of Development - Daniel Marjamäki - CppCon 2024 The presentation covers the 17-year development journey of the Cppcheck static analysis tool, highlighting the challenges, design decisions, and lessons learned along the way. The speaker discusses the tool's evolution, including its focus on finding undefined behavior and real bugs, its compiler-agnostic approach, and the ongoing efforts to improve its performance and language support. back to top

C++ Reflection Based Libraries to Look Forward To - Saksham Sharma - CppCon 2024 The talk discusses how C++ reflection-based libraries can improve developer experience and enable new use cases, such as Python bindings, ABI hashing, and a 'virtual any' type. The speaker demonstrates how the proposed C++ reflection feature can be leveraged to create powerful and user-friendly libraries that abstract away the underlying complexity of reflection. back to top

Back to Basics: Almost Always Vector - Kevin Carpenter - CppCon 2024 The talk discusses the advantages of using std::vector over traditional C-style arrays, highlighting its memory management, iterators, and algorithms. The speaker emphasizes that std::vector is the almost always the preferred container for 80% of use cases, especially for new developers, due to its efficiency, flexibility, and automatic memory management. back to top

Compile-Time Validation in C++ Programming - Alon Wolf - CppCon 2024 The talk discusses the importance of compile-time validation in C++ programming, highlighting various types of software validation, including memory safety, performance, and business logic. The speaker presents different techniques and tools, such as compile-time unit testing, function composition, and stateful meta-programming, to enable comprehensive validation at the compile-time stage. back to top

C++26 Preview - The Smaller Features - Jeff Garland - CppCon 2024 This talk provides a preview of the smaller features coming in C++26, including improvements to debugging, structured bindings, templates, string processing, containers, and more. The speaker covers a wide range of incremental changes and enhancements that aim to improve the day-to-day programming experience in C++. back to top

Back to Basics: Generic Programming in C++ - David Olsen - CppCon 2024 This talk provides a comprehensive introduction to generic programming using C++ templates, covering key concepts such as substitution, instantiation, template parameter constraints, and specialization. The speaker emphasizes the importance of writing simple, user-friendly templates and avoiding overly complex overload sets to ensure maintainability and ease of use. back to top

Back to Basics: Unit Testing in C++ - Dave Steffen - CppCon 2024 The talk discusses the importance of unit testing in C++ development, covering the basics of unit testing, how to write effective unit tests, and the role of unit tests in the software development process. The speaker emphasizes the need to write unit tests, even if they are not perfect, and provides insights on best practices for making unit tests effective, maintainable, and integrated into the development workflow. back to top

C++ Coroutines and Structured Concurrency in Practice - Dmitry Prokoptsev - CppCon 2024 The talk discusses the practical use of C++ coroutines and structured concurrency in a production environment at Hudson River Trading. It covers the challenges faced, the design decisions made, and the benefits realized from using coroutines to simplify asynchronous code and provide better error handling and cancellation mechanisms. back to top

C++ Reflection Based Libraries to Look Forward To - Saksham Sharma - CppCon 2024 The talk discusses the use of C++ reflection-based libraries to enable powerful features like automatic Python bindings, ABI hashing, and a 'virtual any' type. The speaker explores how reflection can transform the C++ developer experience by enabling more expressive and user-friendly APIs, while also acknowledging the challenges around debugging and accessing private members. back to top

JetBrains IDEs - Find Out More At https://www.jetbrains.com/ides/ Unlock the power of code with JetBrains IDEs, where the seemingly magical capabilities of software development are made possible through the collective efforts of millions of developers empowered by the right tools. Discover how JetBrains IDEs can transform your coding experience, enabling you to transcend the boundaries of what's possible with a single click. back to top

Interview with Colin Dowd - Undo - CppCon 2024 The video features an interview with Colin Dowd, a member of the account team for Undo in North and South America. It discusses Undo's involvement in the C++ community, their plans for CppCon 2024, and the company's focus on providing reverse debugging solutions to help developers solve complex bugs. back to top

What Volatile Means (and Doesn’t Mean) in C++ Programming - Ben Saks - CppCon 2024 The presentation discusses the volatile keyword in C++ programming, explaining its purpose, protections, and potential pitfalls. It also provides recommendations for addressing compiler optimization issues related to volatile objects, including using non-inline functions and disabling optimizations for affected code. back to top

What's New in Visual Studio for C++ Developers - Michael Price & Mryam Girmay - CppCon 2024 This talk provided an overview of the latest updates and features in Visual Studio for C++ developers, including productivity tools, GitHub Copilot integration, improvements to the MSVC toolchain, and cross-platform debugging and source control capabilities. The presenters demonstrated various features and discussed how they aim to empower C++ developers and their teams to achieve more through Microsoft's C++ product offerings. back to top

Gazing Beyond Reflection for C++26 - Daveed Vandevoorde - CppCon 2024 The talk covers the evolution of C++ reflection, from the introduction of the reflection operator in C++26 to the proposal for annotations-based reflection, which allows for more expressive and customizable compile-time metaprogramming. The speaker also discusses the implementation details and potential future developments, such as improved tooling and runtime reflection. back to top

Message Handling with Boolean Algebra - Ben Deane - CppCon 2024 The talk discusses a message handling library that uses Boolean algebra to simplify and optimize the processing of message fields. The speaker demonstrates how the library leverages concepts like implication, negation, and disjunctive normal form to efficiently handle complex message structures. back to top

Message Handling with Boolean Algebra - Ben Deane - CppCon 2024 The talk discusses a message handling library that uses Boolean algebra and expression templates to simplify message matching at compile-time. The speaker demonstrates how customizing negation and implication operations allows the library to perform efficient message dispatch and simplification, leveraging the connection between function types and Boolean propositions. back to top

C++ Design Patterns - The Most Common Misconceptions (2 of N) - Klaus Iglberger - CppCon 2024 The talk discusses common misconceptions about C++ design patterns, focusing on virtual functions and the Curiously Recurring Template Pattern (CRTP). It also explores the use of std::variant as an alternative to inheritance, highlighting the architectural implications and the need to prioritize design over performance considerations. back to top

Peering Forward - C++’s Next Decade - Herb Sutter - CppCon 2024 The talk discusses the exciting developments in C++ over the past few years, particularly the progress made in reflection and type/memory safety improvements that are likely to be included in the upcoming C++26 standard. The speaker emphasizes how these features will simplify C++ code and tooling, making the language more expressive and robust. back to top

Interview With Phil Nash (Accelerated TDD: For More Productive C++) - CppCon 2024 This video features an interview with Phil Nash, the creator of the C++ test framework Catch2, who discusses his upcoming talks at CppCon 2024. The talks cover topics such as accelerated test-driven development (TDD) training, modern C++ error handling, and object lifetime management, highlighting Nash's expertise in these areas and his efforts to help developers improve their C++ programming practices. back to top

Interview With Klaus Iglberger (C++ Software Design) - CppCon 2024 This video features an interview with Klaus Iglberger, a freelance trainer and consultant who specializes in C++ software design. The discussion covers Iglberger's upcoming CppCon 2024 talks, including a pre-conference class on C++ software design and a session on common misconceptions about design patterns, with a focus on the Curiously Recurring Template Pattern (CRTP). back to top

Interview With Patrice Roy (Optimizing with Modern C++) - CppCon 2024 Failed to generate summary. back to top

Interview With Mateusz Pusz (Structured Concurrency in C++) - CppCon 2024 This talk will explore the powerful new features in C++26, including reflection and structured concurrency, that are revolutionizing the way developers write asynchronous and concurrent code. Attendees will learn how to leverage these cutting-edge techniques to write more efficient, maintainable, and debuggable applications, with practical hands-on exercises to solidify their understanding. back to top

Performance Engineering

LLVM's Realtime Safety Revolution: Tools for Modern Mission Critical Systems - CppCon 2024 This talk introduces two new tools from LLVM, Real-Time Sanitizer and Performance Constraints Attributes, designed to help real-time programmers write safer and more reliable code. The speakers provide an overview of real-time programming concepts, demonstrate how to use these tools, and discuss their strengths, limitations, and practical applications. back to top

What’s Eating my RAM? - C++ Memory Management - Jianfei Pan - CppCon 2024 This talk explores the challenges of memory management in C++ applications, focusing on the issues of memory leaks and memory fragmentation. The speaker discusses various tools and techniques to identify and address these problems, including the use of custom memory allocators to improve memory locality and reduce fragmentation. back to top

Hidden Overhead of a Function API - Oleksandr Bacherikov - CppCon 2024 The talk discusses the hidden overhead of function APIs in C++, focusing on aspects such as return values, parameter passing, and the impact of C++ abstractions on performance. The speaker provides insights and guidelines to help developers write efficient C++ code by understanding the underlying ABI specifications and compiler optimizations. back to top

C++ Exceptions for Smaller Firmware - Khalil Estell - CppCon 2024 The talk explores how C++ exceptions can lead to smaller firmware binaries compared to alternative error handling approaches. The speaker demonstrates techniques to overcome the perceived limitations of exceptions in embedded systems and presents a tool to analyze exception usage in compiled binaries. back to top

C++ Relocation - How to Achieve Blazing Fast Save and Restore and More! - Eduardo Madrid - CppCon 24 The presentation discusses data orientation techniques, with a focus on relocatability, to achieve blazing fast save and restore functionality in C++ applications. It emphasizes the benefits of homogeneous data structures, entity-component systems, and the need for language improvements to better support data orientation and relocatability. back to top

When Nanoseconds Matter: Ultrafast Trading Systems in C++ - David Gross - CppCon 2024 The talk covers the design and optimization of low-latency trading systems in C++, focusing on data structures, concurrency, and hardware-aware programming principles. The speaker shares insights from their experience in the trading industry and provides practical solutions to common performance challenges in building high-speed financial applications. back to top