Customer Reviews

UML 2.0 in a Nutshell (In a Nutshell (O'Reilly))

5 star:		(12)
4 star:		(5)
3 star:		(1)
2 star:		(3)
1 star:		(2)

 

 

This is the book that UML In a Nutshell should have been.

Several years ago I picked up the original UML In a Nutshell with high hopes; I didn't bother reading much of it in the bookstore because (after all) the book was an O'Reilly. It had an animal on the cover; quality was assured. I snapped it up and went home. It turned out to be the one of the worst computer books I'd ever bought, and many of the Amazon reviews agreed with me. I wrote my own scathing (but rather funny) review, and to be honest I don't know what happened to the book itself, I no longer cared.

A few weeks ago I received email from an editor at O'Reilly asking if I was the person who had posted that review, and would I be interested in a copy of their re-written book on UML 2.0? The book arrived a few days ago, and I've spent a couple hours going through it. (In the interest of disclosure, please note that I did not pay for my copy).

To put it mildly, UML 2.0 In a Nutshell is a vast improvement. I don't know how to emphasize this: It's like waking up from a bad nightmare of Throgzaks-are-after-you (and of course, you can't run) to realize that everything is okay and it was just the cat sleeping on your face. It is a huge relief that O'Reilly recognized their error and decided to fix it.

This book is smaller, more succinct and to the point. The authors dive into meaty subject material right away, starting with the stuff that most engineers are likely to use. The writing is pleasantly conversational, targetted to a technical (rather than a managerial) audience, and the subject matter is well organized. A challenge in grokking the UML is that it is a "wad" of interrelated concepts, and the book has sufficient forward references ("You'll learn more about X in chapter 4") that I felt comfortable just forging ahead. The diagrams are clear and meaningful, and there is (gasp) actual humor from time to time.

I get the impression that O'Reilly's first UML book was published in a hurry just to "get something out there." I have the impression that they took their time getting this one right. There is almost no comparison between the two; this is the book to get. Recommended.

I approached this book with some trepidation. I did not want to get into a sales pitch about the merits of one modeling tool over others. It quickly became obvious that this book is not about tools. In fact, the opposite it true. This book is truly about the UML. While there are sparse references to some tools, the text focuses on the UML as a standard and how to effectively and pragmatically apply it to your efforts.

Another concern I had when starting this book was a strict adherence to the UML. Much to my pleasure, this book takes a very pragmatic approach to modeling software systems. There are often statements indicating how "many designers do it" as opposed to the more formal approach. These situations show how making the UML work for you (as opposed to you working for the UML) does not cause any lack of clarity. In fact, it often adds to clarity and simplicity.

I really appreciate the way in which the text suggests approaching adoption and use of the UML. It would be difficult to try and quickly learn and apply all of the details, of all of the diagram types, and which arrows connect what shapes. The book addresses this by suggesting that readers adopt the UML in pieces. It also suggests that not every diagram type is needed for every situation. Once again, the text emphasizes a practical approach.

Although it would seem difficult to describe the graphical nature of the UML in text, the author does this quite adeptly. There is an excellent balance between figures and text. Examples are direct and meaningful. Also, the author does not dwell on how to model a software system. Instead, the focus is on how to use the UML as a modeling tool.

In addition to the UML-centric chapters, the book offers additional information related to software modeling. The first chapter provides an overview of the UML. This gives readers, especially those new to the UML, a nice foundation of vocabulary and purpose. The last chapter, "Effective Diagramming," provides readers with some solid guidelines on using the UML effectively. Here the author explicitly describes "appropriate" modeling techniques (Dare I say best practices?).

Appendix A provides an introduction to Model Driven Architecture (MDA). It really is a brief introduction that should kindle the reader's desire for more information. If you are feeling ambitious, you can also learn about the Object Constraint Language (OCL) described in Appendix B. The OCL is used in addition to the UML for more granular detail in describing constraints in UML models.

Overall I really enjoyed this book. I highly recommend it to people trying to learn the UML for the first as well as those wanting to know what has changed since previous versions of the UML. I recommend this book to both veterans and to those new to the UML alike because of how it is written. Both groups will find the book's pragmatic approach to using the UML quickly educational and beneficial as an on-going reference.

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".

Like the previous reviewer, Landon, I had read (or at least tried to read) the previous edition of UML in a Nutshell, and I thoroughly slammed it. And I too was contacted by O'Reilly to see if I would like to receive a free copy of this new edition. I must say I'm impressed by their commitment to their readers - I wrote that review YEARS ago, and they were thoughtful enough to follow-up with some of us.

Anyway, about the book. It's much, much better than the first one. The preface and chapter 1 are the only required reading. They explain some important changes from earlier versions of UML and also tell you how to navigate this book. Granted, you could read it cover-to-cover, but that would be pretty boring. Instead, like other good "In a Nutshell" books, it's designed to let you hit the ground running, applying specific portions of the book to your current needs. For example, if you're trying to learn about UML because you work on business processes and do a lot of whiteboarding, you can go directly to chapters 9 and 10. If you're a programmer working on protocols, you can go blah. If you're planning software configuration and deployment, you go to blah. Very handy.

So, in summary, a very good improvement over the first edition. And a handy guide that lets you hit the ground running. The only reason it's only 4 stars is that it's not the author's style is kind of dry. Nowadays I reserve my 5 star review of technical books for titles like Head Start Java.

It is a good effort to put such a good content in just 200 pages. The book shows old UML 1.4 elements by using the 'trap' mark so you can clearly tell it is something deprecated. It is a very clear book, and you can skip to any specific diagram you are interested. Unlike most other UML books, which has more content on methodologies, this book is focus on the language (diagram) itself.

It turns out there's more to UML than stick figures and boxes. "UML 2.0 In a Nutshell" (O'Reilly, ISBN 0596007957) by Dan Pilone and Neil Pitman is an excellent book for those new to UML and development as well as for those with a bit more experience in design and development.

The book makes for a great reference. Each chapter is encapsulated and starts with a high level view of a diagram type and then digs into the implementation details. Finding specific information doesn't take very long. The chapters are well organized - just as we all hope our own use of UML will lend our own work to be. The book is more than a reference. The authors provide sage advice and discussion on common practices and potential pitfalls.

UML made a big leap with its 2.0 release. I know we all have the time to read the thousands of pages of UML 2.0 specification out there; but for those of us who would appreciate a shortcut this book is it. The authors make sure to explain, succinctly, what the new release adds and changes are. They then provide an entire section on Model Driven Architecture (MDA) and a chapter on Composite Structures. The UML 2.0 updates are reason enough to read the book.

I needed better explanations on using UML correctly. I already owned a few books that were -- OK but lacking in a clear style of explaining the correct use of some of the UML. After reading the reviews on Amazon of other books, and the reviews of the updated version of this book - I took the leap and purchased this 2.0 update.

I am very pleased with the book, it is well written, and clear in its subject introduction and explanation of UML's symbols usage.

Being a thinner book makes it possible to have the information at hand when I need to carry my references back and forth from office and home.

I would like to thank the prior reviewers - who had received a copy from the publisher, for posting their reviews. The publisher was confident that they had fixed the problems with the earilier book, and I would agree that they have a very good product now.

The publisher deserves some congratulations on this approach. Good job!

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.

This is my first ever review on Amazon. Why now? Because I am so annoyed with this book I want to draw Amazon's attention to a problem I am noticing for Kindle adaptations of technical books - poorly scanned images.

I really want to read this book, I read the reviews for the paperback edition and it looks like what I want. I'm in New Zealand and it costs a fortune to ship books here, so Kindle is normally the best way to go. This book, however is unreadable because the diagrams (and in UML it's all diagrams) are so poorly scanned.

How did this book get through quality control?

Will be happy to re-review if it gets fixed.

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.