Rating: 
Summary: Excellent book on principled software development
Review: If you always wondered how to find the "right" abstractions - which are nowadays called objects - in your programming. This book gives you an idea what the guiding principles should be.
Don't expect it to be a silver bullet. It is neither the best book on agile software development practices nor the best book on design patterns, but it is the best book on sound principles behind software development. So I believe that some of the content will still be valid in the post OOD-world, whatever it is going to be.
So if you ever wondered, why sometimes programms look good, and most of the times they are just outright ugly, this book gives you a couple of pointers where to look for the problems.
Two more things: a) it is actually fun to read, b) from my experience in project management and software development I don't believe the radical XP approach will establish itself - it doesn't give managers the feeling they are in control. Not that they are with the classic waterfall, but they think they do. Some practices such as pair programming and test-driven development will become best practices - or are they already? The rest will probably be dropped once the fad is over.
Rating: 
Summary: Catch-22
Review: If you are considering committing your time to reading this book for the sole purpose of learning about the Agile Methodology, then-sadly-your money is better spent elsewhere. Nothing said here about the Agile Process is unique, as it was already repeated over and over again in numerous books, articles, and websites dedicated to eXtreme Programming.However, this book does offer a very decent rehash of classical design patterns. The case studies presented help to clarify the discussed patterns in context, and are in general a refreshing and modernized version of the examples found in the classical GoF book. If the author had concentrated his efforts on the discussion of patterns, then the book would have easily managed to win my five-star vote. If you aren't properly introduced to the subject of patterns already, then consider this an essential read. As to the subject of Agile Development, it's a classical Catch-22 situation. The book claims to cover this new cutting-edge and trendy methodology. And indeed, you'll find the mandatory core values and principals chapters, and a sample Pair Programming session. But herein the problem lies: the pair programming session chronicles two highly expert programmers haplessly going through iteration after iteration, page after page, of dull, brain-numbing conversation and mediocre code to write a simple program that is to compute the score of bowling games. Just scale up the experience to a more complicated module in a bigger system, and what you'll have is a development method that no programmer in his right mind would ever consider adopting. Thus, either this is definitely NOT Agile Development, or the whole Agile phenomena is nothing more than a fiasco. I'd personally place my bet on the second possibility. But by all means, don't take my word for it. Point your browser to [local website]for a realistic and often hilarious critique of XP and Agile Development. If you are contemplation the adoption of any of the aforementioned methods, then you owe it to yourself and to your organization to be more cautious when someone offers you yet another silver bullet to end all your software development nightmares.
Rating:
Summary: Real knowledge
Review: If you buy only one technical book this year, buy this one. If you are even considering writing, or managing software you should know what is in this book first.
Rating:
Summary: Anyone I hire will have to read this book!
Review: My first thoughts were "Hmm.. Uncle Bob's written another book. Hmm... another Agile development book. Yup." However, when I started into it, it was obvious that the real heart of this book was the 3 Ps: core OO design principles that, sadly, most programmers haven't even heard of; fundamental, and some novel, OO design patterns; and agile programming practices. Section 1 talks about and overviews some of the core agile programming practices, and sets the stage for the bulk of the book. As a Test-driven Development (TDD) evangelist and author (with my own book on the subject pre-orderable at this point :-) I enjoyed the chapter on TDD, concise and clear. It should whet your appitite for more (hint, hint). The principles are masterfully explained. I expecially appreciated the in depth discussion of package design... something that I haven't before seen dealt with at this depth and with this level of quality. Sections 3-6 cover 3 case studies. Each is used as a platform for introducing and exploring an assortment of core design patterns. Included are standard GOF patterns as well as some from the PLOPD series of books. Again, these are masterfully done. You can tell that Uncle Bob lives & breathes this stuff, and has for quite a while. The appendices on UML are useful to those readers unfamiliar with the notation (which is used throughout). And the inclusion of the Agile vs. Rigid project comparison is good for several chuckles. The inclusion of Jack Reeves' "The Source Code Is the Design" is an added bonus.
The physical aspects of the book are well done as well. The margins are small, with barely enough room for brief notes. There's a lot of material packed into those 500 and some pages. A hardcove is nice these days when most technical books are softcover. This one will lay open next to your keyboard without resorting to paperweights. One thing that bothered me a bit at first, or at least was distracting, came from the variety of the material.. some is older and pre-test-first, some is new and test-driven, C++, Java, etc. But once I got used to the contexts shifts they weren't a problem. Finally, as another reviewer mentioned, this book is full of code. Everything is illustrated with code. My advice: buy it, read it, learn it, live it. Your software will be better for it.
Rating:
Summary: Anyone I hire will have to read this book!
Review: My first thoughts were "Hmm.. Uncle Bob's written another book. Hmm... another Agile development book. Yup." However, when I started into it, it was obvious that the real heart of this book was the 3 Ps: core OO design principles that, sadly, most programmers haven't even heard of; fundamental, and some novel, OO design patterns; and agile programming practices. Section 1 talks about and overviews some of the core agile programming practices, and sets the stage for the bulk of the book. As a Test-driven Development (TDD) evangelist and author (with my own book on the subject pre-orderable at this point :-) I enjoyed the chapter on TDD, concise and clear. It should whet your appitite for more (hint, hint). The principles are masterfully explained. I expecially appreciated the in depth discussion of package design... something that I haven't before seen dealt with at this depth and with this level of quality. Sections 3-6 cover 3 case studies. Each is used as a platform for introducing and exploring an assortment of core design patterns. Included are standard GOF patterns as well as some from the PLOPD series of books. Again, these are masterfully done. You can tell that Uncle Bob lives & breathes this stuff, and has for quite a while. The appendices on UML are useful to those readers unfamiliar with the notation (which is used throughout). And the inclusion of the Agile vs. Rigid project comparison is good for several chuckles. The inclusion of Jack Reeves' "The Source Code Is the Design" is an added bonus.
The physical aspects of the book are well done as well. The margins are small, with barely enough room for brief notes. There's a lot of material packed into those 500 and some pages. A hardcove is nice these days when most technical books are softcover. This one will lay open next to your keyboard without resorting to paperweights. One thing that bothered me a bit at first, or at least was distracting, came from the variety of the material.. some is older and pre-test-first, some is new and test-driven, C++, Java, etc. But once I got used to the contexts shifts they weren't a problem. Finally, as another reviewer mentioned, this book is full of code. Everything is illustrated with code. My advice: buy it, read it, learn it, live it. Your software will be better for it.
Rating:
Summary: deserves the five stars
Review: No other book has these topics -- Design Patterns, Test Driven Development, and Object Oriented Design Principles -- within its covers, with such extensive examples. One of the books I require my developers to read, along with Design Patterns by Gamma, et al., and Refactoring by Martin Fowler.
Rating:
Summary: Clear, specifc, applicable
Review: The bulk of this book describes OO design principles. They're presented in a readable, useful, and well-organized way. Often they just clarify and put a name to something you've probably been doing anyway. The standard Dependency Inversion Principle is there, for one. (I'm glad to see that other people have trouble with the name. By today's reckoning, there's nothing inverted about it, but the name dates back to less enlightened times.) Others, like the Interface Segregation Principle, are less well known but reinforce lots of other good practices, such as data hiding and prevention of "interface leakage". The "Agile" section is blessedly short, and doesn't much contaminate the otherwise good presentation elsewhere in the book. There's a lot of good to be extracted from the agility movement, but there's a lot of rabid dogmatism too. Martin managed to keep it well under control. He presented the Manifesto (ugh) early on, but that was the worst of it. A few points marred the book, but only slightly, The drawings came across as "cute" - unprofessional and tangential to the topics at hand. Semi-fictional conversations in books like this always seem fatuous to me, and Ch.6 was no exception. The technical content managed to withstand this presentation anyway. This book has lots of good ideas. It relates those ideas well to common and useful design patterns. A few aspects of the book tried to be funny, but came across as more annoying than anything else. That was only a few, though - the meaningful content of the book came through despite those flaws. I recommend this book to any serious student or practitioner of OO design and implementation. I really mean "any," since even project-scarred veterans are likely to see some of their hard won knowledge set into clear text and into the context of other ideas.
Rating:
Summary: A wonderful adjunct to the GOF design patterns book
Review: The title of this book belies much of its content. While agile development practices are espoused, much of the content is concerned with the application of design patterns in accordance with Robert's OO design principles. Robert does a wonderful job of explaining each design pattern, demonstrating their use through code, and placing them within the context of his design principles. The examples are numerous and, with a few exceptions, well written. Robert's OO design principles are real gems. His pragmatic approach combined with codifying the principles he's derived over the years makes for a very enlightening read. He articulates those things that most experienced developers have a gut feel for but have difficulty putting in to words. My only criticism is the need for a proofing scrub. There are inconsistencies between some of the class and method names used in the narrative versus those used in the accompanying diagrams and examples. In some cases, this is a bit confusing.
Rating:
Summary: Gotta have it.
Review: This book has had a profound effect on my coding. Uncle Bob does a masterful job putting together the fundamental principles, patterns, and practices that make him and his cohorts gurus. This book introduced me to a number of very important ideas in a very real context and helped me solidify some of the things that I only kind of understood. If you don't have your own personal guru to learn from, this book is the next best thing.
Rating:
Summary: The Software Engineers Companion
Review: This book is packed with software engineering practices. I expect to read it over and over again. I've been reading Robert's stuff ever since his book on C++/Booch. He has willingly shared his thoughts on [his website] and now a lot of it is gathered together in this book. Principles. These principles are the foundation upon each pattern should rest, the reference frame for good software engineering. Patterns. This is not just another GoF section. The patterns are discussed, in context, and related in a way that nicely complements GoF. Patterns not found in GoF are also presented. Practices. I've been practicing light weight methods long before the boost of Agile methods happened (Fowler, Martin). The test first design is a very exiting approach to design, leaving you with something much more valuable than mere diagrams - unit tests. The reason I like reading Robert's work is that one can tell he's a programmer (he's got code up to his elbows). I'm sure there is software engineers matching him out there but only a few that match his teaching skills and experience. Have you ever felt discouraged by books full of (UML) diagrams pretending that's all there is to software development? You won't feel that way reading this book. This is the revival of source code (complemented with conceptual diagrams), so be prepared to read some too. Isn't it great?
| 
