Applied C++: Techniques for Building Better Software

Rating:
Summary: Great idea, terrible execution
Review: A true disappointment. Other books in the series (Sutter, Alexandrescu, Koenig & Moo) have been instant classics, but I get the feeling that Stroustrup didn't really read this one (he's the "series editor", not the "book editor", and not mentioned in the acknowledgements). If he had, I doubt he'd let the following gems see the light of print:

-- "It is easy to spend too much time researching the problem in hopes of finding the most efficient STL component. For example, we could have also chosen to use std::set, as this matches the requirements of our object very closely. ...If you have not used many STL components, you will soon discover that you end up using only a small subset of objects..." (p. 107) In the context, the authors have just selected a std::map whose value type they plan to ignore completely. The C++ standard library is TINY compared to most other currently popular languages, and much more consistent. Wouldn't it be more worthwhile to take a second to learn about std::set just this once, so you'd remember it next time?

--"Namespaces were added to the language to prevent name collisions, but aside from their use in the standard C++ library, we have seen little use of them elsewhere." (p.74) Then, they go on to advocate prefixing all class names, a la "apString". Why not just make an "ap" namespace, if you realize that that's what namespaces are for? Maybe they haven't seen any use of namespaces because they systematically avoid them out of sheer stubbornness?

The book is filled with other inane advice displayed in special boxes: "If you decide to graphically depict your object relationships, take advantage of both axes to represent them." Darn, why didn't I realize this sheet of paper was two dimensional? Glad I bought the book!

The only remotely redeeming factor is the stuff on image processing, but any two-bit text devoted to image processing would be better. Heck, just about anything you could dig up on Google would be just as good, I imagine.

Finally, the included CD stinks. After all that, what you get is essentially a makefile with some lousy code--not even a dummy application that lets you see it in action.

I wish I could give it 0 stars, but it doesn't seem to be possible. Don't waste your money--almost any other AW book on C++ would be a better choice.

Rating:
Summary: A worthy reference for programmers
Review: Applied C++: Practical Techniques for Building Better Software by Philip Romanik and Amy Muntz, is an informed and informative guide intended for experienced C++ programmers in their use of templates and the Standard Template Library for the purpose of improving their language, design, and problem solving skills. Examples, sample code, and an accompanying CD-ROM filled with code, debugging techniques, and a great deal more, make Applied C++ a worthy reference for programmers striving to improve the quality of their work and is a core addition to any professional C++ user reference library.

Rating:
Summary: Good intro to 2D image processing, very nice framework
Review: As a programmer who had never done any image processing before, this book helped raise my knowledge from zero to a reasonably good understanding of 2D image processing, and provided me with a very useful framework that I am using everyday in my job.

I feel that the book also does a good job demonstrating template techniques, and provides a good overall SW development process to follow.

The authors have been very responsive to questions and problems, which I greatly appreciate.

The only thing I really didn't like was the lack of makefiles for the non-template code. I would have liked to have a makefile that creates a library automatically. I ended up doing it myself, which frankly wasn't all that difficult.

Rating:
Summary: This is a great book
Review: I really like this book. Unlike many C++ books, this book shows you how to design and build commercial applications with C++. It stresses good programming practices and should be on the shelf of every C++ developer.

This book is actually two books in one. Like many other recent C++ books, it contains many practical tips and advice on how to improve your programming and design skills. Just by paging through the book, you can come away with many new ideas to incorporate into your own work. For example, I have been involved in designing and enhancing C++ software for many years. I found the section on prototyping to be of great interest because it reminded me how to use prototyping as a tool to solve the nasty design problems I am faced with.

Applied C++ is full of source code examples and turns out to be a great guide on using templates. The image processing framework makes frequent use of templates, including using custom iterators to greatly improve performance. Their design mixes template and non-template classes together to take advantage of all the power that C++ has to offer. If you want to improve your template programming abilities, buy this book for the practical
advice, and Vandevoorde's C++ Templates as the definitive reference manual.

Rating:
Summary: Nothing really new in this book
Review: I was a little bit disppointed with this book, especially when I look at other books in this serie.

Although I cannot find any point totally wrong in this book, I cannot find anything that I did not already knew. I believe that this book is best suited for people rather new to the profession, or maybe even more to people who only use C++ as a better C, and would like to start using C++ specific features.

Maybe in this case, they can find in one book what usually requires at least three books. But that would not take them as far as those three books would do.

I think my biggest disappointment with this book, is that when the authors discuss about their design, they explain how it work in details, sometime they even suggest why they choose this possibility, but they almost never review other possibilities to weight to pro and con of each one.

The text is sometime a little bit tedious to read (the kind of repetition that one would expect in documentation where everything has to be detailled, but not in book).

Finally, there are some technical points where I disagree (or where I beleive a better solution exists, and should at least be evoqued):
- The use of prefix instead of namespace, making code more difficult to read, and I believe even more innapropriate in a book than in real life
- Not a word about the template techniques that might unroll the loops they tediously unroll manually
- The use of trait associated with pixel type could probably ease the use of the library (for instance, specifying the type to be used by default when adding two pixels)
- I think it is rather surprising the way the authors complain about a change in the standard from a well defined behaviour to a buggy one that broke their previous design on purpose (you may think I am cynical, but they _complain_ about this special point at least three times in the book (for their function add2), but never explain why the standard is written as it is)

Rating:
Summary: For graphics and computing users
Review: Many of the performance tips offered in this book are relevant in any language. For example, the authors suggest using integer arithmetic instead of floating point whenever possible. No surprises there. What is pleasant is their use of an image processing need to progressively develop non trivial code that illustrates their suggestions.

In fact they expound on this well enough that a secondary use of this book might be for someone who wishes to start learning image processing, and doing it in C++. Another reason for choosing graphics as the application is that it gives them a way to motivate and show progress through the book. Rather than just displaying flow charts and suchlike. It may also make it easier for you to learn.

Considered strictly as a C++ text, the book is best suited for someone like a junior level programmer, who has been using C++ for less than 2 years or so. More seasoned programmers should be familiar with most of the contents [hopefully].

But if you regard this as a graphics text, then it is also best for someone doing a first course on the field. Two dimensional. No ray tracing or rendering from a wireframe model.

Rating:
Summary: a solid C++ software development book
Review: There are many books about C++, and there are many books about software development. This book is one of the best I've seen at combining the two topics. The authors are obviously real-world developers because they offer real-world solutions and approaches, unlike the authors of many development-oriented books who apparently live in ideal worlds where every project goes perfectly.

C++ continues to be one of the most popular programming languages ever, and I highly recommend this book not only to any developer who writes C++ applications for a living, but also to team leaders and architects who want to make sure their teams are writing the best code possible. I can say based on years of experience that the techniques offered in this book are critically important for real-world, robust, production-quality C++ applications.