There is an old joke: “There are 10 types of programmers: those who understand binary and those who don’t.” Similarly, one could say that there are those programmers who will appreciate this book and those who won’t.

This is a deep book, though not one for every programmer. I spent several hours just on the first few pages. But with each page I read, I felt that I was learning things and gaining new insights into programming. I believe that the reader who will get the most out of this book is one who has a reasonably strong mathematical background and is looking for a rigorous structure in which to view programming.

With many books on programming, there is a sense that there are very few new ideas and that the books often apply standard techniques to new languages, adding some fresh examples. This book is an exception. First, it does not teach any particular language, data structures, or algorithms. In fact, it would be useful if the reader were already well versed in at least one language (preferably C++). Second, a thorough reading of the book will give the reader a rigorous base for approaching programming, particularly the design of libraries; as Stroustrup has famously often repeated: “Language design is library design and library design is language design.”

As far as books on programming go, this one is fairly small--230 pages, excluding appendices and the index--but very dense. Each page may present several important ideas, often in the form of lemmas. Each chapter has several exercises. The exercises can be quite challenging and cannot necessarily be solved by regurgitating the text; for example, “Design an algorithm that determines, given a transformation and its definition-space predicate, whether the orbits of two elements intersect.” There is also the occasional project that is generally longer than an exercise. If the book were to be used as a textbook, I imagine that the exercises would be attempted by a single person, and the projects by a group.

Stepanov and McJones use a subset of C++ as the language to illustrate the concepts in the book; the formal grammar for this subset is defined in an appendix written by Sean Parent and Bjarne Stroustrup. I reiterate that while it is not necessary to know C++ to read this book, it would certainly be useful. I don’t think the intention of the book is to make one a better Haskell programmer, or a better Java programmer, or a better programmer in any particular language. Rather, after reading the book, one should be better at thinking and reasoning about programming. However, having said that, I think that a C++ programmer who reads the book would definitely emerge as a better C++ programmer because, while the concepts discussed in this book map to any programming language and feature set, they map particularly well to C++ and the Standard Template Library (STL).

In conclusion, the style of the book is dense and requires the reader to focus deeply. The book does not make concessions or compromises to try to simplify the material it presents. This terseness is shown, for example, in one of dozens of lemmas that are presented throughout the book: “Lemma 10.8: Disjoint cyclic permutations commute.” That’s it--no discussion, no explanation. Of course, if you have followed the material up to this point, there is no need for a breezy explanation.

In order to be comfortable with this book, you will need to be comfortable with mathematics. If you are comfortable with both programming and mathematics, and are looking for a rigorous treatment of programming that does not make any compromises, then this book will continually delight and surprise you.