Tutorial: An Overview of UML 2.

0
Bran Selic
IBM Rational Software Canada
bselic@ca.ibm.com

Abstract
This half-day tutorial covers the salient aspects of the
first major revision of the Unified Modeling Language
UML 2.0. In this brief summary, we briefly review some
of the main points covered in the tutorial.

1. Introduction
The Unified Modeling Language (UML) was launched
in 1995 and adopted as an industry standard by the Object
Management Group (OMG) in 1997 [3][7]. Since then, its
use has been steadily increasing in both industry and
academia to the point where it has become the prevalent
general-purpose modeling language. As experience with
UML grew and the issues and needs of software modeling
became better understood, new requirements for UML
emerged. This led to the issuing of formal requests for the
first major revision of the standard. The requirements
called for increased precision, greater clarity of the
specification, and some new modeling capabilities.
Concurrently with the publication of the requirements
for UML 2.0, and inspired in a large part by the
widespread adoption of UML, the OMG launched its
Model-Driven Architecture (MDA) initiative. This
defines a conceptual framework for a model-driven
approach to software development and, based on that, a
roadmap for a set of corresponding industry standards.
This had a significant impact on the ultimate form of
UML2.0, since one of the key elements of MDA is the
potential for using modeling languages for more than just
documentation and high-level design sketching. This
includes the abilities to automatically generate
implementations from models or to perform complex
formal analyses to determine the soundness and validity
of proposed designs.
In fact, supporting automation is one of the
cornerstones of MDA. This means the use of computers
to mechanize some of the more complex repetitive
activities involved in software development that were
traditionally by programmers. Needless to say,
automation is one of the most effective technological
means for improving productivity and product reliability.

UML 2.0 is defined by a set of four distinct but related

specifications [3][6][7][8]. These are currently
undergoing finalization prior to becoming fully endorsed
OMG standard technologies.

2. Principal Distinctions of UML 2.0

The following aspects most clearly distinguish UML
2.0 from earlier versions:

An increased level of precision in describing the

basic modeling concepts in the language and, in
particular, their semantics.
An improved capability to model large-scale
software systems. This includes the ability to
model entire system architectures in effect, to
use UML as an architectural description language.
Enhancements to allow modeling of complex
network-based business processes and other
functionally oriented applications.

We briefly examine each of these in turn.

3. Increased Semantic Precision

There are numerous ways in which automation can be
usefully applied to models including:
Automatic code generation this can range from
fairly rudimentary skeleton code generation
(consisting primarily of structural declarations)
all the way to full code generation, whereby the
entire program that implements a given model is
automatically generated from the model.
Automated analysis of models to determine the
correctness or adequacy of designs. This includes
both qualitative analyses by which the safety and
liveness properties of a proposed system design
are verified (e.g., by formal model checking), as
well as quantitative analyses that determine that a
systems qualities of service (e.g., response times)
is adequate. Such analyses typically involve (i)
transforming a UML model into a form suitable
for the analysis on hand, (ii) performing the

Proceedings of the 26th International Conference on Software Engineering (ICSE04)

0270-5257/04 $20.00 2004 IEEE

analysis itself with a suitable tool, and (iii)

presenting the results back in the context of the
original source model.
Model execution/simulation on computers. This is
a common way of validating proposed designs.
While not as comprehensive as formal validation,
it is often far more practical when formal methods
prove infeasible. It is particularly useful to be
able to execute very rough (abstract) models
defined in the early stages of development since
that is when most of the critical design decisions
are made.
In general, to support any of these forms of
automation, it is necessary to eliminate any ambiguity
about the meaning of a model. Hence, the semantics of
the basic modeling concepts in UML have to be very
precisely defined. In UML 2.0, this was achieved by a
number of techniques, including a re-factoring of the
metamodel into primitive concepts whose semantics can
be easily expressed and then combining them to produce
more sophisticated and more powerful user-level
modeling capabilities.

including business process modeling and systems

engineering, which have developed powerful modeling
capabilities based on a functional view of behavior. UML
2.0 supports this through a significantly enhanced activity
modeling formalism. The semantics foundation for
activities is now based on Petri nets rather than on the
more constraining state machines used in UML 1. In
addition, major new capabilities have been added to
support the kinds of functional flows that occur in
complex business processes.

4. Summary
UML 2.0 is a language that was designed for modeldriven development methods although it can still be
used in the traditional way as an informal tool for
capturing and describing ideas in a technology
independent way. Of course, it represents just the first
generation of modeling languages, comparable to Fortran
as a harbinger of things to come. Without doubt, we will
see new and more sophisticated modeling languages
emerging in the near future based on the experience
gained from applying and studying UML 2.0.

4. Large-Scale System Modeling

5. References
The more complex a system, the more value there is in
modeling it. This is because modeling is, primarily, an
abstraction mechanism. It allows us to remove or hide
distracting detail and reduce a system to a more readily
understood essential form.
UML 2.0 includes a number of important new
features that allow it to be used as an architectural
description language. The basis for these capabilities
comes from previous work on architectural description
languages [1][2][10]. These languages support
hierarchical modeling of run-time structures of
communicating components. The concepts are generally
defined recursively, so that components at one level in the
system hierarchy can be decomposed into finer-grained
structures of collaborating components, and so on. This
allows modeling of systems at arbitrary levels of
abstraction.
A similar approach is used to define behavior that
occurs within such structures, with the ability to
recursively decompose high-level specifications of object
interactions into finer-grained ones and vice versa. The
source for this work were earlier standards defined in the
telcom domain, where they have been applied with great
effectiveness.

5. Functionally Oriented Modeling

The initial version of UML was primarily based on the
object paradigm. However, there are many domains,

[1] D. Garlan, et al., ACME: Architectural Description of

Component-Based Systems, in G. Leavens and M. Sitarman
(eds.), Foundations of Component-Based Systems, Cambridge
University Press, pp. 47-68. 2000.
[2] ITU, Specification and Description Language (SDL)
Z.100, Available at: http://www.itu.int/ITUT/studygroups/com10/languages/Z.100_1199.pdf. November
1999.
[3] OMG, UML 2.0 OCL 2nd Revised Submission, OMG
document ptc/03-01-07, Available at: http://www.omg.org/cgibin/doc?ad/2003-01-07. January 2003.
[4] OMG, The, Unified Modeling Language, v1.5, OMG
document formal/03-03-01, Available at:
http://www.omg.org/cgi-bin/doc?formal/03-03-01. March 2003.
[5] OMG, MDA Guide Version 1.0.1, OMG document
omg/03-06-01, Available at: http://www.omg.org/docs/omg/0306-01.pdf. June 2003.
[6] OMG, UML 2.0 Diagram Interchange Draft Adopted
Specification, OMG document ptc/03-07-03, Available at:
http://www.omg.org/cgi-bin/doc?ptc/2003-07-03. July 2003.
[7] OMG, UML 2.0 Superstructure Final Adopted
Specification, OMG document ptc/03-08-02, Available at:
http://www.omg.org/cgi-bin/doc?ptc/2003-08-02. August 2003.
[8] OMG, UML 2.0 Infrastructure Final Adopted
Specification, OMG document ptc/03-09-15, Available at:
http://www.omg.org/cgi-bin/doc?ptc/2003-09-15. September
2003.
[9] J. Rumbaugh, et al., The Unified Modeling Language
Reference Manual, Addison-Wesley-Longman, Reading, Mass.,
1998.
[10] B. Selic, et al., Real-Time Object-Oriented Modeling, John
Wiley & Sons, New York, 1994.

Proceedings of the 26th International Conference on Software Engineering (ICSE04)

0270-5257/04 $20.00 2004 IEEE