Feb 00 Bookshelf
Volume Number: 16
Issue Number: 2
Column Tag: Programmer's Bookshelf
UML Distilled
By Paul E. Sevinç, Switzerland
A Brief Guide to the Standard Object Modeling
About the UML
Before I talk about Martin Fowler's and Kendall Scott's UML Distilled: A Brief Guide to
the Standard Object Modeling Language [Fowler with Scott 2000], let me tell you a
tiny bit about the Unified Modeling Language (UML) and its history.
Basically, software development consists of three iterated steps: analysis, design, and
implementation. While you might invent your own programming language for the
implementation, most of us use a mainstream language like C++ or Java. Among other
reasons, this allows many developers to read and understand our source code - at least
locally. To get the big picture (i.e., the architecture) of a non-trivial software
system, they probably need to see the diagrams and other figures we sketched during
the analysis and design phases. What the graphical and textual elements in these
figures mean (abstract class, is-a relationship, method invocation, etc.) is defined by
a modeling language - again, this might be an invention of your own.
In the mid-nineties, several popular modeling languages existed. Grady Booch and
James Rumbaugh decided to end -i.e., win- this "method war" by merging their
methods. (A method consists of a modeling language and a process. A process suggests
how to proceed with development.) And so, in 1995, they published the Unified
Method. Ivar Jacobson then joined Booch and Rumbaugh at Rational Software to include
his method as well. Because Booch, Jacobson, and Rumbaugh (also know as The Three
Amigos) worked for the same company, the Object Management Group (OMG) formed a
task force to standardize a non-proprietary method. One of the proposals submitted to
the task force was Rational's UML. (Its process is the Rational Unified Process [RUP]
and is more or less independent of the modeling language.) The OMG adopted this
proposal with modifications, and at the time of this writing, version 1.3 is the OMG
UML standard [OMG 1999].
For more on the history of the UML as well as on its future, see [Kobryn 1999]. Books
about the UML and the RUP by The Three Amigos are [Booch et al. 1999], [Jacobson et
al. 1999], and [Rumbaugh et al. 1999].
UML Distilled
This review is based on the first printing of the second edition of UML Distilled. I have
to mention this because Martin Fowler not only updates the book between editions but
also between printings. (If you're wondering why I don't mention Kendall Scott: I'm not
really sure. In the book it says Fowler with Scott and not Fowler and Scott, Scott's
name is printed smaller than Fowler's, and the text is written in the first person.)
UML Distilled encompasses eleven chapters, two appendices, a bibliography, and an
index. That said, let's discuss the book chapter by chapter.
Chapter 1, Introduction, is -oh wonder of wonders- the introductory chapter. Fowler
first defines the terms method language and process and recaps the UML's history.
(Sounds a lot like my introduction so far, doesn't it? Well, guess where I stole it
from!) He then defines the terms notation and meta-model and talks about when and
how to use the UML and other object-oriented techniques. The definitions are
important of course, but as valuable is that Fowler shares his vast experience with the
reader both in this chapter and all the others.
Chapter 2, An Outline Development Process, is not about the RUP. However, what
Fowler discusses in this chapter is -according to him- consistent with the RUP. On
about 20 pages he treats four development phases called inception, elaboration,
construction, and transition which together encompass his "lightweight,
low-ceremony process". How useful this chapter is depends on your experience and
what your next projects are. If you're new to (object-oriented) programming, I think
you shouldn't read this chapter yet; try first to develop an approach that works for you
while your code is not supposed to be reused. If you already have gained some
programming experience with or without a formal process, the level of detail in this
chapter is just perfect. More experienced programmers probably want to quickly read
this chapter and then move on to the RUP.
Chapter 3, Use Cases, is the first chapter that actually discusses UML elements.
Fowler gives examples of both a textual use case and a use-case diagram. I would have
liked him to better explain the so-called extend relationship. But the other
explanations are clear despite being short, too. After reading this 9-page chapter, I
was able to use use cases right away.
Chapter 4, Class Diagrams: The Essentials, and chapter 6, Class Diagrams: Advanced
Concepts, are complementary. While I understand Fowler's decision to treat class
diagrams in two chapters in order not to overwhelm the reader, there are a few things
(e.g., abstract classes) I would have put in chapter 4 instead of chapter 6. But that's
the only thing I can reproach these chapters with. Together, chapters 4 & 6 comprise
about a fourth of the book. (I'm not sure I want to know what they would look like
unfiltered...) Covered is everything I would have thought of and more: subclasses,
visibility, templates, interfaces, etc.
Chapter 5, Interaction Diagrams, is about sequence and collaboration diagrams. These
diagrams visualize basic interactions between objects: method invocations
(synchronously or asynchronously) and object creation & deletion. Fowler devotes
about as much space to the five figures as to the text that describes them. Most of the
figures throughout the book contain two types of elements by the way: actual UML
elements and descriptive elements (i.e., arrows with a label) which Fowler added and
which are easily recognized as such.
Chapter 7, Packages and Collaborations, is somewhat confusing. It explains really well
what packages are, but in the section on collaborations, Fowler should have better
explained the relation between collaborations, collaboration diagrams, and interaction
diagrams. For once, the distillation left back too little.
Chapter 8, State Diagrams, might cause some readers to experience a déjà vu as UML's
state diagrams are based on David Harel's statecharts. But even if you haven't heard
about statecharts before, you won't have any problem understanding Fowler's
explanations.
Chapter 9, Activity Diagrams, describes activity diagrams in more detail than they
warrent in this short book. - At least that's what Fowler thinks. I find that the level of
detail and the length of the chapter are just fine. There's no real reason to remove
anything from this chapter even if other authors start writing about activity
diagrams.
Chapter 10, Physical Diagrams, is a very short and very easy to understand chapter.
It introduces deployment diagrams which show the physical relationship among
hardware and software components. And it introduces component diagrams that show
components and their relationships. Actually, it introduces both types of diagram at
pretty much the same time. And the only figure in this chapter combines them as well.
Chapter 11, UML and Programming, features an example software project. Fowler
uses class, object, and sequence diagrams as well as Java code snippets to illustrate it.
The good news it: the example is not trivial. The bad news is: programming beginners
may have a hard time understanding it. Note that additional information about this
example can be found on Fowler's home page [URL].
Conclusion
There is seldomly so much consensus about something IT-related as there is for the
UML. Both the industry and academia are rapidly adopting it and -in my opinion- so
should you.
A nice feature of UML Distilled are the sidebars. They briefly introduce software
engineering tools and techniques such as patterns, CRC cards, and design by contract. I
also appreciated Fowler's pointers to other sources of information.
While there are certainly several good books about the UML, you cannot go wrong with
UML Distilled. It is very concise without being superficial or difficult to understand.
And even though it is only intended to be an introductory textbook, I also use it as a
reference book.
References
• [Booch et al. 1999] BOOCH, Grady, RUMBAUGH, James, JACOBSON, Ivar.
- The Unified Modeling Language User Guide, Addison-Wesley, 1999.
• [Fowler with Scott 2000] FOWLER, Martin, SCOTT, Kendall. - UML
Distilled: A Brief Guide to the Standard Object Modeling Language,
Addison-Wesley, 2000.
• [Jacobson et al. 1999] JACOBSON, Ivar, BOOCH, Grady, RUMBAUGH,
James. - The Unified Software Development Process, Addison-Wesley, 1999.
• [Kobryn 1999] KOBRYN, Cris. - UML 2001: A Standardization Odyssey,
pp. 29-37 in: Communications of the ACM, Volume 42, Number 10, October
1999.
• [OMG] Object Management Group. - OMG Unified Modeling Language
Specification, Object Management Group, June 1999. Available at
<http://www.rational.com/uml/index.jtpml>.
• [Rumbaugh et al. 1999] RUMBAUGH, James, JACOBSON, Ivar, BOOCH,
Grady. - The Unified Modeling Language Reference Manual, Addison-Wesley,
1999.
• <http://ourworld.compuserve.com/homepages/Martin_Fowler>.
______________________________
Paul is an EE student at the Swiss Federal Institute of Technology Zurich (ETHZ) who
has no idea what he should tell you about him this month. He welcomes suggestions at
psevinc@ee.ethz.ch.