The Uni ed Modeling Language or UML, as a visual and general purpose modeling
language, has been around for more than a decade, gaining increasingly wide application
and becoming the de-facto industrial standard for modeling software systems. However,
the dynamic semantics of UML behaviours are only described in natural languages.
Speci cation in natural languages inevitably involves vagueness, lacks reasonability and
discourages mechanical language implementation. Such semi-formality of UML causes
wide concern for researchers, including us.
The formal semantics of UML demands more readability and extensibility due to its
fast evolution and a wider range of users. Therefore we adopt Action Semantics (AS),
mainly created by Peter Mosses, to formalize the dynamic semantics of UML, because
AS can satisfy these needs advantageously compared to other frameworks.
Instead of de ning UML directly, we design an action language, called ALx, and
use it as the intermediary between a typical executable UML and its action semantics.
ALx is highly heterogeneous, combining the features of Object Oriented Programming
Languages, Object Query Languages, Model Description Languages and more complex
behaviours like state machines. Adopting AS to formalize such a heterogeneous language
is in turn of signi cance in exploring the adequacy and applicability of AS.
In order to give assurance of the validity of the action semantics of ALx, a prototype
ALx-to-Java translator is implemented, underpinned by our formal semantic description
of the action language and using the Model Driven Approach (MDA). We argue that
MDA is a feasible way of implementing this source-to-source language translator because
the cornerstone of MDA, UML, is adequate to specify the static aspect of programming
languages, and MDA provides executable transformation languages to model mapping
rules between languages.
We also construct a translator using a commonly-used conventional approach, in
i
which a tool is employed to generate the lexical scanner and the parser, and then
other components including the type checker, symbol table constructor, intermediate
representation producer and code generator, are coded manually. Then we compare the
conventional approach with the MDA. The result shows that MDA has advantages over
the conventional method in the aspect of code quality but is inferior to the latter in
terms of system performance
