Bjarne Stroustrup on C++ Concepts: Design, Evolution, and the Quest for Expressive, Performant Genericity

This podcast episode features Bjarne Stroustrup discussing the evolution and implementation of C++ Concepts, a feature now integral to C++20. Concepts are introduced as compile-time predicates that impose constraints on template parameters, ensuring that generic components like a `sort` function can specify precise requirements for their arguments (e.g., being a 'sortable' sequence with random access and comparable elements). Stroustrup emphasizes that this feature, designed by Gabby does raise true certain, Andres Arden, and himself, is now widely available in major compilers like Clang and GCC, moving from a theoretical idea to a practical tool for production users.

The discussion delves into the historical context and challenges behind the development of Concepts. Stroustrup recounts his initial design of templates in 1987, where he prioritized flexibility and performance over the ability to express argument constraints and proper type checking for interfaces. He explains that achieving all three properties simultaneously was beyond the knowledge of the time, leading him to compromise on the third for decades. Subsequent attempts, particularly around 2000-2003, faced significant hurdles, including issues with compilation speed, complexity of use, and failure to integrate well with C++'s existing paradigms like implicit conversions and mixed-type arithmetic, partly due to influences from the functional programming community that had different performance and expressiveness requirements.

Practically, Concepts allow developers to write more robust and understandable generic code. Instead of accepting parameters of "any type," templates can now explicitly state their requirements, such as "I'll take something that's sortable." This leads to clearer interfaces, better compile-time error messages, and more reliable software. The ability to formally define and check these properties at compile time significantly enhances the safety and maintainability of generic programming in C++.

Broadly, the conversation highlights the intricate and often protracted process of programming language standardization and evolution. It illustrates the constant tension between design principles like flexibility, performance, and type safety, and how compromises made in early designs can drive decades of future innovation. The journey of C++ Concepts underscores the difficulty of integrating powerful new features into a mature language while maintaining backward compatibility, performance, and usability, reflecting a continuous effort to refine and enhance the language's capabilities for complex software development.

basically what concepts are there compile-time predicates there predicates you can ask are you a sequence yes I have begin an end are you a random exit sequence yes I have subscripting and plus it's your element type something that has a less then yes I have a less than hits

it specifies the requirements of the code on the parameters that gets yes there are lots of types actually but operating in the space of concepts concepts the word concept was used by Alec Stephan of who is sort of the father of generic programming in the context of C++

the difference to me is that we can actually write a concept that will ask a type are you an integral type do you have the properties necessary to be an integral type do you have cross - divide

for for templates I wanted three properties I wanted to be very flexible it had to be able to express things I couldn't imagine because I know I can't imagine everything

secondly it had to run faster as fast or faster that hand-written code so basically if I have a vector of T and I take a vector of cha it should run as fast as you build a vector of cha yourself without parameterization

and thirdly I wanted to be able to express the constraints of of the arguments have proper type checking of the interfaces and neither I nor anybody else at the time knew how to get all three

it bothered me for an hour a couple of decades that I couldn't solve the third one I mean I was the one that put function argument type checking in to see I know the value of good interfaces

a lot of stuff came out of the functional community and it that community didn't deal with multiple types in in the same way as C++ does had more constraints on on what you could express and didn't have the draconian performance requirements

we had some successes but it just in the end wasn't didn't compile fast enough was too hard to use and didn't run fast enough unless you had optimizes that was beyond the state of the art they still are

the basic idea is that when you have a a generic component like a sort function the sort function will require at least two parameters one a data structure with a given type and comparison criteria