Rating: 
Summary: An Excellent Place to Start
Review: Applying UML and Patterns is a great introduction to UML and Object Oriented Analysis and Design. It has a nice slow curve to help introduce newcomers. Each chapter builds upon the concepts and examples of previous chapters to help walk the reader through the process. A point of sale system is used as a consistent example throughout the book. Each chapter adds new features to this system, while simultaniously introducing the reader to new UML concepts. Each new idea is accompanied by several example diagrams with notes to highlight important concepts. Each chapter also includes a quote that should appeal to one's inner computer geek.The linear progression of this book does have its downsides, however. It is difficult to find specific information, or to start in the middle. Each section assumes you've read everything up to that point, and those expecting to use the book as a refresher or reference may find it difficult to find the information they desire. Similarly, one may confuse the notes on the example diagrams as a part of the diagram if not familiar with the style of the notes. Overall it is a very well written book that should prove very useful to those new to UML and OOA/D. Those already familiar with the topic should probably look for a less structured source, but beginners should definitely give this book a try.
Rating: 
Summary: Excellent Software Engineering Title!
Review: I enjoyed this book greatly. It provided me with a solid understanding of how to work with UML and OOA/D. It not only covers the basics of UML but brings the reader through the process of creating software, using a persistent example throughout the book. It helped improve my knowledge of object oriented design and overall software engineering skill. I found the book clear and easy to understand. Additionally I found the examples very helpful in showing me exactly what needs to go into a certain UML artifact. The discussions on the GRASP design patterns and GoF design patterns were both very thorough and helpful and opened my mind to new ways of handling various software problems. The one problem I had with this book is the occasional instance in which the author contradicts himself. Overall an excellent book and I would recommend it to any future software engineer.
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: GREAT introduction to object-oriented design
Review: Despite the main title, this book is not just about the UML (UML is not OOA/D or a method, it is SIMPLY NOTATION). The book helps a developer learn core skills in the art and science of building object systems, rather than notation. In fact, it is not so helpful to learn syntactically correct UML diagramming, but then not be able to create an excellent design, or evaluate, or improve an existing one. This is the harder and more valuable skill. "How should responsibilities be allocated to classes of objects? How should objects interact? What classes should do what?" These are some critical questions in the design of a system. Knowing an object-oriented language is a necessary but insufficient first step to create object systems. This book helps a developer: Apply principles and patterns to create better object designs; Follow a set of common activities in analysis and design; Create frequently used diagrams in the UML notation.
Rating:
Summary: Learn to think in OO by example
Review: It is easy to run out of space just by listing the topics introduced in this book, nevertheless here are some of them: OO fundamentals, UML 1.4, design patterns, Unified Process, domain modelling, mapping of design-to-code (Java), architectural analysis, framework design and the list goes on... The content is organised in 6 parts, including a total of 36 chapters spread over 600+ pages. Long book, many topics... If you are after a quick or thorough description of a single topic then naturally this is not the right reading. The core offering of the book is the middle 4 parts that describe the analysis & design of the case study (a POS system). We are taken through the inception and 3 iterations of the elaboration phase of the UP. It is almost minimalist-UP, as the emphasis is on just doing what is necessary and not creating text/ diagrams for documentation purposes only; the code is the ultimate real model. Naturally, use-case driven, iterative and incremental development is highlighted. In addition, during the OOAD, we are taught how to harness the UML and not only shown the notation and elements that it contains. A good number of patterns are described, again while being applied to the case study, from the GRASP (essential if your background is not OO) to the GoF patterns and many others. The title and subtitle of the book are definitely justified. The author explains all techniques very well and provides precise definitions and examples that hit the spot. In fact, every decision taken when designing for the case study builds on notions previously introduced, thus demystifying OO design; Craig Larman proves it to be a science and not art or magic. Furthermore, numerous references are given for the principles illustrated as well as pointers for further reading (which sometimes are needed given the introductory nature of the writing). In reality, few developers are completely agnostic to all the topics covered in this book (and if they are, then it is the perfect read). Hence, given the intertwined exploration of all areas, few readers are going to avoid reading about material they already know. Following from the previous point, it is natural that the book does not serve as the best of reference titles; although its well-organised index, glossary and in-cover tables/ diagrams do help. In any case, this excellent book would make an ideal university course book.
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: A great learning book for overview of software engineering
Review: This book uses a POS system example to give the idea of software development from the beginning to the end. It concentrates on software designs and artifacts on each phase with good detail description. However, since each software development phase is large topic, it can not give every aspect of design concept but it can give you an overview anyway. This book is great for anyone who interests to apply systematic process to software development but does not know where to start.
Rating:
Summary: Book Review: "Applying UML and Patterns"
Review: Please see my expanded review at:
http://dotnetjunkies.com/weblog/fletcher.dunton/posts/5649.aspx I picked this book up several years ago while writing curriculum for a training class on OOAD and UML. My reason for seeking it was that I needed an alternative to several of the books that Rational published, including UML Distilled and The Unified Modeling Language User Guide. The later two texts just did not tie UML, process and practical examples together and Larman's book did. What appealed to me about "Applying UML and Patterns", is that it combined both theory and practice in manifold ways. I've critiqued each of the following areas: Software Development Life Cycle
UML
Patterns
Practical Case Study and Examples Overall, the book makes for good reading for developers and team leads alike. I recommend it as a baseline prior to choosing a UP based methodology and for those wanting to understand the big picture and how Use Case, UML, Patterns and UP can compliment on another. Happy Reading : )
Rating:
Summary: Pretty Readable For A Textbook
Review: I read Larman's Applying UML And Patterns in my software engineering course at university. Some good points about the text: it was very readable, there were many helpful examples and diagrams, and it showed the UP for one example (the point-of-sale system) rather than several unrelated examples. I think many students are able to relate to the POS system example due to the large percentage of us working retail jobs.
Some negatives are that sometimes the prose rambles a bit or it seems like the author wrote it during a very late night. Also I would have liked more comparisons between the many (and sometimes confusing) diagrams in UML.
Overall, I thought this book did a great job teaching the reader about UML diagrams, software patterns, and the many iterations of the UP.
| 
