Rating: 
Summary: Wonderful introduction to OOA and OOD
Review: Coming from a VB6 (Book-Educated) background, OOA and OOD were very foreign to me. I had read some small explinations in a few books but it just wasnt enough to get me to start thinking in terms of OO.
This book finally did it for me. It leads you through the basic core concepts and patterns while showing you how to Diagram it in UML (This visual also helps in the learning process).
Overall a great find for me, after this I will be moving on to Object Oriented Construction.
Rating: 
Summary: Great book, nearly fatal whopper
Review: GRASP is a series of patterns? That's a pile of crap. GRASP is a list of design techniques and principles. Calling the elements of GRASP "patterns" is a serious violation of semantic integrity and precision, and makes the book a lot less valuable than it should be.
Considering the semantic precision of the rest of the book (its intent is, ironically enough, to teach us semantic precision), this mis-labeling of one of its truly central elements creates a jarring cognitive dissonance.
I make a big deal of this because the GRASP principles are introduced at the pivotal moment in the process when analysis is being rendered into design. This is the moment where the rubber meets the road, and the moment that most of us buy such books for. To be led astray just exactly then by this whopper of a misclassification is a nearly fatal flaw.
The fact that the rest of the book is really terrific makes up for this, hence the restoration of 3 stars. The workaround is also fairly trivial: if the reader simply repeats (like Dorothy with "There's no place like home...") "GRASP is a collection of principles. There are no patterns in GRASP," then the problem completely corrects itself, and the book becomes useful again.
Rating:
Summary: A good introduction, and more, to OO Analysis and Design
Review: I am in agreement with some of the observations made in the 1-out-of-5 review by wiredweird. However, I am inclined
to rate this book a 5 out of 5. There are a lot of books out there that talk about O-O but stop at inane and condescending examples that limits
what knowledge, if any, you could get from the books. On the other side of the spectrum, you have outstanding
books like "Design Patterns" that might be a little hard to follow for people like, for instance, me. The uniqueness
of this book by Craig Larman is that it effectively bridges the yawning gap between the O-O for idiots approach and
the O-O for experts approach. Granted that Mr. Larman seems to be calling "Principles" as "Patterns" -- it is kind of a
stretch to call "Polymorphism" a pattern, but nomenclature aside, the emphasis is rightly on general principles that
prevade patterns of design. Larman might have stretched the limits of UML notation here and there -- but it is
almost always to emphasize an idea. The main portion of the book deals with a case study involving a POS system -- good choice, a POS system is something
we are all familiar with and it offers a lot of possiblities to show the application of design principles and patterns.
Its possible that this is not the best book to teach (or to learn) O-O design -- but I havent come across one that is better. An irritant i have with this book is the quality of the paper used -- it reflects light making it a strain to
read it under fluorescent light. Maybe they will fix it in the next edition so that the reader is the only one doing the
reflecting.
Rating: 
Summary: Keep looking.
Review: I can not recommend this book. I find it confused and confusing, with no clear line between Larman's own diagrams and actual UML notation. Starting on page xvii (before the text even starts), this book mixes the UML comment notation with Larman's own boxes-and-arrows. Similar mixes appear on p.7 and many other places. By p.22 Larman has already confused comment and use-case notation. Diagrams like 17.4 use multiple different arrows to say apparently the same thing - or maybe not, it's not for the reader to know. A number of UML diagrams suffer similarly from creativity. It's never quite clear what marks are defined by the standard and which ones by Larman's over-active imagination. It would have been so simple to fix that confusion, too. Even something like tinting the official UML and leaving his own markup in black and white would have shown which was which. He uses common terms in baffling ways. I've been developing software for many years, and I thought I knew what development was. It's what a software developer does - it's all the work needed to start from nothing, then deploy and support the product. I was quite surprised to learn that planning and analysis are not part of the development cycle, but the start of Ch. 8 assures me that they are distinct. Larman asserts that development is architecture-centric, but makes this assertion when almost 90% of the how-to section has gone by. If archtiecture is so basic to all other design, then it really should have been there at the beginning. I've seen attempts to declare an architecture at the end of the project, and they are comical (as long as I'm nowhere near that project). I was also baffed to see "contracts" so deeply embedded in the UML methodology proposed. Contracts are good, I agree, but they don't become part of UML simply by wishing they were. This is the kind of presentation that will leave a UML novice (the book's intended reader) thoroughly misinformed. Most other authors distinguish between design principles and design patterns, a line that Larman fails to draw. Principles give an idea of how to divide responsibilities, irrespective of what those responsibilities are. The Law of Demeter, cohesion, and the idea of polymorphism are design principles. Patterns state specific responsibilities and assign them to specific (if abstract) classes. Publish/subscribe (aka Observer) is a pattern. It states which object type originates data and which receives it. It states how the receiver makes itself known to the originator. Patterns apply to specific relationships or behaviors, principles apply to any relationship or pattern. Losing the distinction is a real loss of descriptive power, and a disservice to both principles and patterns. The flaws go on, but this book has already taken up enough of my life. I strongly suggest that the reader look at any of the many other books on UML or on patterns. Even picking at random, you're likely to get a better reference.
Rating:
Summary: Great for learning OOA/D
Review: I've come from a mainframe background. I took C++ and Java classes and still didn't know how to design OO. This book has helped me cross that bridge. Highly recommended!
Rating:
Summary: The best book for introducing in OOAD and Design Patterns
Review: If you want to introduce to the world of OOAD and Desing Patterns this is the best book for you ! Don't doubt to buy this book. It has been my inspiration to teach OOAD in my Technology Institute in Culiacán, Sinaloa México. Really UML and OOAD was another thing since i knew the Craig's Book !
Rating:
Summary: Moving from the Classroom to the Real World
Review: One of the more difficult concepts to bring to programming is the very basic concept of Object Orientation. Most programming efforts in the college/university level are really short and quick, while most software projects in the real world are much bigger. Combining all this together you have the potential for turning out graduates that have a hard time in the real world.
An interesting point of this book is its overall design, which is laid out like a software project. That way you are working within the broad concepts while you don't even know that you are being exposed to them.
This is not a book on programming. You should know at least one object oriented language before beginning it. Java is used for most examples, but one of the C's or Python could be used.
The title of the book is somewhat misleading to me. True it is about UML and Patterns, but it's really the sub-title that tells the story. This is a book on object oriented analysis and design (OOAD). UML and Patterns are simply two of the tools used to teach OOAD.
Rating: 
Summary: excellent book for ooad
Review: The book is very effective in guiding the reader by giving a real-world example throughout the chapters. It covers concepts of solid object-oriented design principles, which helps improve a software designer's skill set. Especially as a student from other books I used this book is very clear and easy to understand thru out the chapters. The Author does a good job of showing how patterns are used within the context of the UP. The discussion on the FURPS & GRASP patterns is exceptional, because their application in more complex design patterns is shown as well. Also all the diagram that were listed have a a detailed brief dicription about them.
One thing i didn't like about this book is that, the Author tend to conflict with its statement. If someone went thru each line of the book it is easy to find where two ideas conflict to each other. And it very helpful to have guidance about the conflicting topics to be singled out by instructors, experience Engineers which helps me in my experience.
Rating:
Summary: Very clear and readable intro but too expensive
Review: This book is a really well written, clear, comprehensive exposition of software delopment processes and best practices, uml and design patterns. An excellent read for someone who has just learned how to program in an object oriented language and wants to progress to the next level. The strong points of this book are: it is very clear, to the point and gives a broad coverage of all relevant problems and techiques in software development. Weak points: it is way too espensive, it could be more in depth in some areas, and it would benefit from the addition of a few chapters on how to use CASE tools. Also, it is nice to see the POS case study evolve throughout the book, but it would be even nicer if one could see a diagram or two from other areas and context once in a while.
Rating:
Summary: The best tutorial on OOA/D
Review: This book nearly defies description in terms of the breath and depth of material it covers (and covers very well). In addition to OOA/D, you get essential and detailed information on Use Cases, Requirements gathering, UML, Design Patterns, and Iterative/Agile Development, as well as insights into Test Driven Development. And the best part: all of this information is carefully integrated so you really get a deep feeling for the multitude of skills it takes to be a software developer/architect in the 21st century. No book is a substitute for real world experience coupled with in depth instruction and mentoring, but this book comes as close as humanly possible to achieving those lofty goals without leaving your easy chair/workstation. Most in-depth books leave me with a headache - you get the gist, and then the brick wall goes up when you get to the details. Mr. Larman slowly and steadily gets you into the details without ever over simplifying, yet without sacrificing the "meat" Bravo!
| 
