Classification

Czarnecki et al. propose a possible taxonomy for model transformation approaches [Czarnecki03]. The taxonomy is described with a feature model [Czarnecki98] for making design choices for model transformations explicit. The following sections represent a clas-sification to fit current (and future) model transformation approaches. A specific approach may fit in several classes. Although the same classes as presented in [Czarnecki03] are used in the following, an updated selection of transformation approaches is discussed with the focus more on the overall impact of a specific transformation approach within the con-text of this work than on its detailed features.

Model Driven Software Engineering for Web Applications

2.3.1.1 Hard-Coded Transformations

In contrast to generic transformation approaches, in hard-coded transformations the meta-models and the transformations rules are implemented in a specific programming language.

Thus they do not allow an easy adaptation to changes in the metamodels or transformation rules. An example for this class of transformation approaches is UWEXML, which is pre-sented in 3.4.1.2.

2.3.1.2 Model-To-Code Approaches

Model-to-code transformations can be seen as specialized model-to-(platform specific) model transformations, i.e. a model-to-code transformation is equivalent to a transforma-tion to the platform specific metamodel with subsequent serializatransforma-tion to code. Pure model-to-code approaches are therefore restricted in their application to simple PIM-to-PSM transformations.

Visitor-based approaches are based on the Visitor design pattern [Gamma95]. A visitor mechanism is provided to traverse the internal representation of a model and write code to a text stream. An example for this approach is Jamda [Jamda], an object-oriented Java framework providing a set of classes to represent UML models, an API for manipulating models, and a visitor mechanism to generate code. It does not support the MOF standard to define new metamodels, but new model element types can be introduced by subclassing predefined Java classes.

The majority of currently available MDA tools are template-based model-to-code ap-proaches, e.g. AndroMDA [AndroMDA], OptimalJ [OptimalJ], XDE [XDE] and ArcStyler [ArcStyler]. AndroMDA is based on the template engines Velocity and XDoclet. A tem-plate is a piece of target code that contains meta tags to access the content of the source model and for iterative code expansion, see [Cleaveland01] for an introduction to template based approaches. In comparison to visitor-based approaches templates are more similar to the generated code.

The openArchitectureWare (oAW) tool platform [OAW] describes itself as “a suite of tools and components assisting with model driven software development built upon a modular MDA/MDD generator framework implemented in Java supporting arbitrary im-port (design) formats, meta models, and output (code) formats”. In fact the oAW platform is a powerful tool suite for straightforward transforming models (or arbitrary input data) to code. The main differences, e.g. to the more general QVT approach, are: the concept of models and metamodels only holds on the input side of a transformation. The output of a transformation is plain and unstructured text, i.e. code. Although the output can represent a

33

model at low level, such as XMI, and from this a model instance could be instantiated, this approach is considered more a hack than a reasonable use of the oAW framework. Trans-formations are expressed as transformation templates in a template language called XPand.

A transformation template is defined for a specific metaclass and executed on all instances of it. Transformations can be composed and inherited. The output of a transformation tem-plate is a concatenation of literal code and properties of the model element (i.e. instance of the metaclass). One of the main practical benefits of using the oAW platform is the large number of UML tools that is supported for constructing the input model. By customizing the so called instantiators, new dialects or metamodel extensions can easily be adopted. A basic UML metamodel represented with Java classes can be used as is or be extended by custom metamodel classes either manually or by means of a metamodel generator. Also handling the UML extension mechanisms such as stereotypes and tagged values is easily accomplished. Additionally, aspects are supported as well in the metamodel as in the trans-formation templates. The framework integrates into the Ant deployment tool and into the Eclipse development platform.

2.3.1.3 Direct-Manipulation Approaches

Direct-manipulation approaches can access an internal model representation via an Appli-cation Programming Interface (API) for a particular programming language, such as Java.

Thus, direct-manipulation approaches use hard-coded transformation rules, but they rely on standardized interfaces or frameworks for manipulating models.

The Java Metadata Interface (JMI) Specification [JMI] is the result of a Java Community Process for the implementation of a dynamic, platform-neutral infrastructure that enables the creation, storage, access, discovery, and exchange of metadata within the Java envi-ronment. JMI is based on the Meta Object Facility (MOF) specification [OMG06a], which defines a generic programming mechanism (using IDL) that allows for the discovery, query, access, and manipulation of metamodel instances, either at design time or at run-time. The semantics of any modeled system can be completely discovered and manipulated with standard Java interfaces through the modeling components defined by JMI, i.e. plat-form-independent discovery and access of metadata is possible. These interfaces are gener-ated automatically from MOF models, for any kind of metamodel. Additionally, meta-model and metadata interchange via XML is enabled by JMI’s use of the XML Metadata Interchange (XMI) [OMG05c] specification. Applications using JMI can use the metadata to dynamically interpret the meaning of information, take action on that information and automate transactions across disparate systems and data sources. [Jamda] for example is based on JMI.

Model Driven Software Engineering for Web Applications

The Novosoft Metadata Framework (NSMDF) [NSMDF] is based on the JMI specifica-tion. Generated classes conform to the JMI specification and also additional services like event notification, undo/redo support are provided. The metadata repository is an in-memory implementation. The framework API itself is generated from the MOF specifica-tion, where the shipped (binary) distribution was generated for MOF version 1.3. Libraries for handling UML 1.3 und 1.4 models in the version 1.1 of the XMI interchange format are available in binary form for the direct usage to process UML models. Unfortunately, this version of NSMDF is not integrated in the actual version of the open source CASE tool ArgoUML [ArgoUML]. Instead, it uses the former version of the framework called NSUML with support for UML 1.3 and the version 1.0 of the XMI interchange format.

Due to huge discrepancies between the UML 1.3 and 1.4 metamodel an easy transforma-tion between the different interchange formats is not trivial. The tool ArgoUWE [Knapp03] for development of Web application for the methodology UWE is based on Ar-goUML, hence it is an example for a direct-manipulation approach using NSMDF, see also 3.4.1.1.

NetBeans [NetBeans] is another open source project sponsored by Sun Microsystems. It hosts the NetBeans integrated development environment (IDE) and the NetBeans platform, a software development framework. NetBeans is based on a modular architecture and one such module is the Metadata Repository (MDR). It can be used either within the develop-ment environdevelop-ment or separately. The MDR subproject is another JMI impledevelop-mentation.

Metamodels have to be defined using the version 1.4 of MOF, although a transformation from MOF 1.3 models is done transparently. The metadata repository is a file based im-plementation. The automatization of metadata tasks is encouraged by the definition of Ant tasks. Furthermore, with the UML2MOF tool it is possible to transform UML models us-ing the UML Profile for MOF [OMG06a] to MOF models, i.e. a regular UML CASE tool can be used to define MOF models.

2.3.1.4 Relational Approaches

Relational approaches are declarative approaches based on mathematical relations. Basi-cally, a relation is specified by defining constraints over the source and target elements of a transformation. Without special constructs relations cannot be executed and have no direc-tion. Relational approaches with executable semantics can be implemented with logic pro-gramming using unification-based matching, search, and backtracking, see [Gerber02].

QVT (see 2.3.2) and ATL (see 2.3.3) support the relational approach and additionally pro-vide imperative constructs, i.e. they are hybrid approaches.

35

2.3.1.5 Graph-Transformation-Based Approaches

Graph-transformation-based approaches are declarative approaches based on the theoreti-cal work on graph transformations. Typed, attributed, labeled graphs [Andries96] are par-ticularly suitable to represent UML-like models.

When applying a graph transformation rule a left-hand-side graph pattern is matched and replaced by a right-hand-side graph pattern. In addition to the left-hand-side graph pattern matching conditions can be defined, e.g. negative conditions. Additional logic is needed to compute target attribute values. In most approaches, rule scheduling is done externally in-cluding non-deterministic selection, explicit condition, and iteration (inin-cluding fixpoint iterations). Fixpoint iterations can be used for computing transitive closures. An introduc-tion to the concept of graph transformaintroduc-tions is given in [Heckel05].

The Attributed Graph Grammar System (AGG) is a rule based visual language supporting an algebraic approach to graph transformation [AGG]. It aims at specifying and rapid pro-totyping applications with complex, graph structured data. AGG may be (re)used (without GUI) as a general purpose graph transformation engine in high level Java applications us-ing graph transformation methods. The special characteristics of AGG are [AGG]: com-plex data structures are modeled as graphs which may be typed by a type graph. Graphs may be attributed by Java objects and types. Basic data types as well as object classes al-ready available in Java class libraries may be used and in addition, user-defined Java classes can be used. Graph rules may be attributed by Java expressions, which are evalu-ated during rule applications. Additionally, rules may have attribute conditions being boo-lean Java expressions. The formal semantics of rule application is given in terms of cate-gory theory, by a single categorical construction known as a pushout in an appropriate category of attributed graphs with partial morphisms. This approach is also named single-pushout approach (SPO). For more details about the formal background of AGG see [Ehrig06]. The AGG tool environment provides graphical editors for graphs and supports visual interpretation and validation. The Tiger project [Ehrig05] extends AGG by a con-crete visual syntax definition for flexible means for visual model representation, including the generation of visual editors as plug-ins for the Eclipse framework.

Another promising approach based on graph transformations is VIATRA which currently serves as the underlying model transformation technology of several ongoing European projects mainly in the field of dependable systems [VIATRA]. The main objective of VIATRA is the specification of model transformations in a mathematically precise way. In addition to graph transformations, a rule-based specification formalism for abstract state machines [Börger03] is provided, which allows the use of imperative constructs in addition to the declarative constructs provided by graph transformations. Graph transformation

Model Driven Software Engineering for Web Applications

rules are assembled to complex model transformations by abstract state machine rules, which provide a set of common control structures with precise semantics frequently used in imperative or functional languages.

Other graph-transformation approaches for model transformation include MOFLON [Ame-lunxen06], UMLX [Willink03], GreAT [Agrawal03], ATOM [Lara02], PROGRES [Schürr89] and BOTL [Marschall03].

2.3.1.6 Structure-Driven Approaches

The idea behind structure driven approaches is that a transformation first creates a hierar-chical structure of the target model. Then attributes and references are set in the target model. OptimalJ is an example for this approach [OptimalJ]. So called incremental copiers that have to be specialized by the user copy elements from the source to the target model.

Then the target model can be changed by the transformation implementation. The mapping of specific source types is implemented by defining a corresponding Java method with the source type matching the input parameter type of the method.

2.3.1.7 Hybrid Approaches

Hybrid approaches combine declarative and imperative constructs. QVT (see 2.3.2), ATL (see 2.3.3) and VIATRA (see 2.3.1.5) are hybrid approaches. Another approach is XDE [XDE], which is based on The-Gang-Of-Four design pattern [Gamma95]. Thus, the basic concepts are parameterized collaborations or UML collaboration diagrams to model design patterns. Patterns can be associated to so called Scriptlets, which are similar to JSPs and responsible for model-to-code transformations.

2.3.1.8 Other Model-To-Model Approaches

Some transformation approaches do not fit into any of the classes presented in the previous sections, for example XSLT [XSLT], a declarative and functional transformation language for transforming XML documents. As MOF compliant models can be represented in the XML Metadata Interchange (XMI) format (cf. 2.2.2), XSLT could in principle be used for model-to-model transformations. But this approach has severe problems with scalability, thus XSLT is not suited for more complex transformations

37

2.3.1.9 Discussion

In the previous sections different classes of transformation approaches have been pre-sented. This section discusses the advantages and disadvantages of each transformation class regarding the use of it within an MDA approach.

Hard-coded transformations and direct-manipulation approaches are too low-level because transformations have to be implemented directly by the user in some programming lan-guage. Model-to-code approaches could only be used for the last step in an MDA process when models have to be serialized to code. Structure-driven approaches are too specialized because they can only be used for certain kinds of correspondences between source and target elements. Relational approaches are a good compromise between flexibility and de-clarative expressiveness.

From the academic viewpoint approaches based on graph transformations may seem the best choice because of their high expressiveness and declarative nature. The theoretical foundation of graph transformations eases solving formal questions regarding properties of transformations. But also the complexity stemming from the non-determinism in the rule scheduling and application strategy hinders the practical applicability of this approach. For example the termination of the transformation process has to be studied carefully.

Hybrid approaches combine declarative expressiveness and imperative constructs for those parts of a transformation which would be too cumbersome or even impossible to express with declarative constructs.