RSS Feed
Download our iPhone app
Browse DevX
Sign up for e-mail newsletters from DevX


Executable UML: Diagrams for the Future  : Page 2

Executable UML marries an abstract program model with a platform-specific model compiler that outputs an executable application. If successful, this combination holds the potential for a major shift in development tasks.

Introducing Model Driven Architecture
The word architecture is heavily overloaded in the context of discussing systems and software. An architecture is a description of the fundamental components of a solution and their structural relationships to each other. In the MDA, there's a distinction between application architecture and systems architecture. Application architecture is the components and structural relationships that exist to specify the functional purpose of the application. Systems architecture is the lower level components and structural relationships that allow the application architecture to execute. It is the separation of the application architecture from the systems architecture that is the fundamental thrust of the MDA.

MDA, as defined by the OMG, essentially calls for the mapping of a Platform Independent Model (PIM) onto a Platform Specific Model (PSM).
MDA, as defined by the OMG, essentially calls for the mapping of a Platform Independent Model (PIM) onto a Platform Specific Model (PSM). A PIM is a complete application specification that is independent of the technology platform upon which it will eventually execute. PIMs map onto PSMs, which provide the systems architecture infrastructure, or "plumbing," that implements the PIM on a specific technology platform, turning it into an executable application. One way to view this is to think of the PIM as source code for a solution, the mapping function as a compiler, and the PSM as an execution environment. The term Virtual Execution Environment (VEE) conveys a sense of the ultimate intent of the PSM.

Don't underestimate the benefits of this approach: intellectual capital invested in the PIM is forever protected from changes or advances in the underlying technologies. The PIM lets you model a solution both visually and at a higher level of abstraction. Re-writing applications to take advantage of newer technology (and there will always be a next, greatest technology), will become completely unnecessary. Instead, you simply regenerate the application using a mapping to the newer VEE.

The OMG provides—or will provide—standard PIM-to-PSM mappings for many of the popular technology platforms such as CORBA, J2EE, and .NET. Along with these mappings other OMG standards such as the Meta-Object Facility (MOF), XML Metadata Interchange (XMI), and the Common Warehouse Metamodel (CWM) work in concert to make the MDA a complete and robust approach to software development. The MOF provides a standard repository for UML models and defines a structure that allows a common meta-view of the stored UML models. XMI allows companies to exchange UML models as streams or files with a standard format based on XML. The CWM standardizes how to represent database models, schema transformation models, OLAP, and data mining models.

Adopting Action Semantics for UML
The adoption of the Precise Action Semantics for the UML by the OMG supports the viability of Executable UML. The standard was the work of a large industry consortium comprised of Rational Software, Kabira Technologies, Project Technologies, Kennedy-Carter, and others, in response to a Request for Proposals (RFP) from the OMG. Prior to that adoption the only way to attain 100% code generation from a UML-modeled solution was to use a third generation language or a proprietary language to specify the algorithmic behavior of the solution. In other words, prior to this standard, UML Class Diagrams and State Models could generate data structures and control flow, respectively, but there was no approved standard way to describe the low-level behavior of a given state. Because of this, many CASE tools could generate the shell of an application solution, but programmers were needed to fill in the actual behavior of the states (methods) with either a language like Java or C++ or a proprietary language of the CASE tool vendor.

The Precise Action Semantics for the UML standard provides an unambiguous semantic set of the operations required to specify the behavioral aspects of a UML model to a level of detail such that a self-contained and completely executable application can be generated from that model. The semantic set includes operations that support the synchronous manipulation of objects (create, read, write, delete), the generation and handling of asynchronous events (signals), and the logical constructs that support the specification of algorithms. The modeler specifies these operations using a text-based action language. All that is needed to completely specify the behavioral aspects of the UML model is an action language that follows the semantic standard.

The breakthrough notions of using an action language to specify behavior in a UML model are that:

  • The action language allows modelers to define behavioral specification at a higher level of abstraction.
  • The language is independent of any specific underlying technology in the execution environment.
Note that an action language allows only direct manipulation of UML elements. To accomplish that goal, modelers give up low-level control like pointer manipulation but are also freed from having to clutter up the model with issues like persistence, data storage, or distribution. Instead, application configuration deals with such issues at code generation time. Because an action language—and indeed the entire PIM UML model—is by definition independent of the underlying execution technology, modelers can target the application solution to multiple and diverse execution platforms, even future platforms that did not exist at the time the PIM was developed.

Because action languages exist at such a high level of abstraction they do not entail the steep learning curves of third generation languages.
Unfortunately, the Precise Action Semantics for the UML is a semantic standard only, not a syntactic standard. This was, presumably, based on political expediency, because many members of the submitting consortium supply either CASE or development tools which already contained fully realized action languages with proprietary syntaxes. One point of view maintains that syntax does not matter; however, it's easy to see that competing syntaxes may constrain the ability of Executable UML to gain mind-share in the development community and may, by extension, retard growth rates in the adoption of MDA technology. On the other hand, because action languages exist at such a high level of abstraction they do not entail the steep learning curves of third generation languages. Therefore, after learning one action language syntax, modelers can easily learn another, because they would be dealing with the same semantic set.

Close Icon
Thanks for your registration, follow us on our social networks to keep up-to-date