CppCon 2024

This isn't a talk about why you shouldn't use ranges in your C++20 codebase—unless you work on one of the largest codebases in the world, you probably should. This is a talk about the differences between most programming tasks and software engineering at truly gargantuan scales—and about how it isn't always practical to use the same components of a language in such different contexts.

Ranges are perhaps the largest and most ambitious single feature ever added to the C++ standard library since its inception. They have modernized C++ to match the way the current generation of programmers thinks about iteration and loops, largely owing to the influence of dynamically typed languages like Python and Javascript. Every programming language feature comes with a set of trade-offs, though, and it's unreasonable to expect that those trade-offs will result in the same cost-benefit ratio in every context. At Google, the decision to ban the `<ranges>` header from our C++ codebase continues to be extremely controversial, with nuanced arguments on both sides of the discussion. This talk will summarize those arguments, from broad topics like the diffusion of functional programming paradigms in large codebases, to mutability of concept-driven designs over large time scales,  to technical deep-dives on the inner workings of range adapters and the consequences thereof at scale. We'll conclude with a discussion of what this means for the future of ranges and why Google continues to invest in the ranges study group of the C++ committee.

All code is legacy code, or so they say. Software engineers scoff at the idea of new code instantly becoming legacy code, however software is a time capsule holding the design trends of the time the code was written. As new code is written, new design trends are used and potentially overused, just like the legacy patterns. What if these new design trends have more in common with the original design trends than we initially thought. One example we will investigate is object oriented design through polymorphism and how it has been replaced in many cases with template metaprogramming. There are a variety of template metaprogramming strategies that achieve the object oriented design principles, however when overused you can encounter as many templates as there would be virtual functions in object oriented programming. Have we discovered that balance is the solution or are we still overusing the “fancy” new thing? In this talk, we will investigate various legacy design trends including further examining object oriented design, the singleton pattern, as well as other legacy anti-patterns to reveal the updated trends. We will address each legacy anti-pattern and their corresponding modern update to evaluate whether newer is better or if we have recreated the same legacy problem.