CppCon 2026

To write the best C++ application code, you must think like a library author. This talk reframes application development as a form of library design, where every component is a potential asset for future maintenance and extension.

We'll survey the C++ language features that empower library authors to create powerful, flexible, and safe abstractions. From there, we'll distill the 'library author mindset.’ You will leave with concrete principles and techniques to make your application code more modular, maintainable, composable, reusable, testable, and ultimately, more valuable.

As legacy C++ codebases evolve to meet new requirements, fix architectural issues, and address performance bottlenecks, refactoring becomes inevitable — but full rewrites are risky, costly, and rarely practical. This talk explores how modern C++ features — especially functional programming techniques and type erasure — can be used to refactor and extend legacy systems. We will present a concrete, low-risk, and measurable four-step technical framework for incremental modernization, by leveraging pure functions, discriminated union types, and type-erased callables to achieve safer, more flexible code with compile-time guarantees, even in traditionally object-oriented codebases.

The core of the talk will walk through the entire process on a concrete code example, illustrating (1) how to isolate existing logic, (2) define safer data models using immutable types, (3) deploy type erasure to create a robust, non-disruptive adapter boundary between old and new code, and (4) measurably execute the migration with safe testing practices. We will also share lessons learned from real-world experience and conclude by showing how these foundational patterns can be extended into future-thinking designs, leveraging examples with accepted C++26 features. Every step is grounded in real production constraints and trade-offs, and the techniques transfer directly to any domain where full rewrites are not an option. Attendees will walk away equipped with practical strategies to incrementally refactor your legacy systems without sacrificing stability or velocity.

Martin Fowler's Classic book "Refactoring" presents a list of refactorings (72 in his first edition, 61 in his second, "lots" on his website) and common "Code Smells".  These are not language specific, but are very "OO Design Patterns" flavored and are less applicable to C++ than we'd like.

This hour-long session will start with a ~30 minute overview of some C++ specific code smells and refactorings, and then move to an open Q&A discussion format.  Examples will include:

• Declaring all variables at the top of a function (holdover from K&R C and Fortran)
• Nesting all a function's business logic in conditionals in order to have all code paths share the final return statement ("Single Exit is Obsolete")
• Dynamically allocating objects when we don't need to ("Don't make so much garbage")

This session is "adjacent" to my talk "Refactoring Techniques and Strategies (A Tale in Three Acts)" but doesn't rely on that material; and is accessible to all developers.