Executable UML (xUML)
What is Executable UML (xUML)?
Executable UML (xUML) is a profile of UML 2.0 that leverage the action semantics in order to
facilitate the execution of a UML model.
Action semantics allow UML models to specify behaviors associated with an operation or a state machine
transition. The introduction of action semantics in UML 2.0 is not widely known in the programming community
but it is very significant because it makes UML a turing-complete language! This we finally have a bridge
over the gap between development and modeling activities. Only a few organizations have been crossing this
chasm but those who have, have seen great payoffs. One of the more prominent success stories of xUML was by
Lockheed Martin Aeronautics at to develop the F-16 Modular Mission Computer Application Software.
See http://www.omg.org/mda/mda_files/LockheedMartin.pdf
for more information.
Executable UML, which was also at one point called Executable and Translable UML (xtUML) was developed in
response to the OMG consortium's effort to improve support for model-driven architecture (MDA). The xUML
technology has evolved from proven and well-known formalisms such as the Schlaer-Mellor method of
object-oriented analysis and design.
Problems with xUML
There are two well known problems with xUML: it depends on visual diagrams and there is no widely agreed upon
surface syntax for expressing action semantics (i.e. no action language). Diagrams are excellent
for visualization, but are hard to work with for developers. Some of the problems with diagrams are:
- effective tools for working with diagrams are not easily available, expensive to buy or build
- many important tools in a programmer's toolkit rely on textual representations:
SED, AWK, GREP, WinDiff, Perl
- it is easy to create diagrams of a model that are unusable (elements hiding other elements),
whereas valid textual representations of the same model are always managable.
- diagrammatic tools require a lot of system resources compared to text editors like VI, or Emacs,
which can be run on embedded systems
Action Languages
Action languages are textual syntaxes for expressing the action semantics associated with operations and
state transition diagrams in UML.
The two most widely used action languages are Object Action Language (OAL) used by the Bridgepoint EdgeUML
compiler suite from Mentor Graphics, and the Action Specifciation Language (ASL) used in various tools from
Kennedy Carter.
Heron (http://www.heron-language.com/spec.html)
has an action language at its core, which resembles a combination of Java and Scala,
but is unique in that it also provides a syntactic representation of the elements in xUML class diagrams and
state machine diagrams.
Executable UML (xUML) and Model-Driven Architecture (MDA)
Executable UML (xUML) was developed largely in response the OMG's efforts to come up with a solution for
the Model-Driven Architecutre (MDA) approach to developing software. All MDA approaches other than xUML
require model elaboration. In effect the model is used to generate a portion of the software, and software
"elaborate" on the generated code to produce the final product.
Some of the problems with the elabroationist approach to MDA are:
- is a platform specific approach: each new targeted platform requires new elaboration
- it is a langauge-specific approach: the developers are locked in to the language used for elaboration
- there are no standards in place: every toolset takes its own approach.
Executable UML is considered to be a translationist approach to MDA. Platform specific models or implementations
are generated automated by model compilers.
For More Information
The following links provide more information on xUML:
The following are popular books on xUML:
|
|
