Customer Reviews

Ruminations on C++: A Decade of Programming Insight and Experience

5 star:		(8)
4 star:		(4)
3 star:		(2)
2 star:		(0)
1 star:		(0)

 

 

Nestled between 'learn in 24 hour' books, uml tomes, and vc references is a smallish, silly looking book called Ruminations on C++. At first glance you may be nervous as you find cows on the cover, but this gem is one of the best programming books I've every enjoyed. This book is targeted to the intermediate C++ programmer who has mastered syntax and basic idioms, and wants to move beyond into more complex uses. The book introduces (some may say, pounds) the concept of smart pointers, containers and iterators, templates, and function adapters in a ah-ha! enlightening kind of way. Once you understand these concepts and start employing them in your programs, you'll wonder how you could have ever written programs without them. Some readers may be bothered by the fact that the chapters are 'regurgitations' of previous articles the writer had written, but I would highly recommend that you pick this up. The treatment on the SmartPointer alone is worth the price. Buy it now!!

While this book came out before the ISO C++ (99) standard was finalized it still has a lot of relevant material in it. It is clearly presented, and the underlying design choices are explained and expanded on.

A word of caution, the topic on Smart pointers is interesting, but don't just copy it out, get a tested version from the C++ library "boost". Its like the string class every text seems to use, copy it, use it to learn from but don't use it in an actual project. You'll just have to go through the debugging process that everyone else has already done.

This book focuses on C++ Design and that is a hard subject to teach well. The mechanics of the language are much easier to master, the putting it all together in the correct way is what this book focuses on.

I'd also like to say that I think this book is better written than any of the C++Report articles that A.Koening wrote. My guess is that the review process is more stringent and he and B. Moo had more time to work the text over. In any case it is one of the easier to understand and read intermediate level C++ books.

"Ruminations..." is among my favorite C++-oriented books. If you've read a few articles by Koenig (and sometimes Moo) in JOOP, C++ Report, or elsewhere you'll have a good idea for what to expect here. The problems are practical, the writing is clear, and the analysis is thorough. Code is not sanctioned to sidebars or mammoth examples in this book; it's an interwoven part of the discussion, and it evolves as solutions are explored. You might learn more about the standard C++ library by reading this book than many of the "STL" books out currently available. If you're new to C++ you should start elsewhere, otherwise this book deserves your attention.

A book for the knowledgable C++ programmer who seeks greater insight in programming, design and C++. It goes beyond programming constructs and specific methodologies, covering a very wide range of programming problems and their solutions. Based on magazine columns, the revised and extended material is presented in an unusually readable style. This is a book you will return to many times, just for the joy of it.

The book contains exactly what its title says: Ruminations on C++. For example it explains in a few lines WHY copy semantic of containers is prefered, looking at alternative approaches. Such considerations are written in a style that makes the book a pleasure to read. As most modern books about C++ deal with similar topics, this book is not another C++ book - the authors consider the why of design issues, whereas most other books concentrate on how things are getting done.

Working with programming languages as large and as complete as C++ is not just about how, but is, at a higher level, about why.  If you want rules about what is correct and what is illegal, this is not the place you should be looking for such rules.  If you want a look into the methods and the mind of the serious software engineer, however, this book is a treasure chest of ten years of experience of one of the key players.  Were I to pick one gem that exemplifies this work from among the many it contains, it would be the penultimate sentence of chapter four: "In other words, C++ is biased toward programmers who think for themselves." A careful read, some meditation, and some thinking for yourself are required to get full use from this wonderful book. Thinking for oneself progresses from autodydactism to art as one sees how others do it.

The quality of the authors' technical knowledge is beyond question. They write in an extremely articulate way. They explain in meticulously correct ways how to undertake different (very useful) tasks, most especially the construction of handle classes. Because the content is a family of carefully reworked magazine articles, I think that it conveys the context in which these idioms are most useful somewhat weakly. At one time, this was just the best information available. Now, I think there are better books, including the authors' own Accelerated C++. Personally, I think this is one to take from the library---not one to buy.

This book was a good read, i.e. it showed that elegance can still be found
in C++ programming no matter all the crap that goes around nowadays all
over the place. Concise and understandable code doesn't take magic nor
obfuscated coding practices; just a thorough understanding of the C++
programming language is needed.

Jos

I was keen to read this expanded and edited collection of columns, given the high quality of the authors' Accelerated C++. This is not quite as good as that book, but it's held up better than some of its contemporaries, like Carroll and Ellis's Designing and Coding Reusable C++.

The chapters are quite short, but they feel cohesive and flow well. The early part of the book is perhaps the most dated. There are discussions of implementing a string class and handle classes - they're treated well, but it's likely you've seen this several times before. Also, I didn't find the 'string picture' chapters, designed to illustrate class design, terribly interesting or illuminating of the underlying principles of object orientation (I didn't like them much in Accelerated C++ either).

However, the section on templates remains relevant, and the discussion of function objects and generic programming is a very good introduction. The later chapters on API design also retain insights. And in particular, the chapter on stream manipulators is very cool. It's also very good at discussing implementation and design issues and the thought processes that go into them. The feel is of someone talking you through how they went about writing some useful C++ and the trade offs involved.

In summary, this is a little dated, but it still has some bits and pieces that you won't find elsewhere. Not one to own at all costs, but keep an eye out for a cheap second hand copy, and when the price is right, pounce.

For starters this book was way beyond my level when I got it and am still struggling to implementing many of the ideas contained in Ruminations. I am not fond of the explnations of what not to do. The material is as dense as Acclerated C++. As it has been stated this book came out before the STL was fully devloped so some of the chapetrs could use revising. This is one of the few books that is a practicle guide to advanced programming. My main complaint about the authors is their unique practicle way of teaching C++. I would like to see more examples of how to implemet OOP concepts in C++.