Review of Advanced C++ (1992) by James Coplien

After a pretty intense slog, I've made it through Coplien's Advanced C++ book from 1992.

This has likely been the most difficult C++ book I've ever read, especially compared to some of the easy-breezy golden oldie books like "Ruminations on C++" I've been going through recently. I had to reread chapters and noodle on code examples for a while to get things to sink in.

This book is overkill for most C++ developers, but I would recommend it for certain audiences detailed below.

I think the main value in the book today is to help developers gain mastery of the traditional object-oriented techniques in the C++ core language. This was published before templates were widely supported, before the STL, etc.

Given how dominant templates and the STL have become and the popularity of the Sean Parent hot take that "inheritance is the base class of evil," I've found that there are actually now quite a few C++ developers that don't really have good muscle memory for inheritance or the traditional associated design patterns. This can be a problem because realistically, a great many C++ codebases that one touches at work use these language features and design problems to achieve runtime polymorphism.

For example, at CrowdStrike, the Falcon sensor is a very large monolithic C++ codebase targeting execution as a kernel module. It disables exceptions/RTTI, disallows use of the STL, and provides custom in-house primitives that use traditional inheritance-based polymorphism and the sorts of idioms that Coplien discusses. If you are interested in working in these sorts of codebases, spending a few weeks noodling on this book and thinking through how to updates some of the examples with more modern language features would not be a bad time investment.

I went into this book cold (without even reading the back cover), and I was shocked by the material covered. This book predates the Gang of Four design patterns books, so Coplien essentially uses idiom as a synonym for design pattern essentially.

After a few chapters introducing idioms and hand coding idioms like "handle classes" and "smart pointers," Coplien advances out of what he calls "orthodox" C++ style to build up higher level primitives seem in languages like Smalltalk, Self, Mesa, CLOS, LISPs, etc. These idioms are definitely "non-idiomatic" C++.

My impression is that language designers and computer scientists were a core part of the audience of this book, as Coplien seems to assume the reader is a trained computer scientist with broad familiarity with language features from many languages.

This comes up when Coplien tersely discusses shortfalls where the static nature of C++ prevents some object-oriented technique from Smalltalk or some other more dynamic language with a thicker runtime. Most of these statements went over my head, but I was able to reverse engineer prompts to LLMs to clear up the concepts and generate equivalent examples of the concepts he discussed in Java or JavaScript code samples that I could play with in a REPL. I found this process to be extremely enlightening.

What's the point of bringing up all this non-idiomatic C++ stuff? Well, after introducing the limitation, Coplien walks through how to use build up a runtime in C++ to provide those higher-level capabilities. This is gradually built up over each chapter, eventually getting to code that implements prototypal inheritance (like Self, Scheme, JS, Smalltalk) with garbage collection in a manner where C++ classes become "meta-classes" and the higher-level Classes can be dynamically loaded or updated at runtime.

Pretty impressive 1992 era C++ dark arts all things considered. Overkill for most developers, but some subset of the techniques might be useful for injecting tiny bits of dynamism into static programs when things like Lua, WebAssembly, or BPF is too heavy.