Skip to main content

Über dieses Buch

Models have become essential for supporting the development, analysis and e- lution of large-scale and complex IT systems. Models allow di?erent views, p- spectives and elements of a system to be captured rigorously and precisely, thus allowing automated tools to manipulate and manage the models. In a full-?edged model-driven engineering (MDE) process, the transformations developed and - pressed between models are also key. Model transformations allow the de?nition and implementation of the operations on models, and also provide a chain that enables the automated development of a system from its corresponding m- els. Model transformations are already an integral part of any model-driven approach, and there are a number of available model transformation languages, tools, and supporting environments; some of these approaches are now approa- ing maturity. Nevertheless, much work remains: the research community and industry need to better understand the foundations and implications of model transformations, such as the key concepts and operators supporting transfor- tion languages, their semantics, and their structuring mechanisms and properties (e. g. , modularity, composability and parametrization). The e?ect of using model transformations on organizations and development processes – particularly when applied to ultra-large scale systems, or in distributed enterprises – is still not clear. These issues, and others related to the speci?cation, design, implemen- tion, analysis and experimentation with model transformation, are the focus of these proceedings. The Second International Conference on Model Transformation (ICMT 2009) was held in late June 2009 in Zurich, Switzerland.



Invited Paper

Foundations for Bidirectional Programming

Most programs get used in just one direction, from input to output. But sometimes, having computed an output, we need to be able to update this output and then “calculate backwards” to find a correspondingly updated input. The problem of writing such bidirectional transformations–often called lenses–arises in applications across a multitude of domains and has been attacked from many perspectives [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16, etc.]. See [17] for a detailed survey.
Benjamin C. Pierce

Full Papers

Model Superimposition in Software Product Lines

In software product line engineering, feature composition generates software tailored to specific requirements from a common set of artifacts. Superimposition is a technique to merge code pieces belonging to different features. The advent of model-driven development raises the question of how to support the variability of software product lines in modeling techniques. We propose to use superimposition as a model composition technique in order to support variability. We analyze the feasibility of superimposition for model composition, offer corresponding tool support, and discuss our experiences with three case studies (including an industrial case study).
Sven Apel, Florian Janda, Salvador Trujillo, Christian Kästner

Efficient Model Transformations by Combining Pattern Matching Strategies

Recent advances in graph pattern matching techniques have demonstrated at various tool contests that graph transformation tools can scale up to handle very large models in model transformation problems. In case of local-search based techniques, pattern matching is driven by a search plan, which provides an optimal ordering for traversing and matching nodes and edges of a graph pattern. In case of incremental pattern matching, matches of a pattern are explicitly stored and incrementally maintained upon model manipulation, which frequently provides significant speed-up but with increased memory consumption. In the current paper, we present a hybrid pattern matching approach, which is able to combine local-search and incremental techniques on a per-pattern basis. Based upon experimental evaluation, we identify scenarios when such combination is highly beneficial, and provide guidelines for transformation designers for optimal selection of pattern matching strategy.
Gábor Bergmann, Ákos Horváth, István Ráth, Dániel Varró

Managing Dependent Changes in Coupled Evolution

In Model-Driven Engineering models and metamodels are not preserved from the evolutionary pressure which inevitably affects almost any artefacts. Moreover, the coupling between models and metamodels implies that when a metamodel undergoes a modification, the conforming models require to be accordingly co-adapted. One of the main obstacles to the complete automation of the adaptation process is represented by the dependencies which occur among the different kinds of modifications. The paper illustrates a dependency analysis, classifies such dependencies, and proposes a metamodeling language driven resolution which is independent from the evolving metamodel and its underlying semantics. The resolution enables a decomposition and consequent scheduling of the adaptation steps allowing the full automation of the process.
Antonio Cicchetti, Davide Di Ruscio, Alfonso Pierantonio

Model Transformation By-Example: An Algorithm for Generating Many-to-Many Transformation Rules in Several Model Transformation Languages

Practitioners of model-driven engineering usually find that producing model transformations still requires much effort. The Model Transformation By-Example (MTBE) approach softens this problem by means of the automated creation of model transformations from pairs of source and target model examples. However, the current techniques and tools for MTBE are limited in the sense that they can only produce transformations rules that are limited to just one element in some of the patterns. In addition, some transformation languages cannot directly represent many-to-many transformation rules. To overcome both limitations, this paper presents a MTBE algorithm, that can generate many-to-many rules in several transformation languages even if the transformation language cannot directly represent these kinds of rules. In particular, the implementation of this algorithm with the ATL language is available for practitioners, and it has already generated several MTs that are applied in software development. Finally, the paper compares this algorithm with existing techniques for MTBE.
Iván García-Magariño, Jorge J. Gómez-Sanz, Rubén Fuentes-Fernández

A Collection Operator for Graph Transformation

Graph transformation has a well-established theory and associated tools that can be used to perform model transformations. However, the lack of a construct to match and transform collections of similar subgraphs makes graph transformation complex or even impractical to use in a number of transformation cases. This is addressed in this paper, by defining a collection operator which is powerful, yet fairly simple to model and understand. We present model transformation examples from different modeling domains to illustrate the benefit of the approach.
Roy Grønmo, Stein Krogdahl, Birger Møller-Pedersen

Pattern-Based Model-to-Model Transformation: Handling Attribute Conditions

Pattern-based model-to-model transformation is a new approach for specifying transformations in a declarative, relational and formal style. The language relies on patterns describing allowed or forbidden relations between two models, which are compiled into operational mechanisms to perform forward and backward transformations.
In this paper, we extend the approach for handling attribute conditions expressed in some suitable logic, adapt the operational mechanisms based on graph transformation to relax attribute handling by constraint solving, and discuss heuristics for the compilation of patterns into rules.
Esther Guerra, Juan de Lara, Fernando Orejas

Towards Model Round-Trip Engineering: An Abductive Approach

Providing support for reversible transformations as a basis for round-trip engineering is a significant challenge in model transformation research. While there are a number of current approaches, they require the underlying transformation to exhibit an injective behaviour when reversing changes. This however, does not serve all practical transformations well. In this paper, we present a novel approach to round-trip engineering that does not place restrictions on the nature of the underlying transformation. Based on abductive logic programming, it allows us to compute a set of legitimate source changes that equate to a given change to the target model. Encouraging results are derived from an initial prototype that supports most concepts of the Tefkat transformation language
Thomas Hettel, Michael Lawley, Kerry Raymond

Rewriting Queries by Means of Model Transformations from SPARQL to OQL and Vice-Versa

Implementing language translation is one of the main topics within the model to model transformation area. Nevertheless, a majority of solutions promoted by model driven engineering tools focus on transformations related to modeling languages. In this paper, we address query rewriting by means of model transformations. This study has been carried out within the context of implementing an object ontology mapping tool, which could enable bridging object oriented applications and RDF data sources. This approach allows querying RDF data sources via an object oriented query which is automatically rewritten in SPARQL (RDF query language) in order to access RDF data. Hence, the developer can freely focus upon the sole application object model. In this paper, we also present with solutions for translating SPARQL queries into object oriented queries, thus allowing the implementation of SPARQL endpoints for object oriented applications.
Guillaume Hillairet, Frédéric Bertrand, Jean Yves Lafaye

Solving Constraints in Model Transformations

Constraint programming holds many promises for model driven software development (MDSD). Up to now, constraints have only started to appear in MDSD modeling languages, but have not been properly reflected in model transformation. This paper introduces constraint programming in model transformation, shows how constraint programming integrates with QVT Relations - as a pathway to wide spread use of our approach - and describes the corresponding model transformation engine. In particular, the paper will illustrate the use of constraint programming for the specification of attribute values in target models, and provide a qualitative evaluation of the benefit drawn from constraints integrated with QVT Relations.
Andreas Petter, Alexander Behring, Max Mühlhäuser

Automatic Model Generation Strategies for Model Transformation Testing

Testing model transformations requires input models which are graphs of inter-connected objects that must conform to a meta-model and meta-constraints from heterogeneous sources such as well-formedness rules, transformation pre-conditions, and test strategies. Manually specifying such models is tedious since models must simultaneously conform to several meta-constraints. We propose automatic model generation via constraint satisfaction using our tool Cartier for model transformation testing. Due to the virtually infinite number of models in the input domain we compare strategies based on input domain partitioning to guide model generation. We qualify the effectiveness of these strategies by performing mutation analysis on the transformation using generated sets of models. The test sets obtained using partitioning strategies gives mutation scores of up to 87% vs. 72% in the case of unguided/random generation. These scores are based on analysis of 360 automatically generated test models for the representative transformation of UML class diagram models to RDBMS models.
Sagar Sen, Benoit Baudry, Jean-Marie Mottu

A Simple Game-Theoretic Approach to Checkonly QVT Relations

The QVT Relations (QVT-R) transformation language allows the definition of bidirectional model transformations, which are required in cases where a two (or more) models must be kept consistent in the face of changes to either. A QVT-R transformation can be used either in checkonly mode, to determine whether a target model is consistent with a given source model, or in enforce mode, to change the target model. Although the most obvious semantic issues in the QVT standard concern the restoration of consistency, in fact even checkonly mode is not completely straightforward; this mode is the focus of this paper. We need to consider the overall structure of the transformation as given by when and where clauses, and the role of trace classes. In the standard, the semantics of QVT-R are given both directly, and by means of a translation to QVT Core, a language which is intended to be simpler. In this paper, we argue that there are irreconcilable differences between the intended semantics of QVT-R and those of QVT Core, so that the translation cannot be helpful. Treating QVT-R directly, we propose a simple game-theoretic semantics. We demonstrate that consistent models may not possess a single trace model whose objects can be read as traceability links in either direction. We briefly discuss the effect of variations in the rules of the game, to elucidate some design choices available to the designers of the QVT-R language.
Perdita Stevens

Supporting Model–Driven Development of Object–Relational Database Schemas: A Case Study

This paper completes our proposal for automatic development of Object-Relational (OR) DataBase (DB) schemas. By means of a case study, this work focuses on presenting the tooling developed to support the whole process. As usual, the proposal starts from a conceptual data model (Platform Independent Model) depicted in a UML class diagram. Then, the conceptual data model is mapped into an OR DB model (Platform Specific Model) that represents the OR DB schema. To that end, we have implemented a set of formalized mapping rules using the ATL language. Finally, the SQL code that implements the modeled schema in Oracle 10g is automatically generated from the OR model by means of a MOFScript model to text transformation. Moreover, since the OR model could be refined along the design process, we have developed a graphical editor for OR DB models.
Juan Manuel Vara, Belén Vela, Verónica Andrea Bollati, Esperanza Marcos

Typing in Model Management

Model management is essential for coping with the complexity introduced by the increasing number and varied nature of artifacts involved in MDE-based projects. Global Model Management (GMM) addresses this issue enabling the representation of artifacts, particularly transformation composition and execution, by a model called a megamodel. Typing information about artifacts can be used for preventing type errors during execution. In this work, we present a type system for GMM that improves its current typing approach and enables formal reasoning about the type of artifacts within a megamodel. This type system is able to capture non-trivial situations such as the use of higher order transformations.
Andrés Vignaga, Frédéric Jouault, María Cecilia Bastarrica, Hugo Brunelière

Supporting Parallel Updates with Bidirectional Model Transformations

Model-driven software development often involves several related models. When models are updated, the updates need to be propagated across all models to make them consistent. A bidirectional model transformation keeps two models consistent by updating one model in accordance with the other. However, it does not work when the two models are modified at the same time.
In this paper we propose a new algorithm that wraps any bidirectional transformation into a synchronizer with the help of a model difference approach. The synchronizer enables parallel updates by taking the two original models, the two updated models as input and producing two new models where the updates are synchronized. We also examine the requirements for synchronizing parallel updates, and demonstrate that our algorithm satisfies the requirements if the bidirectional transformation satisfies the correctness property and the hippocraticness property. Implementation of our algorithm showed that it works well in a runtime management framework in practical cases.
Yingfei Xiong, Hui Song, Zhenjiang Hu, Masato Takeichi

Short Papers

Experiments with a High-Level Navigation Language

Writing navigation expressions is an important part of the task of developing a model transformation definition. When navigation is complex and the size of source models is significant, performance issues cannot be neglected. Model transformation languages often implement some variants of OCL as their navigation language. Writing efficient code in OCL is usually a difficult task because of the nature of the language and the lack of optimizing OCL compilers. Moreover, optimizations generally reduce readability.
An approach to tackle this issue is to raise the level of abstraction of the navigation language. We propose to complement the regular navigation language of model transformation languages with a high-level navigation language, in order to improve both performance and readability. This paper reports on the initial results of our experiments creating the HLN language: a declarative high-level navigation language. We will motivate the problem, and will we describe the language as well as the main design guidelines.
Jesús Sánchez Cuadrado, Frédéric Jouault, Jesús García Molina, Jean Bézivin

Using Metrics for Assessing the Quality of ASF+SDF Model Transformations

Model transformations are an essential part of Model Driven Engineering and are in many ways similar to traditional software artifacts. Therefore it is necessary to define and evaluate the quality of model transformations. We propose a set of six quality attributes to evaluate the quality of model transformations. We define 27 metrics for ASF+SDF model transformations to predict the quality attributes we propose. Metrics data has been collected from six heterogeneous model transformations automatically. The quality of the same transformations has been evaluated manually by several ASF+SDF experts. We assess whether the automatically collected metrics are appropriate predictors for the quality attributes by correlating the metrics data with the expert data. Based on the measurement results, we identify a set of predicting metrics for each of the quality attributes for model transformations.
Marcel F. van Amstel, Christian F. J. Lange, Mark G. J. van den Brand

Achieving Rule Interoperability Using Chains of Model Transformations

Model Driven Engineering (MDE) is rapidly maturing and is being deployed in several situations. We report here on an experiment conducted in the context of ILOG, a leader in the development of Business Rule Management Systems (BRMS). BRMSs aim at enabling business users automating their business policies. There is a growing number of BRMS supporting different languages, but also a lack of tools for bridging them. In this paper, we present an approach based on MDE techniques for bridging rule languages; the solution has been fully implemented and tested on different BRMS. The success of the experiment has led to the development and chaining of a significant number of model transformations – no less than twenty. At the same time, this deployment has shown new problems arising from the management of a high number of artifacts. We discuss the positive assessment of MDE in this field, but also the need to address the complexity generated.
Marcos Didonet Del Fabro, Patrick Albert, Jean Bézivin, Frédéric Jouault

Panel on Bidirectional Transformations

Bidirectional Transformations: A Cross-Discipline Perspective

GRACE Meeting Notes, State of the Art, and Outlook
The GRACE International Meeting on Bidirectional Transformations was held in December 2008 near Tokyo, Japan. The meeting brought together researchers and practitioners from a variety of sub-disciplines of computer science to share research efforts and help create a new community. In this report, we survey the state of the art and summarize the technical presentations delivered at the meeting. We also describe some insights gathered from our discussions and introduce a new effort to establish a benchmark for bidirectional transformations.
Krzysztof Czarnecki, J. Nathan Foster, Zhenjiang Hu, Ralf Lämmel, Andy Schürr, James F. Terwilliger


Weitere Informationen

Premium Partner