Loading…
Subject: Tooling/Utilities clear filter
Monday, September 14
 

11:00 MDT

From Firmware to Screen: Real-Time Control, Simulation, and Visualization in C++23 With CUDA and Unreal Engine
Monday September 14, 2026 11:00 - 12:00 MDT
_1
What does it take to build a real-time embedded control system in modern C++, simulate its environment, command it from a browser, and watch it fly in 3D — all from the same open source ecosystem? This talk follows that pipeline end-to-end: from a C++23 real-time framework that schedules deterministic control loops across POSIX hosts and bare-metal microcontrollers, to GPU-accelerated simulation with CUDA, to web-based operations and telemetry, to live 3D visualization in Unreal Engine.

Attendees will see how a unified runtime architecture can span embedded control, simulation, diagnostics, operations, and visualization without fragmenting into separate software stacks. The talk explores deterministic scheduling, zero-allocation real-time design, cross-platform deployment, and integrating CUDA compute kernels directly into scheduled control loops without blocking execution. It also covers tooling for validating deterministic real-time behavior, along with techniques for streaming telemetry and sensor data between simulation and visualization layers in real time.

The presentation includes live demonstrations of a quadcopter simulation flying a programmed trajectory with lidar feedback, and a full-fidelity aircraft simulation with closed-loop autopilot, engine dynamics, and atmospheric turbulence — both running through the same real-time framework and rendered live in Unreal Engine. Whether you build flight software, robotics systems, industrial controllers, or simulation infrastructure, this talk presents practical architectural patterns for modern real-time systems in C++ that bridge embedded devices, GPU compute, and interactive visualization.

Presenters
KG
Monday September 14, 2026 11:00 - 12:00 MDT
_1
  Robotics & AI

11:00 MDT

Same Bits Without Losing MIPS: Reproducible Numerics at Full Hardware Speed
Monday September 14, 2026 11:00 - 12:00 MDT
_6
Floating point has a reputation for betrayal. Change the thread count, vector width, compiler flags, reduction tree, or target architecture, and the low bits can move. Parallel algorithms make this worse: the standard often specifies the operation, but not the numerical expression whose result must be reproduced. This talk asks a provocative question: what if reproducible numerics did not have to be slow?

We will show reproducible, deterministic implementations of reduce and scan that exhibit better error behavior on hostile floating-point workloads and can match or beat conventional standard-library implementations on realistic workloads. The trick is not to freeze the execution schedule. It is to specify the expression being computed, then let the implementation use SIMD, threading, blocking, tiling, and platform-specific strategies to compute that expression efficiently.

The key idea, developed through C++ standardization work such as P4016R0 and P4229R0, is reproducibility by reproducing the computation. Instead of asking the implementation to promise a particular schedule, we give the calculation a named expression. Once that expression is chosen, changing the thread count, vector width, chunking, or blocking strategy does not silently change the answer.

A reproducible scan makes this harder than reduce because it does not expose only one final value. It exposes every prefix. A reproducible final sum is not enough if the intermediate results still drift. We will show how expression and observation contracts make those prefixes reproducible without forcing the computation back into a slow sequential order.

Then we go below the algorithm layer, to the places where bits usually escape: FMA contraction, denormals, floating-point environment choices, math-library approximations, and vectorized transcendental functions. The goal is not to get the same answer by turning off the hardware. We will show reproducible vectorized primitives, including transcendental functions, running at speeds comparable to established vector math libraries while preserving a cross-platform numerical contract.

Finally, we put the whole stack under stress: a heterogeneous numerical pipeline across x86-64, Apple Silicon, and CUDA. The data is deliberately hostile, with high cancellation rates and fragile intermediate states. The aim is not to pass friendly benchmark cases, but to reproduce the specified computation, including the same intermediate failures, not just the same final answer, bit for bit, across CPUs, GPUs, and toolchains.

Presenters
avatar for Andrew Drakeford

Andrew Drakeford

Director, UBS
Andrew Drakeford A Physics PhD who started developing C++ applications in the early 90s at British Telecom labs. For the last two decades, he has worked in finance developing efficient calculation libraries and trading systems in C++. His current focus is on making quant libraries... Read More →
Monday September 14, 2026 11:00 - 12:00 MDT
_6
  Scientific Computing

14:00 MDT

Component based or monolithic development for large C and C++ projects: Why not both?
Monday September 14, 2026 14:00 - 15:00 MDT
_1
Developers of large C and C++ projects have to choose between two main development paradigms: component based development and monolith based development, each one with its own advantages and disadvantages.

In component based development, projects can be split in multiple repositories that allow to do decouple development and releasing, which suits well for many organizations that split the work in different teams with different development speeds. But this approach requires efficient dependency management, complicates working simultaneously in multiple components and it adds extra challenges to implement Continuous Integration at scale.

On the other hand, in monolithic/monorepo base development, the build system tool manages the whole project efficiently, simplifying some development and integration flows. But it can be resource-intensive on the CI side and it also push the whole organization to move at the same speed, often with little or almost no versioning: the “live at head” paradigm

It is said that by Conway's law, organizations are forced in practice to choose between them. But what if modern C and C++ tooling allowed us to have the best of both worlds?

This talk will present the novel Conan2 “Workspaces”, a monolithic view of multiple independent components that can be dynamically added and removed from the monolithic build, and how leveraging CMake FetchContent, such a single monolithic build can be implemented.

Also, for the cases where not only CMake is involved, a quick overview of the orchestration of workspace incremental builds for heterogenous build systems and CI at scale will also be introduced.

The talk will describe the basics, tools, design and architecture of the solutions, and it will also show full working demonstrations for them.

Presenters
avatar for Diego Rodriguez-Losada Gonzalez

Diego Rodriguez-Losada Gonzalez

Conan co-founder, JFrog
Diego Rodriguez-Losada‘s passions are robotics and SW engineering and development. He has developed many years in C and C++ in the Industrial, Robotics and AI fields. Diego was also a University (tenure track) professor and robotics researcher for 8 years, till 2012, when he quit... Read More →
Monday September 14, 2026 14:00 - 15:00 MDT
_1
  General

14:00 MDT

Familiar C++ Patterns That Fail at Scale and the Design Shifts That Prevent Them
Monday September 14, 2026 14:00 - 15:00 MDT
_2
Some of the most expensive C++ bugs are not caused by obscure language features. Instead, they emerge from code that looks reasonable: shared ownership that quietly extends lifetimes, singletons that become invisible dependencies, and performance-driven decisions that harden into architecture.

This talk examines these common design-level failure patterns in large-scale C++ systems. We cover three concrete design shifts:

Lifetimes: Shifting from shared ownership to explicit lifetime boundaries. Coupling: Shifting from implicit global coupling to injected dependencies. Interfaces: Replacing permissive APIs with constrained interfaces using std::span, std::optional, std::variant, and strong types.

Each shift is presented with the failure pattern it addresses, the solution, and the design rule it yields. Attendees will leave with practical heuristics for designing systems that are easier to reason about, test, and evolve: all grounded in real-world failures and the redesigns that fixed them.

Presenters
avatar for Divya Chandrasekar

Divya Chandrasekar

Software Engineering Team Lead, Bloomberg
Divya Chandrasekar is an Engineering Leader at Bloomberg, where she leads FXGO Orders, a trading platform within FXGO. She holds a master’s degree in Computer Engineering from the University of Florida and has held multiple engineering roles at Bloomberg. With a strong technical... Read More →
DD

Devpriya Dave

Devpriya Dave is a software engineer on the FX Options team at Bloomberg. While at Georgia Tech obtaining her master's degree, she helped design and build the system behind Georgia Tech's Machine Learning for Trading online course. She is passionate about STEM mentorship and is always... Read More →
Monday September 14, 2026 14:00 - 15:00 MDT
_2
  Software Design

15:15 MDT

Back to Basics: Code Analysis
Monday September 14, 2026 15:15 - 16:15 MDT
_3
In the C++ ecosystem, we have powerful tools for understanding our programs before, during, and after they run. But compiler warnings, clang-tidy, cppcheck, sanitizers, debuggers, profilers, and coverage tools all answer different questions, and using them well starts with knowing which question you are asking.

This talk introduces code analysis from first principles. We will compare static techniques such as compiler diagnostics, linting, and include analysis with runtime techniques such as sanitizers, coverage instrumentation, and profiling. We will also briefly connect these tools to the direction of modern C++, including C++26 contracts and standard library hardening, where some assumptions that used to live only in comments, documentation, or debug modes become part of the program's checkable structure. Through small C++ examples, we will see what each category of tool can reveal, what it cannot prove, and how the tools complement each other.

Attendees will leave with a practical mental model for choosing the right analysis tool for the task at hand, interpreting its output, introducing analysis into an existing C++ codebase, and writing code that is easier for both humans and tools to understand.

Presenters
avatar for Alexsandro Thomas

Alexsandro Thomas

Senior Software Engineer, Zivid
Alexsandro Thomas is a Senior Software Engineer at Zivid AS specializing in C++ API development, build systems, and developer tooling. His interests include GPGPU, compiler technology, and low-level programming. In his free time he enjoys studying programming and natural languages... Read More →
Monday September 14, 2026 15:15 - 16:15 MDT
_3
  Back to Basics

15:15 MDT

Escaping the AST: A Data-Oriented, Lock-Free Parallel Compiler Architecture
Monday September 14, 2026 15:15 - 16:15 MDT
_4
The architecture of legacy compilers presents limitations for modern software development. As codebases scale, developers face increased compilation times. While language complexity is often cited, key architectural bottlenecks include pointer-chasing across deeply nested ASTs (cache misses), single-threaded type resolution, and significant thread-lock contention (RwLock) during parallel semantic analysis. What happens when we discard the Abstract Syntax Tree entirely and apply strict Data-Oriented Design to the compiler itself?

In this session, we will explore the internal architecture of the Vx compiler frontend—a heterogeneous systems programming language to safely maximize utilization of available CPU cores. We will dissect how to translate complex, tree-like program semantics into flat, contiguous arrays of 256-bit bit-packed Global Identifiers (GIDs).

By stepping away from traditional recursive tree-walking and object-oriented compiler design, attendees will learn how to implement high-throughput parallel pipelines.

This talk is not just for language designers. The architectural patterns used to build the Vx compiler—flattening graphs into arrays, deferred identity, and lock-free synchronization boundaries—are directly applicable to any C++ developer building high-performance, multithreaded systems.

Presenters
avatar for Aditya Kumar

Aditya Kumar

Software Engineer, Google
I've been working on LLVM since 2012. I've contributed to modern compiler optimizations like GVNHoist, Hot Cold Splitting, Hexagon specific optimizations, clang static analyzer, libcxx, libstdc++, and graphite framework of gcc.
Monday September 14, 2026 15:15 - 16:15 MDT
_4
  Embedded

15:15 MDT

The journey to "/W4 /WX": How hard could it be?
Monday September 14, 2026 15:15 - 16:15 MDT
_1
Building on the recent work of improving the quality of Sea of Thieves' codebase by upgrading from C++14 to C++20, this talk will focus on the work that has went into enabling warnings as errors on the game, and more.

Rare will discuss the motivations behind wanting to crank up the warning level, and to flick the "warnings as errors" switch after 10 years of development in their multi-million line Unreal Engine code base.

What were the challenges? How much effort did it take? Was it worth it? Did we find any bugs? Did we stop at just "/W4 /WX"? What warnings did we find the most useful? What warnings were deemed unhelpful? All of these questions and probably more will be answered throughout this session.

Presenters
avatar for Keith Stockdale

Keith Stockdale

Senior Software Engineer, Rare Ltd
Keith Stockdale is a Northern Irish senior software engineer who has been working on the Engine and Rendering teams at Rare Ltd for the last 8 years working on Sea of Thieves. At Rare, Keith's main areas of focus are involved in maintaining and creating general purpose simulations... Read More →
Monday September 14, 2026 15:15 - 16:15 MDT
_1
  GameDev

15:15 MDT

Catching Leaks: How to stop a C++ program at the exact instruction that leaks memory
Monday September 14, 2026 15:15 - 16:15 MDT
_6
Memory leaks are very hard to treat. We have reliable tools like valgrind or AddressSanitizer to tell us whether or not an application has leaked memory, but current tools cannot tell us where the leak happens (they can tell us where the allocation happened,which is not the same).

I show that it is possible to run an analysis that is equivalent to running a garbage detection pass after every instruction and use that to find the actual cause of memory leaks in open source applications.

Using a garbage detection algorithm on record-and-replay recording, one can overcome the most obvious obstacle: stopping a program a program after every instruction or running garbage detection algorithms is very slow, but we can effectively run a bisection search on the recorded timeline to avoid having to evaluate after every instruction.

The goal is attribution to source code. Are we limited to reporting the instruction that overwrites the last reference to allocated memory or can we actually diagnose a specific error for a concrete function?

Presenters
HM

Henning Meyer

Henning is a C++ software developer with ten years of experience ranging from small start-ups to large enterprises. He has PhD in Mathematics from the University from Kaiserslautern and is currently working on new debugging tools for C++.
Monday September 14, 2026 15:15 - 16:15 MDT
_6
  Tooling & Ecosystem

16:45 MDT

AEMBER: Modern Embedded C++ Without the Chaos
Monday September 14, 2026 16:45 - 17:45 MDT
_6
Building embedded systems wastes time on infrastructure instead of features. Before running application logic, developers lose hours bootstrapping init systems, wiring services, debugging startup failures, and fighting tooling never designed for constrained or early-boot environments. AEMBER is a developer-first PID1 (init system) that eliminates this overhead by providing a modern C++ runtime for process supervision, container orchestration, and service management - letting you focus on your application, not your plumbing.

This talk demonstrates how C++23 enables robust embedded systems without sacrificing performance. We'll explore std::expected for exception-free error handling, if consteval for compile-time optimization paths, and deducing this for zero-overhead policy classes. You'll see how monadic operations compose system calls into clean pipelines, and how modern C++ features build type-safe APIs for namespaces, cgroups, and process management.

Starting from main(), we'll trace AEMBER's architecture: how components compose, how errors propagate through std::expected chains, and how C++23 patterns enable embedded systems to be both safe and fast. We'll wrap up with a live demo showing AEMBER managing containers and services in real-time. You'll leave with concrete techniques for building maintainable embedded infrastructure using cutting-edge C++.

Presenters
avatar for Arian Ajdari

Arian Ajdari

Software Engineer, Bertrandt GmbH
Arian Ajdari is a Software Engineer working on cutting-edge applications in the field of smart home appliances. His daily work includes discussions with clients, gathering requirements, building use-cases and implementing different solutions using C++. Arian possesses a deep understanding... Read More →
Monday September 14, 2026 16:45 - 17:45 MDT
_6
  Embedded

16:45 MDT

You’re absolutely wrong! How to get agents to solve complex problems with complex code.
Monday September 14, 2026 16:45 - 17:45 MDT
_1
Modern coding agents are incredible, but they still struggle with the kind of large, unstructured codebases that are common in C++. There are several techniques and tools that can make them perform much better. Here we show examples and demos of how to get your agent to work better with complex code. The focus is on providing an overview on current techniques and how we’ve found they work best. - Skills, memory and MCP - these have all been hyped hard, we’ll sort through where they are actually useful. - All agents (Claude, Copilot, Codex, Gemini) support these - some better than others. - What a skill is and what it isn’t - How to use persistent memory - Why MCP servers are still needed (but not always) - Context engineering. - Context management keeps changing - we’ve got autocompaction and 1M token windows now, why should we care anymore? - When to “manage” your agent’s context window and when it’s a bad idea - How to understand where context is being spent. - How and why to use subagents - these are almost always available but the capabilities in different frontends are exposed in different ways. - Spec Oriented Development: buzzword, euphemism for vibe coding or the future of programming? - What is it? - What tools exist? Covering options such as SpecKit, Kiro, etc. - Working in parallel with agent teams! - How to get started without having to learn anything (almost)! - Runtime context. - How to give your agent the best possible feedback path so you can stop micromanaging it and leave it to complete longer, more complex tasks. - Techniques including testing, CI integration and recording-based technology

Presenters
avatar for Greg Law

Greg Law

CEO, Undo.io
Greg is co-founder and CEO at Undo. He is a programmer at heart, but likes to keep one foot in the software world and one in the business world. Greg finds it particularly rewarding to turn innovative software technology into a real business. Greg has over 25 years' experience in... Read More →
MW

Mark Williamson

CTO, Undo
I went through Cambridge University, UK and got drawn into the local startup ecosystem.  I've been at Undo.io building time travel debuggers for Linux C++ developers for the past 11 years, eventually landing in my current role as CTO.

Right now I'm cramming AI-related knowledge i... Read More →
Monday September 14, 2026 16:45 - 17:45 MDT
_1
  General

16:45 MDT

My DAG Ate All My Cores: Identifying and Resolving Build Graph Bottlenecks
Monday September 14, 2026 16:45 - 17:45 MDT
_5
Every C++ developer runs their build system dozens of times a day, yet few think about what it actually computes. Underneath every cmake --build or ninja invocation lies a directed acyclic graph, a DAG of dependencies that determines what gets rebuilt, in what order, and how much parallelism is available. When builds are slow, when incremental rebuilds trigger more work than expected, or when CI bottlenecks in surprising places, the root cause is almost always a structural property of this graph. Most developers never look at it.

This talk makes the build graph visible and actionable. Through curated examples, we will visualize dependency graphs and expose the common pathologies: overly connected "hub" headers that invalidate half the build when touched, deep critical paths that starve parallelism even on a 128-core machine, and accidental edges introduced by includes that no one questioned. These are not just build performance issues: they are architectural issues wearing a different hat. Your build graph is the ground truth of your codebase's structure, whether or not it matches the diagram in your team's documentation.

Armed with this mental model, we will walk through practical techniques for reshaping the graph: measuring critical path length from .ninja_log , identifying high-fan-in nodes, breaking costly edges with forward declarations and interface segregation, and using graph analysis as an automated architectural fitness function in CI. Worked examples will show concrete before-and-after measurements. You will leave with a new way of seeing your codebase, not as files in folders, but as a graph you can visualize, measure, and deliberately reshape.

Presenters
avatar for Florent Castelli

Florent Castelli

Software Engineer, EngFlow
Monday September 14, 2026 16:45 - 17:45 MDT
_5
  Tooling & Ecosystem
 
Tuesday, September 15
 

09:00 MDT

What's New for C++ in Visual Studio Code: C++ and AI Tooling for Your Build, Your Code, Your Workflow
Tuesday September 15, 2026 09:00 - 10:00 MDT
_6
Modern C++ development spans platforms, build systems, and increasingly complex project structures. In this landscape, Visual Studio Code has carved out its distinct position as a lightweight, extensible editor that works where you do, with first-class extensions built on decades of C++ language services and build system integration. This year's update deepens both of those foundations and opens them up to AI-driven workflows powered by GitHub Copilot.

This session walks through what's new across three dimensions of C++ development in Visual Studio Code. For the inner loop, we'll cover practical improvements to everyday compile-test workflows, including CMake target bookmarks and Run Without Debugging. For writing and understanding code, we'll show how the C/C++ extension's language services now surface rich project understanding to GitHub Copilot, giving AI assistance real awareness of your code structure instead of relying on generic pattern matching. For your workflow, we'll demonstrate how AI capabilities compose across different modes of working: inline suggestions for hands-on editing, agent coordination for multi-file refactoring, and CLI sessions for long-running tasks and deeper codebase analysis you can revisit on your own schedule.

Throughout the session, we’ll use real-world C++ problems to demonstrate where these tools meaningfully improve productivity and where they intentionally stay out of your way. Finally, we’ll show you how to inform GitHub Copilot about your team's best practices and scale them across your code through extensibility points like skills, custom instructions, and custom agents.

Presenters
avatar for Sinem Akinci

Sinem Akinci

Sinem Akinci graduated from the University of Michigan with a focus in Industrial Engineering and Computer Science. She now is the Product Manager at Microsoft working on Cross-platform and CMake developer experiences in Visual Studio and VS Code
avatar for Ben McMorran

Ben McMorran

Principal Software Engineer, Microsoft
Ben McMorran studied computer science at Worcester Polytechnic Institute. Since graduating, Ben has worked on C++ developer tooling at Microsoft as a Principal Software Engineer with a recent focus on AI-powered developer experiences.
Tuesday September 15, 2026 09:00 - 10:00 MDT
_6
  Tooling & Ecosystem

14:00 MDT

Breaking the Speed Limit: Building a High-Throughput Hashing Engine With C++26
Tuesday September 15, 2026 14:00 - 15:00 MDT
_6
Modern storage hardware has evolved at a breakneck pace. PCIe Gen 5 NVMe drives can push data at 10 GB/s, yet standard C++ file abstractions often leave them starving for data. Many developers think they need to abandon portability in favor of unmaintainable, OS-specific kernel bypasses to achieve the throughput necessary to saturate these drives. This session is for developers writing high-throughput, performance-critical applications who want to hit bare-metal speeds without sacrificing clean architecture, cross-platform support, or type safety.

Using a high-throughput cryptographic hashing engine as a concrete case study, this presentation demonstrates how to design a hardware-saturating data pipeline built entirely on the idioms of C++26. We will explore how the mathematical design of an algorithm - specifically BLAKE3's binary Merkle tree structure - can be mapped directly to wide SIMD vector lanes and concurrent CPU cores. We will walk through an execution model that completely bypasses the OS page cache, orchestrates memory without heap allocations on the hot path, and unifies OS kernel quirks in a portable way.

By the end of this presentation, you will learn how to replace rigid thread pools with lock-free, asynchronous execution graphs using Sender/Receiver paradigms (std::execution) and vectorization (std::simd). Crucially, we will focus on the build engineering required to make this work today. We will cover how to use advanced CMake tooling to safely compile multi-architecture vector binaries from a single source of truth, how to prevent LTO cross-contamination, and how to structure your pipeline today to seamlessly absorb upcoming C++ features in a world of trailing vendor toolchains.

Presenters
YS

Yannic Staudt

co-founder, tipi.build
Tuesday September 15, 2026 14:00 - 15:00 MDT
_6
  General

14:00 MDT

Running Compiler Explorer in 2026: Sandboxes, Storage, and Strangers' Code
Tuesday September 15, 2026 14:00 - 15:00 MDT
_2
Compiler Explorer looks simple: type code, get assembly. Underneath: a fleet of sandboxed machines running hundreds of compilers across dozens of languages, terabytes of binaries to keep current, and the ongoing problem of executing arbitrary code from internet strangers.

A lot has changed in the 14 years that the site has been around: The sandboxing layers that let it run other people's code without losing sleep. The storage situation that very nearly broke it, and the content-addressable filesystem that quietly rescued everything. The operational war stories, the migration sagas, and the bits that are far more boring than they look from the outside. Along the way you'll see some of CE's recent features in their natural habitat, and get a peek at what's coming next.

You'll come away with a working mental model of how to run untrusted compilation at scale - and why the parts that look easy are almost always the hard ones.

Presenters
avatar for Matt Godbolt

Matt Godbolt

Programmer and sometime verb, Compiler Explorer
Matt Godbolt is the creator of the Compiler Explorer website. He is passionate about writing efficient code. He has previously worked at a trading firm, on mobile apps at Google, run his own C++ tools company and spent more than a decade making console games. When he's not hacking... Read More →
Tuesday September 15, 2026 14:00 - 15:00 MDT
_2
  General

15:15 MDT

C++ in an AI World
Tuesday September 15, 2026 15:15 - 16:15 MDT
_1
Last year, the title of this talk would have been "AI in a C++ World." That it isn't anymore tells you most of what changed.

A year ago, AI was the visitor we were evaluating. Now, it is the room we work inside, and the question for C++ programmers is no longer whether to take the technology seriously but how to keep doing serious work in its presence.

Another year of using these tools in earnest on production C++ has clarified what works, and given me an actual workflow to point at instead of a set of slogans.

I'm a professional C++ developer, and yet I haven't written a line of code since last November. Not because I've not written any code, but because AI has written every line.

It is not a theoretical presentation, but a working practitioner's report. I'll walk you through the development workflow I now use for serious C++ development.

Along the way I'll cover what C++ developers actually need to know about how LLMs work, what the agentic loop is, and how to get production-quality C++ out of these systems. The tone is practical, but opinionated, though those opinions are based on personal experience.

If you are not yet using AI as another independent member of your development team, or if you think I'm completely off my rocker, then this talk is definitely for you.

Presenters
avatar for Jody Hagins

Jody Hagins

Director, LSEG / MayStreet
Jody Hagins has been using C++ for the better part of four decades. He remains amazed at how much he does not know after all those years. He has spent most of that time designing and building systems in C++, for use in the high frequency trading space.


Tuesday September 15, 2026 15:15 - 16:15 MDT
_1
  General

15:15 MDT

Mock Any Function in C++ Without Changing a Single Line of Code
Tuesday September 15, 2026 15:15 - 16:15 MDT
_6
In many languages, you can mock almost anything. Python has unittest.mock, Java has Mockito and PowerMock, and C# has Moq. In C++, you can usually mock only what was designed to be mockable — and little else. Want to mock a free function? Wrap it in an interface. A static method? Refactor to a template. A non-virtual member? Redesign the class hierarchy. The cost is real: developers either shape production code around testing-tool constraints instead of domain needs, or they simply leave hard-to-mock code untested.

This talk introduces [LibraryName], a new C++ mocking library we developed (and plan to publish soon as open source) that can mock almost any C++ callable — free functions, static methods, non-virtual members, private members, templates, lambdas, and even extern "C" routines — without modifying the code under test. Developed and battle-tested at [CompanyName] for three years across a very large C++/C codebase, it aims to deliver a first-class testing experience for C++. Under the hood it uses runtime binary patching — replacing function prologues with redirections at test time, restoring them on scope exit — all surfaced through familiar Google Mock syntax.

We'll show [LibraryName] in action, walk through the patching mechanism, and share how to get started -- you'll walk away ready to test almost any function, regardless of how it was designed. Strong test coverage has always been essential, and AI-assisted code generation only increases the need for reliable testing backpressure. C++ deserves mocking tooling that matches.

Presenters
IE

Ilya Ermakov

Ilya Ermakov graduated from Vanderbilt University with a major in Computer Science. Since graduating, Ilya has worked at Bloomberg where he is now a Software Engineer working on Distributed Systems and C++ tooling.
BR

Brian Rudo-Hutt

Brian Rudo-Hutt is a Senior Software Engineer at Bloomberg and organizes engineering-wide initiatives to improve testing, safety, and software maturity. Brian holds Computer Science and Electrical and Computer Engineering degrees from Cornell University and lives with his family in... Read More →
RZ

Ruifeng Zhang

Bloomberg LP
Tuesday September 15, 2026 15:15 - 16:15 MDT
_6
  Tooling & Ecosystem

16:45 MDT

From User to Contributor: Fixing Bugs and Adding Features in Clang
Tuesday September 15, 2026 16:45 - 17:45 MDT
_6
Clang is the C++ compiler used by hundreds of millions of developers every day, yet most of those developers have never looked inside it. The codebase can feel intimidating, with millions of lines of C++, an unfamiliar architecture, and a review process with its own customs. But once you know the map, contributing is surprisingly accessible.

This session is a live, code-first walkthrough of the full contribution cycle for Clang. Starting from a clone of the LLVM monorepo, we will configure a development build, locate the right subsystem for a real reported bug, write a regression test, fix the bug, and verify the fix. We will then extend that foundation to implement a small but complete language feature: adding a new diagnostic, walking through Sema, the AST, and the diagnostic engine as we go. Every step attendees see on screen can be replicated on their own laptops during and after the session.

Attendees will leave with a mental model of Clang's layered architecture (driver, frontend, Sema, CodeGen), a workflow for finding the code responsible for any given compiler behavior, and enough familiarity with the test infrastructure and review process to open their first pull request.

Presenters
MI

Matheus Izvekov

I am a compiler engineer working on Clang, employed by the C++ Alliance.
Tuesday September 15, 2026 16:45 - 17:45 MDT
_6
  Tooling & Ecosystem
 
Wednesday, September 16
 

09:00 MDT

Turbocharging Native Code Performance: Compiler Optimizations, Profile-guided Optimizations, and Beyond
Wednesday September 16, 2026 09:00 - 10:00 MDT
_4
Making native code fast is a team sport: efficient algorithms, high-performance libraries, memory-conscious design, and modern hardware all play a role. But the critical link between your code and the hardware it runs on is the optimizing compiler.

This talk explores new & improved compiler optimizations in Visual Studio 2026, and how these improve the performance of existing C++ code with minimal source changes. We will examine both architecture-independent optimizations (such as improved scalar replacement, vectorization, and loop transformations) and architecture-specific enhancements (such as AVX-512 and NEON specific optimizations). Along the way, we will connect high-level C++ constructs to the generated assembly and CPU behavior to build an intuition for how performance improvements are realized. While the talk discusses Visual Studio code generation & optimizations, the tools and analysis apply to all native platforms & compilers.

We will also introduce sample-based profile-guided optimizations (SPGO) which uses the runtime characteristics of your application to guide optimization decisions, WITHOUT requiring traditional instrumentation. You will learn how SPGO works, how to apply it in practice, and where it delivers measurable gains: typically in the 5-15% range across real world native codebases.

Attendees will leave with a practical understanding of how to reason about native code performance, and how to leverage SPGO to turbocharge the performance of their code.

Presenters
EB

Eric Brumer

Eric is an engineering manager on the Microsoft C++ Team, working on the compiler back-end.
Wednesday September 16, 2026 09:00 - 10:00 MDT
_4
  GameDev

14:00 MDT

Automatic Splitting of Translation Units: Compiler-Agnostic Compiler Frontend Parallelization
Wednesday September 16, 2026 14:00 - 15:00 MDT
_6
AI agents are accelerating code generation at an unprecedented pace, yet C++ file is still compiled as a monolithic translation unit, meaning a many-core machine often cannot rebuild a template-heavy file much faster than a single core. Header-heavy designs, inline functions, and templates compound the problem: the same bodies are parsed repeatedly, and small edits can invalidate an entire translation unit.

This talk presents a compiler-agnostic technique for splitting translation units into smaller independently compilable units. Using libclang, the tool rewrites headers and sources into declaration-only interfaces plus generated .cpp fragments, backed by a shared preamble that can turn into a C++ module, precompiled header, cached serialized AST and a source-map. The fragments compile in parallel, then link into a binary functionally equivalent to the original monolithic build.

Expect benchmarks from major codebases covering compile-time, link-time, and run-time performance; live demos of fast incremental updates that avoid reprocessing unchanged code as well as an analysis of the resulting binaries layout.

Presenters
avatar for Damien Buhl

Damien Buhl

co-founder, tipi.build
Damien (aka daminetreg), co-founder tipi.build by EngFlow is an enthusiast C++ developer. Opensource entrepreneur, CppCon Speaker, GameMaker.fr community founder, Qt for Android contributor and Boost.Fusion maintainer since 2014.
Wednesday September 16, 2026 14:00 - 15:00 MDT
_6
  Tooling & Ecosystem

15:15 MDT

AI is UB with Better PR
Wednesday September 16, 2026 15:15 - 16:15 MDT
_4
C++ runs the world’s systems, and with that comes a responsibility for safety and stability. Avoiding AI entirely gives up on incredible potential benefits, but using AI without guardrails poses significant risks to our critical systems. How does AI fit into this world? This talk examines effective and ineffective approaches to using AI in systems that cannot afford “slop.” We will explore several case studies where AI produced significant value in C++, and several where it did not. The pattern that emerges is consistent: AI thrives when it is orchestrating well-defined, deterministic components, translating between them intelligently without being trusted to reason correctly on its own. When AI is asked to be the system rather than connect the system, things fall apart.

Presenters
MK
avatar for Andy Soffer

Andy Soffer

Andy Soffer is a lapsed mathematician turned software engineer. He spent eight years at Google, before founding BrontoSource in late 2024. His time at Google culminated in leading the C++ Core Libraries team (responsible for Abseil and GoogleTest) and the C++ Large Scale Refactoring... Read More →
Wednesday September 16, 2026 15:15 - 16:15 MDT
_4
  Robotics & AI

15:15 MDT

Works on My Machine, Works in CI: Treating Your Build Toolchain as a Dependency
Wednesday September 16, 2026 15:15 - 16:15 MDT
_6
Modern C++ development has embraced package managers like Conan and vcpkg for dependency management, gaining reproducibility and productivity. However, a significant weak point remains: the build toolchain. Unlike standard dependencies, the disparate set of tools comprising the compiler, linker, standard libraries, and OS-specific headers often remains outside this managed ecosystem. This gap leads to frequent complications, where misaligned versions between local environments and CI cause build errors and subtle ABI incompatibilities.

The operational cost of maintaining these toolchains is high. Updating a compiler version often necessitates the creation and deployment of new VM images or manual infrastructure updates, a process that can be even more complex if specialized environments like CUDA are involved. These hurdles directly impact engineering productivity and organizational alignment. Docker is a popular solution to isolate toolchains, but it does not support all the mainstream platforms.

This talk proposes a shift in perspective: treating the build toolchain as just another dependency. We will explore how leveraging toolchain isolation allows developers to express specific toolchain versions within their project manifests—using cross-platform tools like Conan and vcpkg to ensure strict repeatability across local developer environments and CI machines.By automating the fetching and configuration of the entire compiler suite, teams can ensure perfect alignment across all environments, simplify the upgrade path, and ultimately boost engineering velocity.

Presenters
avatar for Luis Caro Campos

Luis Caro Campos

JFrog
Luis is a Electronics and Computer Engineer based in the UK, with previous experience as a C++ engineer in the field of Computer Vision and Robotics. With a passion to enable C++ engineers to develop at scale following modern DevOps practices. He is currently part of the Conan team... Read More →
Wednesday September 16, 2026 15:15 - 16:15 MDT
_6
  Tooling & Ecosystem

16:45 MDT

CMake: Making Hard Things Easy
Wednesday September 16, 2026 16:45 - 17:45 MDT
_1
Modern C++ development involves much more than compiling source files. Cross-platform builds, dependency management, C++ modules, package metadata, SBOM generation, CI infrastructure, and distributed builds have all increased the complexity of software engineering over the last two decades.

CMake has evolved alongside those challenges.

This talk explores how modern CMake helps make difficult software-engineering problems more manageable through targets, dependency modeling, metadata generation, debugging tools, and scalable build orchestration.

We will examine how CMake supports C++20 modules, including dynamic dependency scanning, build graph updates, and import std.

We will also look at CPS and SBOM generation together: CPS provides machine-readable package metadata, while SBOM support helps CMake expose software supply-chain information from the dependency graph.

Next, we will discuss debugging CMake itself using the CMake debugger protocol, and debugging builds using the CMake Instrumentation API to understand where time is spent during configuration and build execution.

Finally, we will examine distributed execution and build acceleration, exploring options available to CMake users in both open-source and commercial environments.

Along the way, we will discuss the real-world challenges, trade-offs, and lessons learned from evolving a long-lived build system to meet the demands of modern C++ development.

This is not your mother’s CMake.

Presenters
avatar for Bill Hoffman

Bill Hoffman

Kitware, CTO
Mr. Hoffman is a founder of Kitware and currently serves as CTO. He is the original author and lead architect of CMake, an open source, cross-platform build and configuration tool that is used by hundreds of projects around the world. Using his 20+ years of experience with large software... Read More →
Wednesday September 16, 2026 16:45 - 17:45 MDT
_1
  General

16:45 MDT

C++ Core Guidelines Enforcement in Practice
Wednesday September 16, 2026 16:45 - 17:45 MDT
_6
The C++ Core Guidelines is quickly gaining popularity as the main C++ coding standard in the industry. The official introduction of the standard states the following: "Many of the rules are designed to be supported by an analysis tool. One way of thinking about these guidelines is as a specification for tools that happens to be readable by humans."

We took up this challenge: we built the tools, implemented a subset of the C++ Core Guidelines, and applied them to more than 8,000 industrial embedded software projects. That was not an easy undertaking, because the defined “rule enforcements” contain all kinds of caveats, shortcomings, unclarities, exceptions etc.

During this talk, we will explore the conceptual obstacles we encountered during implementation, how we have addressed them, and what remains to be done to make the C++ Core Guidelines the de facto standard in C++ programming.

Presenters
PJ

Paul Jansen

Paul Jansen (1967) graduated from the University of Amsterdam in computing science and philosophy (both cum laude). At Philips Research he was a computer scientist in the field of compiler construction and domain-specific languages. After a brief stay at Atos Origin and QA Systems... Read More →
Wednesday September 16, 2026 16:45 - 17:45 MDT
_6
  Tooling & Ecosystem
 
Thursday, September 17
 

09:00 MDT

Tying up Loose Threads: Making Your Project No-GIL Ready
Thursday September 17, 2026 09:00 - 09:30 MDT
_5
Python's Global Interpreter Lock, which determines which single thread can execute native Python code and call C API functions, simplifies writing multithreaded code. By default, the most popular C++ bindings to this API, pybind11 and Cython, implicitly enables the GIL by default. However, sticking with this execution model leaves out extra performance afforded by modern multicore CPUs with hyperthreading, as automatic locking and unlocking of the GIL does not scale well with thread counts, especially in performance-sensitive workloads.

The newfangled free-threaded interpreter promises salvation when running either pure Python code or with compiled extensions. General multithreading rules apply (prefer thread-local variables, using locks to prevent simultaneous access of shared data), but when dealing with projects containing compiled extensions that directly or indirectly interface with Python's C API, more porting rules also apply.

Key porting tips, including projects using the Limited API, include: port native code away from C API functions that avoid borrowed references because they aren't thread-safe; modify unit tests to catch concurrency bugs arising from assuming the presence of the GIL; and extend CI coverage of Python interpreters both for testing and to build free-threaded compatible wheels.

Presenters
CL

Charlie Lin

Freelancer, N/A
Thursday September 17, 2026 09:00 - 09:30 MDT
_5
  Tooling & Ecosystem

14:00 MDT

C++ in the Age of AI: How Visual Studio Is Evolving
Thursday September 17, 2026 14:00 - 15:00 MDT
_6
For almost 30 years, Visual Studio has been a core part of the C++ developer's toolkit on Windows. This year, we're building on that foundation with investments across three themes: making the IDE faster and more responsive for large codebases, advancing compiler conformance and runtime performance, and integrating AI-powered workflows that help you debug, refactor, and optimize more effectively. Beyond the IDE, we'll show you how AI-powered command-line tools can become a natural part of your development process. This session combines demos and practical guidance so you can get the most out of these tools right away. Come with curiosity, leave with new techniques you can apply immediately.

Presenters
avatar for David Li

David Li

Game Developer Product Manager, Microsoft
David Li is the Game Developer Product Manager at Visual Studio with 12 years of experience in the software industry. As a gamer himself, David is especially passionate about enhancing game developer productivity through improving tooling for Visual Studio. In his free time, he enjoys... Read More →
avatar for Augustin Popa

Augustin Popa

Senior Product Manager, Microsoft
I am a product manager on the Microsoft C++ team, working on the Visual Studio IDE and vcpkg, the C/C++ package manager.
Thursday September 17, 2026 14:00 - 15:00 MDT
_6
  General

14:00 MDT

Generating Reliable Reference Documentation for Modern C++ Using the Clang AST
Thursday September 17, 2026 14:00 - 15:00 MDT
_5
Teams writing modern C++ libraries with concepts, niebloids, deduction guides, and SFINAE-driven overload sets either accept wrong reference documentation or maintain a Doxygen + XSLT + Sphinx pipeline of workarounds. A different approach is to read C++ from the Clang/LLVM AST, separate corpus extraction from output templates, and recognize common idioms as first-class. This allows the source to stay clean from workarounds.

Doxygen-based pipelines all share these failures on modern C++. Constraint, noexcept, and explicit specifier expressions get truncated or dropped. Niebloids and function objects show as wrappers, not callables. Overloads distinguished by SFINAE or concepts scatter across the output, and CRTP base classes render with the wrong members. All of this disappears when the tool reads the compiler's AST and is able to instantiate specializations.

The talk then covers the architecture of MrDocs, an open-source documentation generator built on Clang/LLVM. Corpus extraction handles the redeclaration, template instantiation, and overload resolution problems that break naive AST traversal. Idiom recognition treats modern patterns as first-class metadata: niebloids, overload sets, concept constraints, requires-clauses preserved verbatim, function-object auto-detection, SFINAE overload sets, and deduction guides. It also captures the specifiers: explicit, noexcept, consteval, storage class, defaulted and deleted functions, and attributes. The templating layer gives full control over the output (HTML, AsciiDoc, Markdown, XML, or custom formats) without forking the tool.

The session is heavy on code from real C++ template libraries, with examples drawn from fmt, nlohmann/json, mp-units, and several Boost and Beman libraries. By the end, you will know why partial AST tools break on modern C++, what an alternative architecture looks like, and which idioms it has to recognize.

Presenters
AD

Alan de Freitas

Software Engineer, The C++ Alliance
Thursday September 17, 2026 14:00 - 15:00 MDT
_5
  General

14:00 MDT

Using Modules in a Real Project
Thursday September 17, 2026 14:00 - 15:00 MDT
_3
C++20 modules are finally usable end to end, from your own modules to 'import std;' The functional build-system support with real diagnostics. This talk teaches modules the way #include was once taught: with small files, a build, and concrete use cases. Modules stopped being experimental somewhere around 2025. This session builds the mental model from scratch: what a primary module interface unit is, how partitions and implementation units fit together, and, crucially, how import differs from #include in ways that matter day to day. It uses a small library, exposes it as a module, splits it across partitions, consumes import std; and observes the compile-time effect. Then it answers the questions every team hits in week one: how modules interact with macros, with templates in headers, with header-only dependencies, and with a mixed codebase that can't convert everything at once. The examples will be using CMake, clang and recent gcc. You will leave able to structure a small library as a module, explain why a macro didn't cross a module boundary, and plan an incremental adoption that doesn't require converting the whole tree.

Presenters
avatar for Erez Strauss

Erez Strauss

Strat - Sr Software Engineer, Eisler Captal
Erez Strauss worked in Banks and Hedge Funds while focused on low latency systems.
Thursday September 17, 2026 14:00 - 15:00 MDT
_3
  General

15:15 MDT

Building C++20 Modules: The Rest of the Story
Thursday September 17, 2026 15:15 - 16:15 MDT
_2
There is no classical treatise on the design and implementation build systems; no faithful textbook every toolchain engineer has on their bookshelf. If there were we would need to throw it out anyway, because C++20 modules required a significant rethink of how build systems orchestrate compilation of C++ software.

It's been said over and over again that C++20 modules complicate the classic compile and link steps for C++. However, few have dived into how exactly build systems are dealing with this step-change in complexity. Talks will demo a few raw compiler invocations and say no more about the subject. This leaves engineers unequipped to deal with problems that arise in their builds; frustrated by opaque error messages and baffling build logs.

In this talk, we're going to fill in the rest of the blanks and explore exactly how build systems are tackling modules.

Presenters
avatar for Vito Gamberini

Vito Gamberini

Senior R&D Engineer, Kitware
Coding build systems to build systems code.
Thursday September 17, 2026 15:15 - 16:15 MDT
_2
  General

15:15 MDT

Leveraging LLM to Generate Unittests for Notifiers in Taskflow
Thursday September 17, 2026 15:15 - 16:15 MDT
_6
Notifiers are a critical synchronization primitive in task-parallel programming systems such as Intel TBB and Taskflow, responsible for efficiently sleeping and waking worker threads as tasks become unavailable and available over and over again, directly impacting scheduler throughput and latency. Correctness here is non-negotiable: a single missed wakeup can significantly hamper the performance of an entire program. Yet writing strong unit tests for notifiers is notoriously difficult, because the bugs they target, lost wakeups, spurious wakes, race conditions, are timing-dependent, non-deterministic, and often only surface under specific thread interleavings that are hard to force reliably.

The problem is compounded in practice. Notifier implementations evolve constantly: small algorithmic tweaks, memory ordering changes, and refactors across systems demand a fresh round of carefully constructed tests. This is tedious, expertise-heavy work that takes a lot of time and engineering effort. In this talk, we explore using Large Language Models (LLMs) to automate the generation of the unit tests for notifiers. Specifically, we will demonstrate how LLM-generated tests, guided by proper prompts can systematically stress the two-phase wait protocol across Notifiers in Taskflow. We will show this in a widely used Notifier implemented in Taskflow. We are able to find an undiscovered bug that has been existing in the project.

Presenters
SS

Snikitha Siddavatam

Snikitha Siddavatam is a Computer Science and Data Science student at the University of Wisconsin-Madison, expected to graduate in May 2027, with coursework spanning machine learning, artificial intelligence, distributed systems, data visualization, and advanced algorithms. Snikitha... Read More →
Thursday September 17, 2026 15:15 - 16:15 MDT
_6
  General

15:15 MDT

The Latency Slippage: Understanding the Hidden Costs of Caching for Low Latency C++
Thursday September 17, 2026 15:15 - 16:15 MDT
_1
Choosing cache-friendly data structures is a well-known optimization, but it's rarely the whole story. This talk goes deeper, exploring the hardware mechanics that dictate real-world performance and showing where significant gains are still left on the table.

We'll start from the ground up: what actually happens inside the cache hierarchy when your code issues a memory read or a software prefetch? Understanding the hardware lets us answer, when you should prefetch manually, and when you should trust the hardware prefetcher.

From there, we'll examine the invisible cost of multi-core C++. Cache coherency protocols (MESI/MOESI) can silently degrade performance through false sharing, RFO stalls, and coherency storms. We'll walk through how to diagnose these issues using hardware performance counters and how to eliminate them.

Additionally, we will contrast these behaviors across the data cache (DCache) and instruction cache (ICache), and analyze how Translation Lookaside Buffers (TLBs) impact overall memory read latency.

Finally, we'll tie it all together by combining hardware insight with application profiling data to arrive at practical strategies for low latency C++, packaged as an application-aware memory allocator.

Presenters
SG

Sanchit Gupta

Sanchit Gupta graduated from Indian Institute of Technology, Madras with Honours in Bachelors of Technology in Computer Science and Engineering. Since graduating, Sanchit has worked for Graviton as a Low latency Software Developer
Thursday September 17, 2026 15:15 - 16:15 MDT
_1
  General

16:45 MDT

Getting More Out of AI in C++: Custom Hooks, Skills, and MCP servers
Thursday September 17, 2026 16:45 - 17:15 MDT
_3
AI coding agents are transforming how we write C++ code and come with a growing extensibility stack. Between hooks, skills, and MCP servers it's not obvious when to reach for which in your day to day workflow. This talk demonstrates the differences through demos in a real C++ codebase. We'll build a hook that runs the project's linter and lets the agent fix any issues it finds, create a skill to flag C++ performance pitfalls, and use an MCP server to verify portability across compilers, with each technique solving a problem the others can't. Along the way, you'll see how these mechanisms compose into a single workflow. Whether you're just getting started with AI tooling or already using it daily, you'll leave knowing exactly which tool to reach for and how to get the most out of your AI coding agent for C++ development.

Presenters
AK
Thursday September 17, 2026 16:45 - 17:15 MDT
_3
  General

16:45 MDT

Extending Google Test for Statistical Benchmarking, CUDA Profiling, and CI Performance Regression
Thursday September 17, 2026 16:45 - 17:15 MDT
_4
Benchmarks shouldn't live in a different world from tests. Most C++ projects already use Google Test, but the moment performance enters the picture, developers reach for separate tools, separate workflows, and ad-hoc timing loops that don't survive contact with CI. This talk argues for a different default: treat performance measurements as first-class tests. They are written in the same harness, run in the same suite, and fail the same builds.

Using a real C++23 framework built on top of Google Test, the session shows what that looks like in practice. Semantic macros distinguish throughput, latency, and contention tests; built-in statistical analysis tracks medians, percentiles, and coefficient of variation. Adaptive thresholds scale with payload size, so tiny operations and multi-megabyte workloads aren't held to the same stability expectations.

Once benchmarking lives inside the test framework, the rest of the performance toolchain follows. Five CPU profiler backends drop in behind a single --profile flag: perf, gperftools, bpftrace, RAPL, and callgrind. Attaching a memory profile to a test prints bandwidth, efficiency, and a CPU-bound or memory-bound classification with no extra code. The same harness extends to CUDA through a fluent kernel builder that captures launch configuration, achieved occupancy, transfer overhead, multi-GPU scaling efficiency, and thermal throttling. Nsight Compute drops in through the same --profile flag.

The payoff is CI integration that's nearly automatic. A companion CLI tool compares baseline and candidate runs, applies statistical thresholds, posts markdown reports on pull requests, and fails the build on regressions. The result is a single workflow for performance verification that scales from a developer's laptop to a CI runner to a Jetson on a workbench, across hardware ranging from x86 to ARM to RISC-V.

Presenters
KG
Thursday September 17, 2026 16:45 - 17:15 MDT
_4
  Tooling & Ecosystem

17:20 MDT

Who Is #include-ing You? Measuring the Impact of C++ Libraries
Thursday September 17, 2026 17:20 - 17:50 MDT
_3
C++ library maintainers are often in the dark as to everyone who actually depends on their code. Without that knowledge, deprecation decisions are guesses, the downstream impact of any API change is hard to predict, and the case for funding or continued investment is difficult to make rigorously. This talk demonstrates how mapping your downstream ecosystem changes the way you maintain and evolve a library, using dependent-audit, an open-source tool that discovers real-world dependents by searching public source code for #include directives and CMake integration files, and cross-referencing published academic citations. We'll show concrete examples of what this data reveals: where your true API surface lies, which users are candidates for upstream contribution, and how to make the case for your project's real-world significance. Attendees will leave with a lens for library stewardship built on data and ecosystem analysis

Presenters
avatar for John Parent

John Parent

Kitware, Inc, Research and Development Engineer
John Parent is a senior research and development engineer on the Software Solutions Team at Kitware, Inc., where he is the primary developer of the Spack package manager’s Windows support. His other work covers contributions to CMake, establishing complex CI systems and C++ /Python... Read More →
Thursday September 17, 2026 17:20 - 17:50 MDT
_3
  General
 
Friday, September 18
 

09:00 MDT

“If You Can’t Measure It, You Can’t Improve It”: From Profiling to Automatic Benchmarking
Friday September 18, 2026 09:00 - 10:00 MDT
_5
Modern hardware is increasingly complex and difficult to reason about; effective C++ performance work therefore demands a disciplined loop - profile, benchmark, analyze. Yet profiling alone is tricky, doesn’t answer “what if” questions, and manual benchmarking is dominated by hidden biases.

This talk presents a novel automatic benchmarking approach that focuses on eliminating measurement biases. We combine symbolic execution of identified hot regions with microarchitectural state randomization to systematically explore latency and throughput behavior under diverse - cache, branch, data layout - conditions. The technique is integrated with Linux perf, so the entire process - region isolation, state variation, measurement, analysis - is fully automatic.

The talk first grounds attendees in profiling with hardware performance counters, Top‑down Microarchitecture Analysis (TMA), and processor tracing. We then demonstrate how to automatically stress specific microarchitectural features to produce statistically reliable, "bias‑free" benchmarks. Finally, we close the loop with machine‑code analysis, showing how the measured numbers connect directly to instruction‑level behavior and ultimately to C++ code.

Attendees will leave with a concrete framework they can apply immediately to better understand and improve C++ performance.

Presenters
avatar for Kris Jusiak

Kris Jusiak

Lead Software Engineer, Citadel Securities
Nanosecond count
Friday September 18, 2026 09:00 - 10:00 MDT
_5
  General

13:30 MDT

Code You Didn't Write: Understanding Large and Unfamiliar Codebases
Friday September 18, 2026 13:30 - 14:30 MDT
_6
First day on a new project. You set up your workstation and then download a repository of over 1,000,000 lines of code. Even more intimidating, the code has been around for 20 years. Parts are in legacy C++, parts use the latest C++26 features, and increasingly, AI coding assistants are weaving new code through all of it, meaning some parts of the codebase may have never been fully understood by a developer. You feel overwhelmed. Don't Panic! In this talk, we share techniques and tools that real engineers use to find their bearings in code they didn't write, from the humble grep through debuggers and profilers to time-travel debugging and AI-assisted exploration. The audience will leave this talk with a mix of simple and advanced tricks for navigating large and complicated codebases.

Presenters
CC
avatar for Mike Shah

Mike Shah

Professor / (occasional) 3D Graphics Engineer
Mike Shah is currently a teaching faculty at Yale University with primary teaching interests  in computer systems, computer graphics, and game engines. Mike's research interests are related to performance engineering (dynamic analysis), software visualization, and computer graphics... Read More →
Friday September 18, 2026 13:30 - 14:30 MDT
_6
  Business & Career

13:30 MDT

Why Great C++ Libraries Fail (And How to Fix That)
Friday September 18, 2026 13:30 - 14:30 MDT
_2
You found the perfect C++ library. But you cannot integrate it with your CMake build without reading three pages of bespoke instructions. The documentation (if any) is a Doxygen-generated API dump. You file a bug, get "read the source," and move on. You never adopted it—and you had every intention of doing so.

Or you are the author of that library. Technically brilliant. Six months after release: three users, no contributors, two support tickets, you are not sure how to answer. Drawing on years of experience as both a maintainer of mp-units — a high-visibility, standards-track C++ library — and as a developer who regularly evaluates and contributes to third-party C++ projects, I have watched this pattern repeat across dozens of technically excellent libraries. The barriers that drive users away, frustrate potential contributors, and quietly kill great projects are predictable. More importantly, they are fixable.

This talk traces the five stages every C++ library must survive — Discovery, Evaluation, Integration, Contribution, and Community — and examines the concrete engineering decisions at each. We will look at how naming, README structure, and CI signals communicate trust to a user who found you three seconds ago; how a properly fuzzed build matrix gives users real confidence across their compiler, their C++ standard, and their platform; how DevContainers and Compiler Explorer eliminate the local setup barrier for both users and contributors; how the Diátaxis framework turns a documentation site from a reference graveyard into a system that serves newcomers, practitioners, and design-curious contributors; and how to craft an AI contribution policy that manages the rising volume of LLM-generated PRs without sacrificing the architectural integrity that makes a library worth contributing to in the first place.

Whether you are a user evaluating libraries, a developer looking for a C++ project worth your time, or an author trying to build one, you will leave with a concrete, field-tested checklist.

Presenters
avatar for Mateusz Pusz

Mateusz Pusz

C++ Trainer | Principal Engineer, Train IT | Epam Systems
A software architect, principal engineer, and security champion with over 20 years of experience designing, writing, and maintaining C++ code for fun and a living. A trainer with over 15 years of C++ teaching experience, a consultant, a conference speaker, and an evangelist. His main... Read More →
Friday September 18, 2026 13:30 - 14:30 MDT
_2
  General

13:30 MDT

Modernizing Legacy Codebases without Stopping the World
Friday September 18, 2026 13:30 - 14:30 MDT
_3
Every mature codebase carries history and technical debt. The challenge is modernizing without stopping the world or introducing big re-write failure risks.

In this talk, we’ll explore how to modernize legacy C++ codebases incrementally using a mix of deterministic code transformations and AI-assisted refactoring .

After delving into some of the common problems with legacy modernization, we'll start tackling the simple "boring" stuff that deliver huge leverage of changes via clang tooling . These represent repeatable, deterministic reviewable upgrades that can be automated and applied at scale.

Then we can look at more difficult transformations that can be AI assisted with more aggressive transformations including API improvements and how to prevent it going off the rails. This will be backed by Compiler diagnostics, static analysis and testing to keep changes maintainable and correct .

The goal is not to replace engineering judgment, but to accelerate it: turning modernization into a continuous, low-risk workflow instead of a disruptive project.

Attendees will leave with a repeatable playbook for modernizing legacy codebases incrementally, safely, and at scale—using the right tool for each class of change

Presenters
avatar for Peter Muldoon

Peter Muldoon

Engineering Lead, Bloomberg
Pete Muldoon has been using C++ since 1991. Pete has worked in Ireland, England and the USA and is currently employed by Bloomberg. A consultant for over 20 years prior to joining Bloomberg, Peter has worked on a broad range of projects and code bases in a large number of companies... Read More →
Friday September 18, 2026 13:30 - 14:30 MDT
_3
  Tooling & Ecosystem
 

Get help with the event

Contact event planner Event login
View support guides Find upcoming events
Create an event you'd love to attend!
Explore why organizers choose Sched • Success stories
Event App • Event scheduling • Event registration • Event ticketing • Sched forms • Call for papers • Badges • Conferences
© 2026. SCHED LLC - All rights reserved - Helping events since 2008
Meeting Planning Software • Privacy • Terms
Share Modal

Share this link via

Or copy link

Filter sessions
Apply filters to sessions.
Sunday, September 13
Monday, September 14
Tuesday, September 15
Wednesday, September 16
Thursday, September 17
Friday, September 18
Colorado A
Colorado B
Colorado C/D
Colorado Pre-function
Gaylord Rockies
Mountain Pass Sports Bar
Rockies Square
_1
_2
_3
_4
_5
_6
  • Back to Basics
  • Business
  • Business & Career
  • Embedded
  • GameDev
  • General
  • Open Content
  • Robotics & AI
  • Scientific Computing
  • Social
  • Software Design
  • TBA
  • Tooling & Ecosystem
  • Subject
  • Algorithms
  • API Design
  • Concurrency
  • Embedded
  • Functional
  • Future C++
  • Generic/Metaprogramming
  • Math/Analysis
  • Performance
  • Safety
  • Security
  • Software Design
  • Software Quality
  • Standard Library
  • Testing
  • Tooling/Utilities
  • Value Semantics
  • Popular