CppCon, The C++ Conference

Do you *really* need to know all of C++? Does Bjarne Stroustrup know all of C++? Find out in our new outtake from the upcoming C++ Documentary. The full film is released on June 4th. https://lnkd.in/dRqZuvRx

CppCon, The C++ Conference 2026 Call for Poster Submissions https://lnkd.in/eKGcX9E4 Are you doing something cool with C++? Got a great new library, technique, or tool? We want you to share it with the C++ community by creating a poster and presenting it at CppCon 2026! The poster program will be back in action this year at the conference. The poster submissions deadline is July 15th, with decisions sent by August 3rd. For topic ideas, submission instructions, and advice on making the best possible submission, see the Poster Submissions page Poster Submissions page: https://lnkd.in/gqgqEHKS Important Dates Submissions open: 1 June 2026 Submission deadline: 15 July 2026 Decision notifications by: 3 August 2026

CppCon, The C++ Conference 2025 - Lightning Talk: Jonathan White: "Crafting CUDA Compatible C++ Code" youtu.be/hIx4HpWBoKE -- An annoying part of writing CUDA code is needing to repeat program logic in CUDA kernels. C++ 20 provides a way to write this code in a single location accessible from both the host and device. -- Jon White

CppCon, The C++ Conference 2025 : Lightning Talk: Tyler Drake: "A C++20 Modules Performance Field Report" youtu.be/84qXqMMDS3I --- C++ modules work, and they increase build performance. This is especially true when modularizing dependencies. --- Tyler Drake I do simulation/game programming. I consider fundamentals to be important, and I consider trade-offs to be non-universal, so I frequently build things that seem like they already exist.

CppCon, The C++ Conference 2025 - Lightning Talk: Ruslan Arutyunyan: "Lambdas, Ranges and trivially_copyable: Why This Matters for Parallel Algorithms" youtu.be/9bq1gEw6OzY --- This talk is going to explore the trivial copyability of the ranges (based on `transform_view`) in combination with lambdas and explain why it matters for Parallel Algorithms. We are going to look at the problems, possible workarounds and a potential solution that I have in mind. --- Ruslan Arutyunyan Ruslan is a Senior Middleware Development Engineer specializing in parallel and threading runtimes. He joined Intel in 2017 and has experience in the autonomous driving domain, where he led the development of two libraries. Currently, Ruslan is the lead developer of oneAPI DPC++ library (oneDPL) while also contributing to other Intel products, including oneAPI Threading Building Blocks (oneTBB). He is an active member of the C++ Standard Committee (WG21), focusing on the C++ standard library, concurrency, and parallelism, with several accepted proposals. His current priorities are standardizing std::simd enhancements, extending C++ parallel algorithms, and contributing to Senders/Receivers. Ruslan recently stepped into the role of SG1 (Concurrency and Parallelism) co-chair in the C++ Standard Committee.

CppCon, The C++ Conference 2025 - Lightning Talk: Makar Kuznietsov: "Understanding Data Dependency Chains" youtu.be/eMnz158Y0Ok --- Long dependency chains in your code might completely nuke the performance. Even on the high-end systems there will be a significant slow-down, as the more threads or more cache will not improve performance in this case. To find a solution it is crucial to be able to differentiate between primary and secondary dependency chains, see what data is the dependency over, and know whether to focus on latency or throughput of instructions. In this talk I will introduce a mental framework to quickly spot and fix long dependency chains, and characterize them with specific quantifiable metrics. --- Makar Kuznietsov Makar Kuznietsov, MIT '25 graduate, and incoming MIT masters student is a co-founder of Functio, which creates LLMs to find and fix performance bottlenecks in software projects. In his prior research project he developed robust electrostatic motor control solution in C++ on ESP32 platform. Additionally, he worked on GPU design at NVIDIA, and led team in designing electronics for autonomous boats at MIT Arcturus team.

Join me in Colorado this September in person to learn about essential debugging tools! #cpp #debugging #tooling #systemsprogramming

CppCon, The C++ Conference 2025 - Lightning Talk: Hossein GhahramanzadehAnigh: "How Fast Isn’t You Constexpr?" youtu.be/rmfuWQXojtY --- I investigate the compile time + run time of running an algorithm in an effort to compare how much it takes the compiler to run the same algorithm at compile time vs how much it takes to run the algorithm natively. With the findings at the end I hand roll a constexpr alternative that strikes a balance between compile-time and run-time performance. --- I am C++ developer currently working at IMC Trading. I have been a C++ enthusiast ever since I was 15. I do a lot of compile time stuff.

CppCon, The C++ Conference 2025 - Lightning Talk: Jeff Garland: "Bool - Implicitly Dangerous" youtu.be/PcerWZRm_eA --- Really, boolean should be the easiest thing to understand in C++. It's two possible states -- true and false -- what could possibly go wrong? Unfortunately, plenty. If you're still a C++ programmer after reveal how using bool can be risky business, I'll provide some simple strategies for taming your bools. --- Jeff Garland 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.

CppCon, The C++ Conference 2025 - Lightning Talk: Raffaele Rossi: "Proof Searching in DepC" youtu.be/sB-mQRsXv1M --- News articles in recent years have highlighted the problem of memory safety in System Programming languages like C and C++, with governments urging companies to move to Rust. Among memory safety errors, buffer overflows and dangling references are the most typical. Dependent Types are known to help with the former, by encoding the length of arrays in their types. Rust’s Borrow Checker helps with the latter, but its approach is unique and does not reconcile with Dependent Types. I propose new inference rules in the theory of Dependent Types that prove, at compile-time, that references are valid and can be safely dereferenced. --- Raffaele Rossi By day I am a Tech Lead at Maven Securities. In my spare time I work on DepC, like C/C++ but with Dependent Types