CppNow 2024

Back to all conferences

Table of Contents

• Compute (23 videos)
• Developer Experience (52 videos)
• Embedded (1 videos)
• Security (1 videos)
• Serverless (1 videos)

Compute

Get A Sneak Peek Of C++Now 2024! Exclusive Interview With Michael Caisse By @cppevents! This video features an exclusive interview with Michael Caisse, a long-time contributor to the C++ community, who is set to deliver a keynote talk at the upcoming C++Now 2024 conference. Caisse discusses the challenges of concurrency in embedded systems and how the 'senders and receivers' design pattern can help address issues related to value channels, error handling, and task cancellation. back to top

The Importance of the C++ Build System Target Model - Bill Hoffman - C++Now 2024 The talk discusses the importance of the C++ build system Target Model, which organizes projects around targets rather than directories or files. It also highlights the need for better communication between library maintainers and consumers, and proposes the use of the Common Package Specification (CPS) as a solution to this problem. back to top

Fast Conversion From Cpp Floating Point Numbers - Cassio Neri - C++Now 2024 The talk discusses the problem of converting floating-point numbers to strings, and presents a new algorithm called 'T Jagua' that is fast, accurate, and easy to implement. The speaker shares the inspiration behind the algorithm, which comes from South American mythology, and provides details on the algorithm's implementation and performance. back to top

Expressive Compile-Time Parsers in C++ - Alon Wolf - C++Now 2024 The video discusses expressive compile-time parsers in C++, showcasing various libraries and techniques for creating domain-specific languages and integrating them into C++ code. The speaker covers the importance of expressive code, the evolution of compile-time parsing in C++, and the potential future of integrating alternative syntaxes within the C++ ecosystem. back to top

C++26 Preview - Jeffrey Garland - C++Now 2024 This talk provides a preview of the upcoming C++26 standard, highlighting key language features like reflection, contracts, and pattern matching, as well as a wide range of library improvements in areas such as strings, numerics, linear algebra, and concurrency. The speaker covers the standardization process, the current state of C++26 proposals, and the priorities and schedule for the new standard. back to top

Unlocking Modern CPU Power - Next-Gen C++ Optimization Techniques - Fedor G Pikus - C++Now 2024 The talk discusses the evolution of modern CPUs, highlighting the challenges and optimization techniques required to effectively utilize their increased compute power and complex architectural features, such as non-uniform memory access (NUMA) and branch prediction. The speaker provides real-world examples and insights on how to address these challenges through profiling, monitoring, and tailored optimizations. back to top

Rappel: Compose Algorithms, Not Iterators - Google's Alternative to Ranges - C++Now 2024 The presentation discusses Rappel, Google's alternative to C++ Ranges, which aims to provide a safer and more efficient composition of algorithms by using a push-based approach with continuation passing style, rather than the pull-based iterator model. The key benefits of Rappel include avoiding dangling references, reducing stack usage, and providing better error handling through monadic composition. back to top

C++26 Preview - Jeffrey Garland - C++Now 2024 The talk provides a preview of the upcoming C++26 standard, covering a range of language features such as contracts, reflection, and pattern matching, as well as various library improvements, including enhancements to strings, numerics, and concurrency support. The presenter emphasizes the incremental approach of the C++ standardization process, where features are introduced gradually and the committee focuses on delivering a 'minimum viable product' in each release. back to top

C++ Coroutines at Scale - Implementation Choices at Google - Aaron Jacobs - C++Now 2024 The talk discusses the design choices and implementation details of a C++ coroutine library developed for use at Google, focusing on scaling concerns such as efficiency and usability for thousands of engineers. The key aspects covered include lifetime rules for coroutine parameters, bounding stack usage, and implementing robust cancellation support. back to top

Embedded Asynchronous Abstraction C++ - Implementing Senders & Receivers Without an OS - Ben Deane This talk explores how the senders and receivers abstraction can be implemented in embedded systems, which often have constraints like no operating system, limited resources, and interrupt-driven execution. The speaker demonstrates how senders and receivers can be used to efficiently schedule and execute work in an embedded environment, while also addressing challenges like cancellation, error handling, and static memory allocation. back to top

C++ Should Be C++ - David Sankel - C++Now 2024 The talk discusses the role of C++ and Rust in software development, highlighting the complexity and incoherence introduced in the C++ standardization process. The speaker advocates for simpler, more idiomatic C++ code and a reduction in the complexity of the language, while also exploring the potential benefits of Rust for certain use cases. back to top

Keynote: Employing Senders & Receivers to Tame Concurrency in C++ Embedded Systems - Michael Caisse The talk discusses employing 'senders' and 'receivers' to tame concurrency in C++ embedded systems. The speaker demonstrates how senders and receivers can be used to effectively handle asynchronous events, manage state, and compose complex functionality in a more structured and composable way compared to traditional approaches. back to top

Value Oriented Programming Part V - Return of the Values - Tony Van Eerd - C++Now 2024 This talk explores the concept of value-oriented programming, emphasizing the importance of separating calculation from action and the benefits of using immutable values over mutable objects. The speaker delves into the challenges of object-oriented programming, such as entanglement and non-local reasoning, and proposes value-oriented programming as a solution to these issues. back to top

Fast Conversion From Cpp Floating Point Numbers - Cassio Neri - C++Now 2024 Cassio Neri presents a new algorithm, named T Jaguar, for the efficient conversion of floating-point numbers to strings. The algorithm aims to produce the shortest possible representation while maintaining the round-trip property and addressing the challenges associated with the underlying binary representation of floating-point numbers. back to top

Unlocking Modern CPU Power - Next-Gen C++ Optimization Techniques - Fedor G Pikus - C++Now 2024 This talk covers the evolution of modern CPUs over the past 10 years, highlighting the increasing complexity and performance capabilities, as well as the challenges this introduces for optimization techniques. The speaker discusses various optimization strategies, including leveraging the CPU's superscalar architecture, managing cache and memory access patterns, and addressing the complexities of NUMA (Non-Uniform Memory Access) systems. back to top

Zero-Cost Abstractions in C++ - High Performance Message Dispatch - Luke Valenty - C++Now 2024 This talk presents a case study on zero-cost abstractions in C++ for high-performance message dispatch, highlighting the importance of declarative, extensible interfaces and leveraging fundamental mathematical concepts to optimize performance and maintainability in embedded firmware development. back to top

C++ is a Metacompiler - Daniel Nikpayuk - C++Now 2024 The talk explores how C++ can be used as a metacompiler, allowing the creation of domain-specific languages that can be metacompiled into efficient C++ code. The speaker discusses the theoretical foundations, implementation details, and future directions of their open-source cctm library, which demonstrates this approach. back to top

Guide to Random Number Generation in C++ - Adrien Devresse - C++Now 2024 The talk discusses the practical usage of random number generation in C++, focusing on the C++ standard library's random API and the advantages of counter-based random number generators. It highlights the importance of high-quality random numbers in scientific computing and provides guidance on choosing the appropriate random number generation approach. back to top

C++11 to C++23 in the C++ Memory Model - Alex Dathskovsky - C++Now 2024 This talk provides an in-depth exploration of the C++ memory model, covering the optimizations performed by compilers and CPUs, as well as the synchronization tools and techniques available in C++11 to C++23. The speaker delves into the intricacies of memory ordering, memory fences, and the practical implementation of these concepts, equipping the audience with the knowledge to write efficient and correct concurrent C++ code. back to top

Backporting C++ Safety - Taylor Foxhall - C++Now 2024 The talk discusses the challenges of ensuring safety in C++ code, particularly in the context of a distributed system like Blazing MQ. The speaker explores various approaches to achieving memory safety, type safety, and thread safety, highlighting the use of contracts, custom allocators, and the actor model to mitigate these issues. back to top

A Deep Dive Into C++ Object Lifetimes - Jonathan Müller - C++Now 2024 This talk provides a deep dive into the complex topic of C++ object lifetimes, covering the intricacies of object creation, initialization, destruction, and the subtle implications of pointer arithmetic and type punning. The speaker delves into the abstract machine model, highlighting the importance of object provenance and the challenges posed by the standard's evolving rules around undefined behavior. back to top

Detect C++ Memory Leaks with ALSan: Attachable Leak Sanitizer - Bojun Seo - C++Now 2024 The presentation discusses an attachable leak sanitizer tool called ALSan, which uses eBPF and uprobes to detect memory leaks in C++ applications without affecting the target process's memory. The tool can hook memory allocation functions, save allocation information, and analyze and report unreachable memory, addressing the limitations of existing memory leak detection tools like Valgrind and AddressSanitizer. back to top

This is C++: Uncompromised Performance, Undefined Behavior, & Move Semantics - Jon Kalb C++Now 2024 This talk explores the defining aspects of C++ and how they shape the language's design and evolution. The speaker discusses C++'s focus on uncompromised performance, the implications of undefined behavior, and the challenges posed by move semantics, highlighting the trade-offs and decisions made by the C++ standards committee. back to top

Developer Experience

CppNow 2024 Session Preview with Bret Brown and @cppevents The speaker discusses their experience with C++Now, a conference focused on C++ and related topics, highlighting the conference's unique small-town vibe, depth of expertise, and opportunities for collaborative work. They also share insights on managing large-scale C++ codebases and the evolving landscape of C++ tooling and package management. back to top

Exclusive Interview With C++Now 2024 Program Chair Inbal Levi with @cppevents! The video features an interview with Inbal Levi, the Program Chair for C++Now 2024, discussing the upcoming conference. Levi highlights the focus on tooling and development environments, as well as the exciting lineup of keynote speakers and talks that attendees can look forward to at the event. back to top

Keynote Session Preview - C++ Painkillers by Anastasia Kazakova with @cppevents In this preview of the keynote session at the C++ Now conference, Anastasia Kazakova, a long-time C++ advocate and developer at JetBrains, discusses the importance of tooling in the C++ ecosystem. She shares insights on the evolution of C++ tooling, the challenges of incorporating AI-powered features, and her plans to inspire the audience with stories and insights from her extensive experience. back to top

C++Now 2024 Session Preview - Interview With Katherine Rocha by @cppevents This video previews the upcoming C++Now 2024 conference, highlighting the excitement and interactive nature of the event. The speaker, Katherine Rocha, discusses her talk on legacy design trends and their modern replacements, emphasizing the valuable conversations and learning opportunities that take place at the intimate, expert-filled conference. back to top

Keynote Session Preview - C++ Painkillers by Anastasia Kazakova with @cppevents The keynote session preview by Anastasia Kazakova at the C++ events conference focuses on the importance of tools and their evolution in the C++ ecosystem. Kazakova shares her insights on the challenges and opportunities of integrating AI-powered tools into the development workflow, emphasizing the need for seamless integration and prompt engineering to enhance the productivity of C++ developers. back to top

C++Now 2024 Session Preview - Interview With Zach Laine by @cppevents This video previews the upcoming C++Now 2024 conference, featuring an interview with Zach Laine, a long-time contributor to the Boost C++ libraries. Laine discusses the unique challenges of writing high-performance C++ libraries versus applications, and shares his experiences attending and presenting at the C++Now conference over the years. back to top

C++ Reflection - Back on Track - David Olsen - C++Now 2024 This talk discusses the upcoming C++ reflection feature, which will allow programs to introspect and manipulate their own structure at compile-time. The speaker provides an overview of the proposal, demonstrating how reflection can simplify common programming tasks like command-line parsing and serialization. back to top

C++ Coroutines and Structured Concurrency in Practice - Dmitry Prokoptsev - C++Now 2024 The speaker discusses the practical usage of C++ coroutines, including the challenges faced and the solutions developed. The talk covers structured concurrency, cancellation, and the integration of coroutines with existing callback-based asynchronous code. back to top

Investigating Legacy Design Trends in C++ & Their Modern Replacements - Katherine Rocha C++Now 2024 The talk explores the evolution of design trends in C++ and the trade-offs between using newer and older approaches. It emphasizes the importance of applying the same level of scrutiny to both new and legacy design patterns to ensure the most appropriate solution for the use case. back to top

Expressive Compile-Time Parsers in C++ - Alon Wolf - C++Now 2024 The talk explores the evolution of expressive compile-time parsers in C++, showcasing various libraries and techniques for creating domain-specific languages and integrating them seamlessly with C++ code. The speaker demonstrates how compile-time parsing can be used to generate functions, types, and data structures, highlighting the potential for future advancements in this area. back to top

C++ Type Erasure Demystified - Fedor G Pikus - C++Now 2024 The talk discusses the concept of type erasure in C++, a programming technique that removes explicit type information from the program. The speaker explains different approaches to implementing type erasure, including inheritance, static functions, and V-tables, and compares their performance characteristics through benchmarks. back to top

Value Oriented Programming Part V - Return of the Values - Tony Van Eerd - C++Now 2024 This talk explores the concept of value-oriented programming, where the focus is on using immutable and movable values rather than mutable objects. The speaker discusses the benefits of separating calculation from state changes and the challenges of managing entanglement and non-local reasoning in object-oriented code. back to top

Boost.Parser (Part 2 of 2) - A Parser Combinator Library for C++ - Zach Laine - C++Now 2024 The speaker discusses Boost.Parser, a C++ parser combinator library that provides robust Unicode support, debugging tools, and callback parsing capabilities. The library aims to make parsing tasks more accessible and efficient, with a focus on usability and flexibility. back to top

C++ Should Be C++ - David Sankel - C++Now 2024 The speaker discusses the complexities and challenges facing the C++ programming language, highlighting issues with the language's standardization process and the need to balance innovation with maintaining existing codebases. He advocates for simpler, more coherent C++ development and suggests exploring alternative governance models for the language's evolution. back to top

Boost.Parser (Part 1 of 2) - A Parser Combinator Library for C++ - Zach Laine - C++Now 2024 This talk discusses the Boost.Parser library, a modern parser combinator library for C++. The speaker highlights the advantages of Boost.Parser over existing parser libraries like Boost.Spirit, including improved compilation times, better error reporting, and more flexible composition of parsing rules. back to top

What We’ve Been Awaiting For? - How to Build a C++ Coroutine Type - Hana Dusíková - C++Now 2024 The talk explores how to build a C++ coroutine type, discussing the model of coroutines, their transformation into code, and the implementation of suspendable functions. The speaker also demonstrates a search engine implementation using coroutines to fetch and process data asynchronously. back to top

Investigating Legacy Design Trends in C++ & Their Modern Replacements - Katherine Rocha C++Now 2024 The talk explores the evolution of design trends in C++, examining the pros and cons of various approaches such as Singleton, MonoState, Dependency Injection, and Concepts. It emphasizes the importance of scrutinizing new trends with the same rigor as legacy designs, as newer is not always better. back to top

Reflection Is Good for C++ Code Health - Saksham Sharma - C++Now 2024 The talk discusses the use of reflection in C++ to improve the C++ library ecosystem, including examples of using reflection for Python bindings, ABI hashing, and a virtual any object. The speaker also discusses alternatives to reflection that the C++ community has been using, such as Protobuf and Avro, and how reflection could improve these approaches. back to top

What We’ve Been Awaiting For? - How to Build a C++ Coroutine Type - Hana Dusíková - C++Now 2024 The talk discusses building a C++ coroutine type, exploring its features and implementation details. The speaker demonstrates how to create a simple search engine using coroutines and discusses the challenges and benefits of using this language feature in C++. back to top

Boost.Parser (Part 2 of 2) - A Parser Combinator Library for C++ - Zach Laine - C++Now 2024 This video discusses Boost.Parser, a parser combinator library for C++. The speaker covers various features of the library, including rules, higher-order parsers, directives, Unicode support, diagnostics, and callback parsing, and provides an extended example of implementing a JSON parser. back to top

C++ Reflection - Back on Track - David Olsen - C++Now 2024 The presentation discusses the upcoming C++ reflection proposal, which aims to provide a compile-time reflection system for C++. It covers the key features of the proposal, including the reflection operator, introspection capabilities, and the ability to define classes and functions using reflection. back to top

The Importance of the C++ Build System Target Model - Bill Hoffman - C++Now 2024 The talk discusses the importance of the C++ build system Target Model, which organizes projects around targets rather than directories or files. It highlights the need for better communication between library maintainers and consumers, and proposes the Common Package Specification (CPS) as a solution to this problem. back to top

C++ Coroutines and Structured Concurrency in Practice - Dmitry Prokoptsev - C++Now 2024 This talk discusses the practical use of C++ coroutines in production code, highlighting the challenges and solutions in implementing structured concurrency, error propagation, and asynchronous cancellation. The speaker shares insights from their team's experience of using coroutines for over two years, including the benefits of simpler and more readable code, as well as the performance considerations and the development of a custom concurrency framework. back to top

Rappel: Compose Algorithms, Not Iterators - Google's Alternative to Ranges - C++Now 2024 The presentation discusses Rappel, Google's alternative to C++ Ranges, which aims to provide a safer and more efficient way to compose algorithms by using a push-based model instead of the pull-based model of iterators. The speaker highlights the challenges of using iterators, such as dangling references and inefficient composition, and demonstrates how Rappel addresses these issues through its eager processing and continuation-passing style. back to top

Boost.Parser (Part 1 of 2) - A Parser Combinator Library for C++ - Zach Laine - C++Now 2024 The video discusses the Boost.Parser library, a parser combinator library for C++. The speaker explains the motivation behind creating the library, its key features, and how it differs from existing parser libraries like Boost.Spirit. back to top

C++ Type Erasure Demystified - Fedor G Pikus - C++Now 2024 This talk demystifies C++ type erasure, explaining how it works, its use cases, and the different implementation approaches, including inheritance, static functions, and V-tables. The speaker compares the performance of these approaches and provides insights on the trade-offs, emphasizing that type erasure is a powerful abstraction technique that separates the interface from the implementation. back to top

An Adventure in Modern C++ Library Design - Robert Leahy - C++Now 2024 This talk explores the design of a modern C++ library to query financial market data, highlighting the challenges of handling live data streams, type-safe data representations, and incremental computation. The speaker demonstrates how techniques like metaprogramming, customizable functions, and stream-based processing can be used to build a robust and extensible library that addresses the complexities of the problem domain. back to top

Developing Better C++ Code by Isolating Decisions - Michael Okyen - C++Now 2024 Failed to generate summary. back to top

Functional C++ - Gašper Ažman - C++Now 2024 This talk explores the challenges of using functional programming techniques in C++, introducing concepts like monads, sums, and packs to manage complexity and ensure correctness in C++ code. The speaker presents a library that aims to make these functional patterns more accessible and composable in C++, with the goal of enabling more robust and provable code. back to top

Developing Better C++ Code by Isolating Decisions - Michael Okyen - C++Now 2024 Failed to generate summary. back to top

Dependency Injection in C++ - A Practical Guide - Peter Muldoon - C++Now 2024 This talk provides a practical guide to implementing dependency injection in C++ codebases, emphasizing strategies for overcoming the challenges of legacy code and large-scale complex systems. The speaker shares insights gained from refactoring a 30-year-old codebase, highlighting the importance of proper code factoring, managing API changes, and leveraging techniques like template-based dependency injection and type erasure. back to top

Reintroduction to Generic Programming for C++ Engineers - Nick DeMarco - C++Now 2024 The talk discusses the importance of generic programming in C++ and how to approach it effectively. It covers concepts, abstractions, and the balance between product code and library code, emphasizing the need to generalize stable code to reduce technical debt. back to top

Keynote: C++ Painkillers for C++ Developers - The Evolution of C++ Tooling - Anastasia Kazakova This talk explores how C++ tooling can help address common pain points faced by C++ developers, such as managing dependencies, build times, and language safety. The speaker highlights various tools and techniques that can serve as 'painkillers' to alleviate these issues, while emphasizing the importance of language evolution and the collaboration between the language committee and tool vendors. back to top

C++ Zero Overhead Pass by Value Through Invocable C++ Abstractions - Filipp Gelman - C++Now 2024 The presentation explores techniques for passing function arguments by value through C++ abstractions, such as std::function, without incurring unnecessary copies or moves. The speaker demonstrates how to leverage compiler-specific features and the Itanium ABI to achieve this zero-overhead pass-by-value behavior, even for non-trivially copyable types. back to top

How Bloomberg Built a Reusable Process For Consensus on Their Massive C++ Codebases - Sherry Sontag This talk discusses how Bloomberg built a reusable process for achieving consensus on their massive C++ codebase. The speaker highlights the importance of open communication, humility, and asking questions to understand the needs of both infrastructure and development teams, leading to a collaborative approach that balances guidelines and flexibility. back to top

C++ Overload Inspector - A Tool for Analyzing and Profiling Overloaded Function Calls - C++Now 2024 C++ Overload Inspector is a tool that provides detailed analysis and profiling of overloaded function calls in C++ code. The tool, which is based on the Clang compiler, offers insights into the overload resolution process, including the reasons for the chosen overload, the time taken for the resolution, and support for filtering and customizing the output. back to top

Implementing Ranges and Views in C++ - Roi Barkan - C++Now 2024 The presentation discusses the implementation of ranges and views in C++, highlighting the composability and laziness of these concepts. It covers the details of creating range adapters, handling lifetime management, and exploring various range operations like merging, intersection, and difference. back to top

Testability and C++ API Design - John Pavan, Lukas Zhao & Aram Chung - C++Now 2024 The presenters discuss strategies for designing C++ APIs that are testable, focusing on principles like the SOLID design principles and patterns like the Pimpl idiom. They also propose the idea of a tool that could automatically generate boilerplate code and design patterns to make it easier for developers to write testable C++ code. back to top

Fun with Flags - C++ Type-safe Bitwise Operations - Tobias Loew - C++Now 2024 The talk explores type-safe bitwise operations in C++ using a custom library called Boost.Flex. It highlights the challenges with using enumerations for bitwise operations and presents a solution that enforces type safety, provides a complement type, and maintains zero overhead in optimized builds. back to top

Concept Maps using C++23 Library Tech - Indirection to APIs for a Concept - Steve Downey - C++Now 24 The talk discusses a C++23 library-based approach to implementing concept maps, which allow open extension of concepts through specialized implementations. The speaker demonstrates how this can be used to implement useful abstractions like monoids, which have applications in data structures like finger trees and priority queues. back to top

The Most Important API Design Guideline - No, It's Not That One - Jody Hagins - C++Now 2024 The speaker discusses the importance of designing software with testability in mind, using examples from the finance industry to illustrate the consequences of neglecting this principle. He also shares his perspective on object-oriented programming and how it differs from the common practices in the C++ community. back to top

Unit Testing an Expression Template Library in C++20 - Braden Ganetsky - C++Now 2024 The talk discusses the challenges of unit testing an expression template library in C++20, focusing on the importance of custom error messages and the author's efforts to create a testing framework that can run tests at both compile-time and run-time. The speaker explores various testing frameworks, their strengths and limitations, and introduces upcoming C++ features that can enhance the testing experience. back to top

What Does It Take to Implement the C++ Standard Library? (C++Now Edition) Christopher Di Bella This talk discusses the challenges and best practices involved in implementing the C++ Standard Library, including the need for correctness, good performance, and robust diagnostics. The speaker also emphasizes the close relationship between the Standard Library and the compiler, and the importance of leveraging compiler extensions to provide the best possible user experience. back to top

Generic Arity: Definition-Checked Variadics in Carbon - Geoffrey Romer - C++Now 2024 This talk presents Carbon's design for definition-checked variadics, which aims to provide the benefits of Carbon's generic system to functions with variable arity. The key ideas are representing pack types as sequences of segments and performing type checking at function definition time rather than instantiation time to enable incremental migration from C++. back to top

Mistakes to Avoid When Writing C++ Projects - Bret Brown - C++Now 2024 The talk discusses the importance of designing robust interfaces for C++ projects, including project contracts, naming conventions, build system integration, and dependency management. The speaker presents an open-source project called 'zero code' as an example of how these principles can be applied to create maintainable and interoperable C++ projects. back to top

How do Time Travel Debuggers Work? - Design and Implementation of a Time Travel Debugger - Greg Law The talk explores the design and implementation of time travel debuggers, which allow developers to record and replay program execution to understand complex software issues. It discusses the key design decisions, such as the choice between storing program state changes or re-executing the program, and the challenges of handling non-deterministic events like system calls and thread switches. back to top

Lightning Talk: Fun? with NTTPs in C++ - Ben Deane - C++Now 2024 This talk explores the creative and unexpected uses of Non-Type Template Parameters (NTTPs) in C++. The speaker delves into various techniques, including using lambdas, macros, and even unconventional grammar constructs, to leverage NTTPs in ways that push the boundaries of the language. back to top

The C++ Vector Challenge - Lisa Lippincott - C++Now 2024 This talk discusses the challenges of formalizing the interface of C++ data structures, particularly the vector container, using a picture language approach. The speaker proposes a framework for defining object interfaces that can express the preconditions and postconditions of operations, allowing for more rigorous reasoning about program behavior. back to top

Modernizing Finite State Machines in C++ - Empower Simplicity & Boost Performance With std::variant The presentation explores the evolution of implementing finite state machines in C++, starting from the naive approach using if-else statements and switches, progressing to the state pattern, and culminating in the use of std::variant to achieve simplicity, flexibility, and high performance. The speaker showcases benchmarks demonstrating the efficiency of the std::variant-based implementation, which outperforms the state pattern approach and is on par with the enum-based implementation. back to top

Glean: C++ Code Indexing at Meta - Michael Park - C++Now 2024 Glean is a system for collecting, deriving, and querying facts about source code, designed to scale to large codebases and support multiple programming languages. The talk explores Glean's architecture, its use of a flexible schema to handle language-specific nuances, and its application in providing enhanced code navigation and analysis capabilities. back to top

Closing Keynote: C++ Development Tools: Past, Present and Future - Marshall Clow - C++Now 2024 The keynote explores the past, present, and future of C++ development tools, highlighting the evolution from paper tape splicing to modern tools like sanitizers, fuzzing, and AI-assisted development. The speaker discusses the potential impact of AI on software development, including the rise of one-off software and the challenges of training new developers in an AI-assisted world. back to top

Designing a Slimmer Vector of C++ Variants - Christopher Fretz - C++Now 2024 The talk details the speaker's experience in creating a novel solution to reduce memory usage of a Vector of std::variant. The presented design uses a bit-packed representation and a virtual interface to dynamically adjust the offset storage, resulting in a 40-50% memory savings compared to the standard approach. back to top

Embedded

Keynote: Employing Senders & Receivers to Tame Concurrency in C++ Embedded Systems - Michael Caisse This talk discusses how the speaker, Michael Caisse, employed the concept of senders and receivers to tackle the challenges of concurrency in C++ embedded systems. The speaker presents a library called Cinders that utilizes senders and receivers to manage asynchronous events, state, and error handling, providing a more structured and composable approach to solving concurrency problems in embedded systems. back to top

Security

Security in C++ - Hardening Techniques From the Trenches - Louis Dionne - C++Now 2024 This talk discusses the importance of security in C++ and presents two techniques, standard library hardening and type-aware memory operations, to improve the security of C++ programs. The speaker emphasizes the need for pragmatic and easily adoptable solutions to address the vast amount of existing C++ code and the responsibility of the C++ community to improve the language's security. back to top

Serverless

C++ Coroutines at Scale - Implementation Choices at Google - Aaron Jacobs - C++Now 2024 The presentation discusses the design choices made in implementing a C++ coroutine library at Google, focusing on scaling concerns such as efficient parameter lifetimes, bounded stack usage, and robust cancellation support. The speaker highlights how thoughtful API design can address both efficiency and usability challenges in scaling coroutines to large engineering teams. back to top