Content and opinions

The book is split in two parts: the basis and the more complex blocks.

For Alexandrescu, there are four basis that should be covered: polycies, type lists, allocators and general techniques. Polycies is tightly related to the strategy pattern. The author discusses the elegant and complex architecture that can be written using them. Type lists is, in my opinion, the first step in using metaprogramming. Since Alexandrescu wrote this book, the Boost library implemented a lot of tools to work on type lists (as well as different types of type lists). This book explains very well how it can work and how to make the most of it. Allocators is perhaps one of the toughest topics in C++. Fortunately, the book provides a good implementation for small objects, and it is stable and efficient. I don’t think it is sound to implement your own, so using this one is perhaps best! Finally, the second chapter tackles different small tricks that can be easily implemented in every C++ code.

The second part is much more complex. Using the different basis blocks from the first part, Alexandrescu starts by creating a generic functor. It’s perhaps too much for 99% of the projects, but it still is a great proof of concept for elegant C++ architecture. The second topic in this part is singletons. Alexandrescu tries to address every side of this question, and although he provides an implementation, it is unfortunately not yet available/used in every framework. Next come smart pointers. They will be available in the next C++ standard, but only in a reduced form than what is exposed here. It is interesting to know the different issues that such a “simple” class has to solve. The next two chapters are dedicated to factories and abstract factories. As usual, one can create its own factory, but Alexandrescu tries to solve the more general problem. Before my favorite chapter, implementing the visitor pattern is addressed. It’s not the most widely used pattern, but it solves some tricky cases. Finally, even less used is the multiple dispatch function. Imagine you have to instanciate several functions with different types. You wan use type lists for this if you have only one type for each function. But if you have a more general case with two or three types that have to be instanciated, you have to use the multiple dispatch. It can be found in the intersection sample that is used in the book, but also in steering code (your favorite template class can be used with objects that can be of different types, like int matrices or float matrices, and you only have access to the base class of this type, and the class instance must call the correct instanciation).

Each time, the main focus is on automation, less code, more readability. Of course, this last point is only achieved if the reader has some knowledge of this modern C++ design…

Conclusion

Alexandrescu wrote Loki as a proof of concept of modern C++. The book is the result of the different solutions he thought of. Loki may be outdate by Boost in several fields, but it is also the foundations of the Boost library. If you want to write good professional-grade C++, you should read at least once this book and appropriate its content.

Modern C++ Design: Generic Programming and Design Patterns Applied
Price: $53.99

Modern C++ Design: Generic Programming and Design Patterns Applied (Paperback)
by Andrei Alexandrescu
ISBN: 0201704315

Price: USD 48.45
54 used & new available from USD 15.04

| 4.5 | 70

Content and opinions

Everything on the STL can be found in this book. Every algorithm is explained with details, almost every function of every container, with their features, qualities and defaults. In fact, there are so many things in the STL that one cannot know every detail without studying it in depth. And this is where Meyers shines: the book helps learning this fastly!

Besides the STL, the old non standard containers (hashmap for instance) are also covered, although C++0x changed them, so these items can be bypassed.

Conclusion

Even more useful than Effective C++, the tips provided in this book can be forgot easilly, so you need to come back to it regularly. If you use the STL (which you must if you’re a C++ developer), you must have a copy of Effective STL.

Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library (Addison-Wesley Professional Computing Series)
Price: $32.25

Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library (Paperback)
by Scott Meyers
ISBN: 0201749629

Price: USD 40.55
46 used & new available from USD 27.50

| 4.5 | 38

Effective C++ is at its third edition, which is a complete rewrite with topics from the “old” Effective C++ and More Effective C++. So if you have one or the other, you will find yourself with additional content.

Content and opinions

When rewritten, the book changed its approach to C++. No more migration from C to C++, but using C++ with the const keyword, initializations, … Difficulty is growing, the first elements being eay to understand and to put into action, then we go into more complex fields – what does the compiler do under the hoods, the assignement operator, … -. The part on memory management is more complete and is about resources, not only memory, in fact. Design and class declarations/implementations/inheritance parts are relevant as well. Some items from the previous editions were moved to other sections, new items were added wisely. A part dedicated to generic programming was introduced with even some meta-programming. The section on new/delete is also new, with their overloading, an interesting topic.

Conclusion

The book is now several years old, but it is still current, and more C++ oriented (compared to the previous editions). Effective C++ handles C++0x with TR1 (even if it is far older than the forthcoming new standard) and even the Boost library. With this last edition, the book is again one of the best books for a beginner during his learning the langage, as the first edition was in the past. Even for an advanced developer, it is filled with tips that you should never forget.

Effective C++: 55 Specific Ways to Improve Your Programs and Designs
Price: $32.25

Effective C++: 55 Specific Ways to Improve Your Programs and Designs (3rd Edition) (Paperback)
by Scott Meyers
ISBN: 0321334876

Price: USD 40.74
60 used & new available from USD 30.00

| 4.5 | 149

Content and opinions

TDD is about testing while developing, so it is of no wonder that the first part of the book which expose the methodology is done with the help of an example. Small steps, one of the main ideas behind TDD, in the explanations result in a lot of small chapters that explain how to do one thing.

The second part is about the main tol for TDD: xUnit. Its goal is to provide a standard tool for all languages.Well, in fact, it is different implementation, but some are not as easy to use as JUnit, the Java implementation. Some languages are more easy to cope with TDD than others.

The third part is a formal list of patterns to efficiently develop with TDD. What do you need to test something completly? What do you need to go from a test to the actual associated solution? This is the kind of questions the patterns try to answer.

Conclusion

There are a lot chapters with simple ideas in each one. What bothers me is that they could have been hierarchized a little bit more, but really, this is not an issue here. TDD is something that everyone should do, but there are some domains where it is more difficult than in other. For instance, hw would you test a complex stochastic scientific module? This is a question that remains open at the end of the book. For general IT, it answers every question on testing though.

Test Driven Development: By Example
Price: $44.99

Test Driven Development: By Example (Paperback)
by Kent Beck
ISBN: 0321146530

Price: USD 40.53
54 used & new available from USD 24.99

| 4 | 34

Content and opinions

The standards are split in several groups, from policy to type safetiness. Each time, the coding standard is stated, with a short summary and then a discussion. There can be an example if needed, and some references. The standard is always simple enough to follow, and the explanation is clear yet complete.

The handled issues are very vast, oriented towards common pitfalls. Use inheritance when needed, use collaboration elsewhere, do not inherit from a class that isn’t made for inheritance, … When you are used to these pitfalls (because a lot of C++ gurus talk about them in their forum posts, mails or blogs), you may sometimes forget them and write code that is not optimal (in several ways, performance or maintenability). The book is in that regard a good way of having the good practices classified by topics and easilly accessed: you don’t have to check or search on the Internet. Finally if someone has a question on why you used a specific coding standard, you can give a full explanation and a context (and spread the good pratices).

Conclusion

C++ Coding Standards are sometimes more a question of style than of language, but they are part of the general pieces of advices one should follow. C++ is a language that permits a lot of things, perhaps too much, and this set of rules makes it possible to write readable, efficient, robust code.

C++ Coding Standards: Rules, Guidelines, and Best Practices
Price: $32.25

C++ Coding Standards: 101 Rules, Guidelines, and Best Practices (Paperback)
by Herb Sutter, Andrei Alexandrescu
ISBN: 0321113586

Price: USD 40.45
45 used & new available from USD 24.89

| 4.5 | 27

Content and opinions

First, this book could be seen as a follow up of Refactoring, as almost all the described processes use steps from it. The first chapters explain what to expect from refactoring (how it affect software architecture), patterns and how to detect code that needs refactoring. The catalog is split like the original Design Patterns book in different categories (Creation, Simplification, Generaliation, Protection, Accumulation or Utilities), and each of them is described as in the GoF book (which suits me quite well).

The code language is Java, so it may be sometimes difficult to find the equivalent construction in your favorite language, but it is doable if you known Java basics.

Conclusion

This book quotes several times Martin Fowler, but this is not related to the fact that this book is in the “Fowler signature” collection of the publisher. Refactoring to Patterns addresses what Refactoring couldn’t and goes firther, without imposing, just by suggesting.

Refactoring to Patterns (The Addison-Wesley Signature Series)
Price: $41.93

Refactoring to Patterns (Hardcover)
by Joshua Kerievsky
ISBN: 0321213351

Price: USD 52.71
53 used & new available from USD 29.90

| 4 | 45

It was the first book where I found the code smell concept. And my former code really smelt…

Content and opinions

This book became a reference for me. The patterns catalog (because I consider them as patterns) seems almost exhaustive for me. Some of the steps described are too easy (as inlining a function). It may be more difficult at first to extract a method from another, but it is still the basis of refactoring.

The main use of the book isn’t saying what one already know (inling, splitting a function, …), it is showing a new step, one one didn’t think about and that solves the problem at hand. Stating the problem, the smell, is also a main focus of the book, where Martin Fowler gives hints to distinguish between the different smells.

The author is one of the world-known unitary tests herald, so it is no wonder they have a central place in the different patterns. This way, the refactoring cannot change the code behavior. The given examples are also clear and simple enough, completely described step by step (mainly as the book goes forward, new patterns use preceding ones).

Finally, the code is written in Java, but it isn’t a problem for someone used to object-oriented language. Useful tools are also exposed, but they are old, dating from the time when the book was written (and they are mainly geared toward Java).

Conclusion

This was a really simple book. Since I closed it, I didn’t have to open it again, as the patterns are pretty simple. But still, as for every pattern, you first have to understand it (and read it) to acknowledge it. And I tend to refactor regularly following the ideas behind this book.

Refactoring: Improving the Design of Existing Code
Price: $41.93

Refactoring: Improving the Design of Existing Code (Hardcover)
by Martin Fowler, Kent Beck, John Brant, William Opdyke, Don Roberts
ISBN: 0201485672

Price: USD 53.06
62 used & new available from USD 36.99

| 4.5 | 141

This book is one of the “must-have” in your library. If you write some code or if you manage some IT or Computer Science projects, you will have this book to lay down the basic software architecture.

Content and opinions

The first two chapters are an introduction and explain the reasons of the existence of design patterns, how they should be used, good and bad pratices, … Design patterns without rules to apply them are useless (as the original architectural patterns are useless without drawings skills). A practical example is the object of the second chapter.

Design patterns are exposed in a three parts catalog. Each pattern each described by a complete explanation, an UML diagram, the interactions between the pattern elements, as well as some implementation solutions (all solutions cannot be written, as it is language-dependent).

Creational patterns are about creating new objects. They include the abstract factory (constructing several objects of different kinds), the builder (a more elaborate constructor), the factory method (overloading a class method to create objects based on different classes), the prototype (creating new objects by cloning an instance) and the singleton (creating only one instance of a given class).

Structural patterns are more about the actual software architecture. They include the adapter (translating an interface to another one), the bridge (separating an interface from different implementations), the composite (allowing several objects of a hierarchy to be composed together), the decorator (adding characteristics to an object), the facade (offering an interface to several classes), the flyweight (sharing the same objects between instances so as to reduce memory overhead) or the proxy (using another object to access another, potentially hidden, one).

Behavioral patterns enable a software to change its own behavior. They include the chain of responsibility (allowing processing requests by whoever can), the command (creating complex requests), the interpreter (describing how a language can be processed), the iterator (providing a way of browing the content of a data container), the mediator (allowing communication between different classes), the memento (enabling restoring the state of an object), the observer (sometimes also called listener, creating a way for instances to be updated/called by another one), the state (allowing changing behavior on the fly), the strategy (providing several ways of doing something), the template method (providing a skeletton for an algorithm) or the visitor (allowing execution of code for every the content of an object). This patterns set is perhaps the most heterogeneous one (although the state and the strategy are in fact exactly the same, the only difference being the interpretation of their actions).

Conclusion

This book, sometimes refered ad the GoF book, lays down the basis of software conception. These 23 patterns are not the only ones you may use (some of them are also seldom used), but they are used to make the more complicated ones. If you have one design patterns book you should buy, it is this one.

Design Patterns: Elements of Reusable Object-Oriented Software
Price: $38.7

Design Patterns CD: Elements of Reusable Object-Oriented Software, (CD-ROM)
Price: $33.86

Design Patterns: Elements of Reusable Object-Oriented Software (Hardcover)
by Erich Gamma, Richard Helm, Ralph Johnson, John M. Vlissides
ISBN: 0201633612

Price: USD 51.04
108 used & new available from USD 24.95

| 4.5 | 271