Customer Reviews

Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development (3rd Edition)

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

 

 

There is a lot of textbooks on UML in the market, similarly on development processes like the Unified Process, design patterns and OOA/D. Many textbooks that I have seen provide a dry list of UML notations, or a dry list of process guidelines, or trivial examples on how a design pattern can be implemented. However, no other textbook in my opinion makes an excellent job in putting everything together in a case study (the 3rd edition provides two case studies) in order to illustrate (1) what is the significance of each one of the above, (2) how they fit together and (3) what are possible tradeoffs. The author very clearly explains what are the underlying principes behind object-oriented software development and (more importantly) how these principles can be put into practice.

Since the first edition I found Craig's writing style very easy to follow and as a graduate student taking software engineering and related classes I used this textbook as a self study to learn about OOA/D and UML. As an instructor I have been using this textbook for a number of software engineering and related classes (both senior level undergraduate and graduate), and the feedback I receive from students is very positive. I also recommend this book to students who are undertaking final-year undergraduate projects or graduate projects, and we have found this book to be very valuable for projects that involve several stages of analysis, design and implementation and who want to know how a process such as the Unified Process can be used in an agile manner. My experience tells me that this last point is very important for students who would work individually or in small groups over a (usually) short period of time to complete a development project.

Several of my previous students who are now employed in the IT industry as developers are telling me that they still use this book and find it a very valuable reference.

The book has also sparked interesting discussions among colleagues and researchers on various aspects on OOA/D and it is a valuable source. More particularly, the book successfully manages to integrate the principle of Design by Contract beyond implementation. Craig's approach to introduce operation contracts places emphasis on assertions from early stages of development and shows how this emphasis is propagated to detailed design (through UML communication diagrams) and through the use of responsibility patterns.

Regarding a comment on GRASP by a previous (and anonymous) reviewer, I would like to point out that a pattern is a set of principles (can be on any level of granularity) that solves a recurring problem at any stage during development. This (albeit informal) definition does not confine patterns to structural or behavioral design (along the lines of the GoF design patterns). Craig makes that very clear in the book particularly in the second and third edition) and I'm afraid to say that the reviewer who made the comment either skipped that part or misunderstood it.

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.

Let me say to begin that I am a graduate student in computer engineering, without a strong OO background. Sure I knew inheritance, polymorphism, and even some UML. But how do you really use them in practice? I have been eager to learn what this OOAD is all about, and anyway it's a valuable skill to possess.

Now where to begin learning OOAD? As I scratched the surface I encountered such oft-cited works as Design Patterns by the "Gang of Four", Booch's Object-Oriented Analysis and Design with Applications, and Object-Oriented Modeling and Design by Rumbaugh et al. Obviously many books attempt to explain the OO paradigm. Specifically I want one that is: 1.) interesting, 2.) informed, and 3.) insightful.

That's why I'm glad I chose this book. It's unmistakably for serious readers, and not as easily accessible or "witty" as a few others. On the other hand, if you want to encounter *many* useful concepts and suggestions from an authoritative source, then I can't imagine a better choice than Applying UML and Patterns. I've read it cover-to-cover once, and have already begun referring back to it for my own purposes.

Sometimes it's useful to understand the author's perspective, to know if you will learn anything useful from their books. Craig Larman is obviously a proponent of agile risk-driven software development, OOAD, and using the UML sparsely as a communicative tool ("sketching" vs. "blueprinting").

Larman makes a very strong case for his perspective, too. After all, everyone knows requirements evolve and change over time, as does design. So why not adopt a process that accomodates this? Similarly, the UML is potentially a complicated language, but why get caught up on notation? The point is to communicate something of value, especially during design, when collaborative decisions must be made - leave the rest to CASE tools. Don't be scared of the Unified Process either, as it provides a great context in which to discuss business processes and risk-driven software development, even if you never explicitly use it.

By the time you finish this book you will: have a good overview of iterative and agile software development, know aspects of the unified process, know the basics of the OO paradigm, know how to assign responsibilities to objects, have been exposed to the most common design patterns, have encountered a few analysis patterns, and have a wealth of tips and suggestions to draw from in your own work.

All of this is presented in the context of a case study on a fictional point-of-sale system. The book slightly favors Java in its examples, but as these are fairly sparse and generally brief, it should be easy enough to follow for those familiar with C++ or C#. The author tries to note whenever choice of language has a significant impact.

Even at nearly 40 chapters, I wish the book were longer, as Larman's writing style is coherent and enjoyable. You'll likely find yourself wanting to know more about software architecture or the details of certain patterns, and luckily the book is full of citations and suggested reading material.

It's a great place to start for students and professionals, anyone who wants to pick up OOAD. If you only want a reference on patterns, then this is probably not the book for you. It doesn't go into great detail about the more complex patterns. Therefor it's recommended that you own some of the classic patterns literature. Likewise if you primarily need a reference on UML, I'd recommend Martin Fowler's excellent UML Distilled. Again, the bibliography of Applying UML and Patterns is an abundant source of related works, for those digging a bit deeper.

I read the first edition of this book years ago when I was making the transition to objects. It was about the tenth book on the subject that I had read, but it was the first one that consistently anticipated the questions that came up when I was actually trying to build something using UML, long after the hype and "objects will save us" party atmosphere had died down. Craig Larman has carefully remembered, or has taught this enough to have been reminded of, the kinds of questions software practitioners actually encounter on the way to building systems using UML. This 3rd edition is twice as big as the first, and it is twice as good only because it is twice as much of Larman's excellent teaching.

This book is so good that even developers experienced with UML, the GRASP patterns, and agile development methods will gain from it, reminding us once again to balance the best practices that we apply perhaps a little unevenly at times. It is clearly a book by someone who has been there, and has remembered what it was like during the learning process. But perhaps its greatest strength is its application of very good theory in a very pragmatic way, in short, its balance. This is one of a very few books that I recommend to everyone I know in software.

I've been reading this book over the holiday break. I find the introduction to iterative development, Unified Process, and agile approach refreshing. The discussion on patterns is something of a review to me because I've already read the GoF book, and many patterns are just common sense that a good experienced developer should already know. The way to apply UML in iterative development in UP fashion using GRASP is the goal of the book, and it is very educational. However, I find the book is geared towards beginners. The text is easy read; fonts are relatively large as compared to technical books; and the author seems to repeat the idea over and over again while incrementally adding a little idea with each repetition. And I am not referring about the iteration development process. I am referring the author's style of writing. To an experienced developer, the content of this book could have been cut in half. I am taking 1 star as a result of this. Otherwise, a fine book.

I had a degree in Computer Science from a respectable university when I read the book. Still, I learned from the book so much that I realized I barely scratched the surface of OO design before reading it.

It teaches OO Analysis and Design using many techniques, such as writing use cases, modeling the business domain, drawing UML diagrams, using CRC cards, and going through agile iterative development cycles.

This book will not only provide you with a chance to learn OO Design, but also requirements gathering, analysis, and basic architecture and project management.

For people like me, that its main knowledge's source are books, this one is the best I read about OO. There are many advices about how to make systems well, clears many obscure concepts (at least for me) and get us focused on a balance between the analysys and desing metodology and code construction.
Very well done!

I've been toying with the idea of a more agile programming environment coupled with good visual documentation for quite a while. I'm a project manager in a small software company and I've finally gotten the time to do what I'm meant to do - manage projects! We all know what it's like...

Although I've known of Agile programming methods (Extreme Programming for example) for a while and am well aware of the Waterfall Method's shortcomings - and I've known about and used quasi-UML now for about 3-4 years - it's never really synthesised sensibly for me.

I took a 10 minute, sit in the bookshop, read this book and the concepts started to come together for me; I learn by seeing how the concepts are applied to real things or projects and there's plenty of examples actually worked through rather than piecemeal.

This book has a tone such that the author is actually there with you. It's not at all boring, it invites you to think with the author and for yourself and it's great for people like me who hate being talked down to by an expert - even if we know that expert knows more than us - because it feels as though it's simply a more skilled person communicating his skills to you.

I heartily recommend this book.

DSL

I have been using the 2nd edition to teach a semester long "Object-Oriented Software Engineering" subject at the School of Information Technology (James Cook University, Townsville, Australia) for the last 4 years (2002-2005), see

http://www.it.jcu.edu.au/Subjects/cp3120/2004-2/CP3120.HTML

On the positive side: It improved my own design and code dramatically. It looks like the Controller pattern has been overlooked by other pattern books. The book provides a seamless recipe for delivering design/code from the use cases (this is the only book that I know that actually does that). So I strongly recommend the book as a self-study book for a professional programmer.

However as a teaching tool: here are some of the problems that forced me to look for a different text book for the next year:

1A. The book still does not come with lecture notes. (I have to write my own for the 2nd edition)
1B. It does not have exercises/problems for teaching.
1C. It has no realistic java code examples (the old problem with explaining concepts using toy-examples).
1D. It completely ignores interaction with GUI (saying .... we are not modeling outside the domain?). This did not help as all our assignments have complicated GUIs (preparing for the real-world jobs).

2. Covering UP/RUP and patterns in one semester is too much. It is better to do less but better. UP/RUP is more relevant to a generic software engineering subject as the current best practice in SE. Plus after teaching from the book for 4 years, I cannot see how anyone could implement the UP following the book. You would still have to get a different book for it.

3. Some (if not most) students were really struggling with the book. Larman explains things in too many words (actually pages and pages of it), which is even for a native English speaker is a lot of reading for little TESTABLE reward, not to mention our Asian students.

4. Larman is expensive and physically big (less chances for students to carry it around for tutorial and lectures). The 3rd edition is even bigger.

Dmitry
dmitry.konovalov@jcu.edu.au

I have to disagree with whoever said this is a great book for beginners. There is too much information to the point of overkill. I am getting more enlightenment from going to www.omg.org and reading the UML specs. The author interjects way too much unnecessary information, then takes a good example model (like on the back page) using default language, only to throw "veggieburger" in the middle of it all, which to a novice lends only to confusion.
I am in the middle of reading this so I may change my stripes by the end, but I really don't see it happening. "UML 2 Toolkit" and "Head First Design" have helped me learn this stuff much faster.