System developers have used modeling languages for decades to specify, visualize, construct, and document systems. The Unified Modeling Language (UML) is one of those languages. UML makes it possible for team members to collaborate by providing a common language that applies to a multitude of different systems. Essentially, it enables you to communicate solutions in a consistent, tool-supported language. Today, UML has become the standard method for modeling software systems, which means you're probably confronting this rich and expressive language more than ever before. And even though you may not write UML diagrams yourself, you'll still need to interpret diagrams written by others. UML 2.0 in a Nutshell from O'Reilly feels your pain. It's been crafted for professionals like you who must read, create, and understand system artifacts expressed using UML. Furthermore, it's been fully revised to cover version 2.0 of the language. This comprehensive new edition not only provides a quick-reference to all UML 2.0 diagram types, it also explains key concepts in a way that appeals to readers already familiar with UML or object-oriented programming concepts. Topics include:

• The role and value of UML in projects

• The object-oriented paradigm and its relation to the UML

• An integrated approach to UML diagrams

• Class and Object, Use Case, Sequence, Collaboration, Statechart, Activity, Component, and Deployment Diagrams

• Extension Mechanisms

• The Object Constraint Language (OCL)

If you're new to UML, a tutorial with realistic examples has even been included to help you quickly familiarize yourself with the system.

Amazon.com® Reader Reviews (Ranked by Helpfulness)

Average Amazon.com® Rating:  Based on 15 Ratings

One of the Best UML Reference Books On the Market Today & Very Portable - 2007-03-11
Reviewer Rating:
When searching for a very good UML reference book last year, I happened upon the book entitled "UML 2.0 in a Nutshell" by Dan Pilone with Neil Pitman. The book, which measures a mere 8.9 by 6 by 0.8 inches, is both lightweight and highly portable; which is one of the reasons that I decided to purchase a copy. However, it was ultimately the content of the book, and not its compact size, that convinced to me that this would a very useful resource. Condensed within 216 pages, "UML 2.0 in a Nutshell" lives up to its title, as the book is an extremely informative resource in understanding the various graphical elements that comprise UML with its nine types of diagrams.

The book's 12 chapters and two appendices are divided into four main parts: an introduction, static diagrams, behavioral modeling diagrams and finally, extensions and applications of UML.

First Part: Introduction

chapter 1: Fundamentals of UML

This chapter provides a short, but good introduction to the fundamentals of UML. If you have never used UML before, this will help to introduce several key concepts of UML; but you might want to consider purchasing a UML tutorial book, such as "UML Weekend Crash Course" by Thomas A. Pender, to obtain a more hands-on approach to learning UML.

Second Part: Static Diagrams

Chapter 2: Class Diagrams

Class diagrams are one of the most important aspects of UML. With class diagrams, the relationships between classes can be thoroughly illustrated, including the strengths of the relationships between classes. This chapter provides a precise description of the various ways that class relationships can be defined within UML: dependencies, associations, aggregations, compositions and generalizations; as well as association classes. This chapter also discusses class members (variables & methods), whether a class might be abstract or an interface, and templates.

Chapter 3: Package Diagrams

Classes that are contained within a common package can be illustrated within UML using package diagrams. This chapter also includes relationships between packages and use case packages.

Chapter 4: Composite Structures

This chapter discusses composite structures that exist during runtime, including connectors and ports, as well as collaborations.

Chapter 5: Component Diagrams

Components (replaceable & executable pieces of a larger system whose implementations are usually hidden) can be used in UML as either a black-box or white-box view. This chapter discusses both uses.

Chapter 6: Deployment Diagrams

This chapter discusses how the deployment of an application (which may include many pieces) can be illustrated within UML, including artifact instances, manifestations, nodes, devices, execution environments and communication paths.

Third Part: Behavioral Modeling Diagrams

Chapter 7: Use Case Diagrams

This chapter documents how an actor (a person or another application) interacts with applications and their internal components.

Chapter 8: Statechart Diagrams

This chapter discusses the two types of state machines that can be described in UML: behavioral state machines and protocol state machines. This includes states, composite states, submachine states, transitions, activities, pseudo-states and event processing.

Chapter 9: Activity Diagrams

This chapter discusses how activities and actions are illustrated within UML, including activity edges, activity nodes, object nodes, control nodes and more advanced activity modeling: activity partitions, exception handling, expansion regions, looping, streaming, interruptible activities and data store nodes.

Chapter 10: Interaction Diagrams

How UML is able to illustrate interactions between objects is accomplished through interaction diagrams. This chapter discusses usage of interaction participants, messages, execution occurrences, state invariants, event occurrences, traces, combined fragments, interaction occurrences, decompositions, continuations, sequence timing, timing diagrams and communication diagrams.

Fourth Part: UML Extensions & Applications

Chapter 11: Tagged Values, Stereotypes and UML Profiles

This chapter discusses use of stereotypes, tagged values, constraints and UML profiles.

Chapter 12: Effective Diagramming

This chapter is essentially a "do" and "don't do" chapter that emphasizes the need to keep UML diagrams as simple as possible, though that is not always possible.

The two appendices: Appendix A is about MDA (Model-Driven Architecture) and Appendix B is about the object constraint language (OCL), which is an extension of UML 2.0.

Overall, I rate "UML 2.0 in a Nutshell" with 5 out of 5 stars and highly recommend it to anyone learning and/or using UML on a regular or infrequent basis. I have yet to see a book as well written as this in explaining the many aspects of UML in as a concise & easy-to-understand form as "UML 2.0 in a Nutshell".

Only a reference guide - 2007-11-11
Reviewer Rating:
This book is just a reference guide for UML 2.0. Well categorized, small examples for each UML concept but nothing else. If you want to learn UML from scratch this is not the first book you want or even need to read. If you are a proficient UML designer you won't need it. If you are in the middle path this book can help you a little, when you forgot something specific for example. Although you can easily find the same information googling elsewhere.

I'm not telling you this is a waste of money. Just don't expect too much.

Great reference - but it is a reference - 2007-12-08
Reviewer Rating:
I am a software developer with 15 yrs experience, been a Java developer for the last 7. Never worked in a heavy UML environment but have been required to put together class diagrams and wanted to learn more about other UML features. This book is not a cookbook, a how-to, or a learning guide, so if you need to learn and use UML in a heavy-duty way this book is not the right one. However, this book is great as an overview and reference, and it allows me to speak intelligently about UML and understand diagrams. Certainly would recommend it for other developers who wish to have a working understanding of UML.

Poorly organized - 2009-07-16
Reviewer Rating:
This is my first O'Reilly book and I am a bit disappointed. The book seems to be poorly organized and simply thrown together. There are numerous locations in the book that while trying to explain a particular item, you are often referred to other parts of the book - like chapters you haven't read yet.

Here is one example:

In the chapter for Use Cases, four pages into the text, there is a sentence that states, "What happens after a use case begins execution is specified elsewhere (see "Use Cases")." I am already reading Use Cases, start over??? What do they mean? There is nothing in the chapter that addresses this particular issue, so where do I look now? After reviewing the index, I discover that they probably mean "Use Cases" in another book because there is nothing in this book that speaks about what happens after a use case begins execution - unless it is cryptically hidden somewhere or in one of the hard to read diagrams. :)

There are numerous sections in the book that require prior knowledge to fully understand the text. So, my plan is to finish reading the book and then re-read it so that when I am referred to a future chapter, I will have already read it and hopefully the second time around I will gain the understanding I was hoping to gain during the first read. This is extremely disappointing.

Also, many of the diagram in the book are too small and don't appear the way they are described in the text. You are told that there are solid and dashed lines but, when you examine the diagram it is sometimes extremely difficult or impossible to determine which lines are solid and which are dashed. True, they had to resize the images to fit within the allowed width of the page, however, it would have been far better to design the images with this in mind so that dashed lines appear dashed, etc.

This experience will cause me to proceed with caution anytime I am considering another O'Rielly book.

It helps understand the basics - 2008-03-22
Reviewer Rating:
It provide enough "life" examples to permit you to understand the basic. It is a great complement to maybe a college book that provides limited examples.

Browse Similar Topics

Top Level Categories:
Programming
Software Engineering

Sub-Categories:
Programming > UML
Software Engineering > OOP
OOP > Methodology
OOP > Use Cases/Requirements
Software Engineering > UML