I was looking for a way to present to a reviewing committee an educational video game which I am designing. "Learning UML 2.0" was at the right level of detail to show me what diagram types I might use.

The book is right for a person who taken a course in Java or C++ where you do many small problems, and now you need a plan for outlining a larger project. I think the book would be very difficult for anyone who had not programmed in Java or C++.

Many years ago I had vacillated among the notations of Rumbaugh, Booch and Jacobson. It is satisfying to see their ideas combined in a common notation.

Reading this book before and during an object-oriented design project will alert you to problems before they become errors.

I'm a junior Java programmer and the main reason why I came into contact with UML is because some of the major Java IDE's like Sun Java Studio and NetBeans have fully adopted support for UML modeling. Even though the tutorials on the Sun and NetBeans website give you a very good heads up and despite the fact that there are many UML tutorials available on the web I wanted more. Both a learning guide as well as some good reference.

And thats what I found in Learning UML from O'Reilly. What I like best about this book is that even though it covers the entire UML 2.0 spectrum it doesn't try to cover every little detail which don't add to the learning experience. Instead it gives you clear links for further reading or browsing (for example; it covers some of UML's history and gives you links for more detailed stories).

Another very important part for me is the way the book is setup. It seperates the different diagrams and follows a very logical order. From Use Case to Activity, Class (both regular and advanced), Object, Sequence, Communication, Timing, Component, State and Deployment. And because each chapter covers one diagram (with the exception of the class diagram which covers 2 chapters) its very easy to use this book both as learning tool as well as reference.

And the reason why I'm writing up this review.. This book assumes that the reader is already somewhat familiar with Object Oriented (OO) programming as well knows a little about Java. Examples where they show how some code snippets functionality are being displayed in a model are based on Java. However, despite that detail it doesn't result in a book which is only usable for Java (-like) programmers.

So summing up: A great book to learn UML and use as reference.

I've read a couple of other books that talk about UML, but they seem to just skim the surface and try to talk simple to you. This book is truly for someone who wants to learn about UML and how to use it properly.

I recommend reading through the whole book once quickly and then go back and read it again carefully. I believe that's the best way to learn the details presented in this book.

I found this book to be largely readable and comprehensible. The writing style is fluid and the book is laid out well. One notable omission is a quick reference chart -- but the chapters are well laid out enough and short enough that I don't think it will be much of an issue in practice. I recommend this one.

I liked this book better than "UML 2 for Dummies". I thought "Learning UML 2.0" was more concise and had more illustrations per page of the UML diagrams being introduced.

I found the presentation pragmatic, readable, and practical.
It is easy to pick a UML Diagram type you want to use and start reading, drawing.
UML is a straight forward notation and these authors presents it as such. (Perhaps because it is straight forward many other authors seem to make their UML exposition much more complex than it needs to be).

Excellent book. Entertaining, not distracting with formal details or innecessary stuff that only appears in the UML specification. This book will give you excellent practical insight on the stuff that matters in the day to day development using UML.

This book could have been titled UML 101, because it is very readable. However it assumes that the reader knows a bit of an object oriented language, in particular Java. Chapters 4 thru 7 demonstrate how UML diagrams are used to model OOP principles such as class inheritance, interfaces, and messaging using Java snippets of code. This is an important part of the book, but it isn't a show stopper for those unfamiliar with object oriented concepts. The authors briefly explain what classes are; they also define abstraction, encapsulation, state, and behavior.



I Highly recommend this book for getting familiar with UML.

In particular:

- It's very readable.

- It is not specific to any UML software tool, only the standard symbols and diagram layout practices.

- It is a book that you could open up to any page and browse.

- As a future reference.

This book could have been titled UML 101, because it is very readable. However it assumes that the reader knows a bit of an object oriented language, in particular Java. Chapters 4 thru 7 demonstrate how UML diagrams are used to model OOP principles such as class inheritance, interfaces, and messaging using Java snippets of code. This is an important part of the book, but it isn't a show stopper for those unfamiliar with object oriented concepts. The authors briefly explain what classes are; they also define abstraction, encapsulation, state, and behavior.

I Highly recommend this book for getting familiar with UML.
In particular:
- It's very readable.
- It is not specific to any UML software tool, only the standard symbols and diagram layout practices.
- It is a book that you could open up to any page and browse.
- As a future reference.

Nice to read and quick to understand with the illustrations. Well described examples and after going through the frist few models you would able to quick start building the models. Overall, It is recommended for a one time read.

Nice to read and quick to understand with the illustrations. Well described examples and after going through the frist few models you would able to quick start building the models. Overall, It is recommended for a one time read.

Based on a recent project at work, I realized I needed a better understanding of UML. To that end, I decided to review the book Learning UML 2.0 by Russ Miles and Kim Hamilton. While there's still a lot to learn there, I think I have a much better grasp on what's going on...

Contents: Introduction; Modeling Requirements - Use Cases; Modeling System Workflows - Activity Diagrams; Modeling a System's Logical Structure - Introducing Classes and Class Diagrams; Modeling a System's Logical Structure - Advanced Class Diagrams; Bringing Your Classes to Life - Object Diagrams; Modeling Ordered Interactions - Sequence Diagrams; Focusing on Interaction Links - Communication Diagrams; Focusing on Interaction Timing - Timing Diagrams; Completing the Interaction Picture - Interaction Overview Diagrams; Modeling a Class's Internal Structure - Composite Structures; Managing and Reusing Your System's Parts - Component Diagrams; Organizing Your Model - Packages; Modeling an Object's State - State Machine Diagrams; Modeling Your Deployed System - Deployment Diagrams; Object Constraint Language; Adapting UML - Profiles; A History of UML; Index

Miles and Hamilton use a conversational approach to introduce the reader to UML 2.0, and they build on a model that makes sense. The Use Case view drives nearly everything, as that's the "what" of what the system is supposed to be able to do. Then they cover the logical, process, physical, and development views that support the system and show different perspectives of what the system will look like depending on which angle you view it from. All too often, it seems like UML diagrams are just thrown at the reader one after another, and there's no real explanation as to how it all fits together. Fortunately, that's not the case here, as the model framework for their tutorial puts everything in the right relationship to each other. I also appreciated how the diagram tutorials started out with just the basics and built from there. Again, it's common to see a tutorial diagram with every possible permutation thrown in right at the start. As such, it's far too easy to zone out right away because of all the baggage. Here, you get the core elements of the diagram first (which often cover 80 - 90% of what you need to know anyway), and then the extra details are introduced after that. I was much better able to conceptualize the whole discussion when put in that light... Very nice job...

I would say that if you have this book coupled with a full UML 2.0 reference manual of some sort, you'd be pretty well set to do most anything you'd need to in the world of UML. I know I'm better equipped to do those sequence diagrams now, where before I was faking it pretty well... :)

Easy to understand -- great diagrams -- I highly recommend this book.

Easy to understand -- great diagrams -- I highly recommend this book.

Unfortunately, this book is so poorly written that it is often confusing. Especially for a beginner, I highly recommend obtaining a copy of Pilone's book instead. The examples are much clearer and easier to follow, and the exposition is extremely clear.

Unfortunately, this book is so poorly written that it is often confusing. Especially for a beginner, I highly recommend obtaining a copy of Pilone's book instead. The examples are much clearer and easier to follow, and the exposition is extremely clear.

I just finished Learning UML 2.0. Java is an object-oriented programming language. The power about Java comes from the ability to create objects from classes. Classes should be written to promote encapsulation, inheritance, and polymorphism. Objects that are instantiated from classes can become very complex. UML (Unified Modeling Language) is a tool to diagram and model objects. I love the Java language. However, I was deficient in using a modeling tool to diagram the structure of complex systems. UML and Software Engineering concepts have made me a better programmer. I was impressed with this book and have already purchased the related book UML 2.0 in Nutshell. If you are looking into learning UML I recommend this book.

I just finished Learning UML 2.0. Java is an object-oriented programming language. The power about Java comes from the ability to create objects from classes. Classes should be written to promote encapsulation, inheritance, and polymorphism. Objects that are instantiated from classes can become very complex. UML (Unified Modeling Language) is a tool to diagram and model objects. I love the Java language. However, I was deficient in using a modeling tool to diagram the structure of complex systems. UML and Software Engineering concepts have made me a better programmer. I was impressed with this book and have already purchased the related book UML 2.0 in Nutshell. If you are looking into learning UML I recommend this book.