Feb 00 Bookshelf
Volume Number: 16 (2000)
Issue Number: 2
Column Tag: Programmer's Bookshelf
By Paul E. Sevinç, Switzerland
A Brief Guide to the Standard Object Modeling Language
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].
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].
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.
- [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.
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 email@example.com.