Skip to main content

2008 | Buch

Theory and Practice of Model Transformations

First International Conference, ICMT 2008, Zürich, Switzerland, July 1-2, 2008 Proceedings

herausgegeben von: Antonio Vallecillo, Jeff Gray, Alfonso Pierantonio

Verlag: Springer Berlin Heidelberg

Buchreihe : Lecture Notes in Computer Science

insite
SUCHEN

Über dieses Buch

Models have become essential for dealing with the numerous aspects involved in developing and maintaining complex IT systems. Models allow capturing of the relevant aspects of a system from a given perspective, and at a precise level of abstraction. In addition to models, the transformations between them are other key elements in model-driven engineering. Model transformations allow the de?nition and implementation of the operations on models, and also provide achainthatenablestheautomateddevelopmentofasystemfromitscorrespo- ing models. Furthermore, model transformations may be realized using models, and are, therefore, an integral part of any model-driven approach. There are already several proposals for model transformation speci?cation, implementation and execution, which are beginning to be used by modeling practitioners. However, model transformations need specialized support in s- eral aspects in order to realize their full potential. The problem goes beyond having speci?c languages to represent model transformations; we also need to understandtheirfoundations,suchasthekeyconceptsandoperatorssupporting those languages, their semantics, and their structuring mechanisms and pr- erties (e. g. , modularity, composability and parametrization). In addition, model transformations can be stored in repositories as reusable assets, where they can be managed, discovered and reused. There is also a need to chain and combine model transformations in order to produce new and more powerful transfor- tions, and to be able to implement new operations on models. Finally, model transformations need methodology support, i. e. , they need to be integrated into software development methodologies supported by appropriate tools and en- ronments. These issues and concerns de?ne the focus of these proceedings.

Inhaltsverzeichnis

Frontmatter

Process and Engineering of Model Transformations

Transformations Have to be Developed ReST Assured
Abstract
Model transformations do not simply appear. They have to be not-so-simply developed. In early phases of development, there may exist only an intuition or an educated guess on some of the characteristics of the transformation. Instead of assuming a pre-existing complete transformation specification, we embrace change and develop transformations incrementally, gradually refining them into more complete ones as the body of knowledge of the domain grows. We present an iterative process encompassing requirements capture, design and implementation of model transformations. We describe partial transformations as so called transformational patterns and iteratively refine them. We apply the approach to developing a transformation that is used in building APIs that comply with the ReST architectural style.
Mika Siikarla, Markku Laitkorpi, Petri Selonen, Tarja Systä
Lifting Transformational Models of Product Lines: A Case Study
Abstract
Model driven development (MDD) of software product lines (SPLs) merges two increasing important paradigms that synthesize programs by transformation. MDD creates programs by transforming models, and SPLs elaborate programs by applying transformations called features. In this paper, we present the design and implementation of a transformational model of a product line of scalar vector graphics and JavaScript applications. We explain how we simplified our implementation by lifting selected features and their compositions from our original product line (whose implementations were complex) to features and their compositions of another product line (whose specifications were simple). We used operators to map higher-level features and their compositions to their lower-level counterparts. Doing so exposed commuting relationships among feature compositions in both product lines that helped validate our model and implementation.
Greg Freeman, Don Batory, Greg Lavender
Model Synchronisation: Definitions for Round-Trip Engineering
Abstract
In a model-centric software development environment, a multitude of different models are used to describe a software system on different abstraction layers and from different perspectives. Following the MDA vision, model transformation is used to support the gradual refinement from abstract models into more concrete models. However, target models do not stay untouched but may be changed due to maintenance work or evolution of the software. Therefore, in order to preserve a coherent description of the whole system, it is necessary to propagate certain changes to a target model back to the source model. However, as transformations in general are partial and not injective, they cannot be easily reversed to propagate changes. This paper presents a formal definition of round-trip engineering and the semantics of target changes in the context of partial and non-injective transformations.
Thomas Hettel, Michael Lawley, Kerry Raymond
The Epsilon Transformation Language
Abstract
Support for automated model transformation is essential for realizing a Model Driven Development (MDD) process. However, model transformation is only one of the many tools in a model engineering toolkit. To apply MDD in the large, automated support for a number of additional tasks such as model comparison, merging, validation and model-to-text transformation, is essential. While a number of successful model transformation languages have been currently proposed, the majority of them have been developed in isolation and as a result, they face consistency and integration difficulties with languages that support other model management tasks. We present the Epsilon Transformation Language (ETL), a hybrid model transformation language that has been developed atop the infrastructure provided by the Epsilon model management platform. By building atop Epsilon, ETL is seamlessly integrated with a number of other task-specific languages to help to realize composite model management workflows.
Dimitrios S. Kolovos, Richard F. Paige, Fiona A. C. Polack

Model Transformations Supporting Concurrency and Time

Transforming Process Algebra Models into UML State Machines: Bridging a Semantic Gap?
Abstract
There exist many formalisms for modeling the behavior of (software) systems. These formalisms serve different purposes. Process algebras are used for algebraic and axiomatic reasoning about the behavior of distributed systems. UML state machines are suitable for automatic software generation. We have developed a transformation from the process algebra ACP into UML state machines to enable automatic software generation from process algebra models. This transformation needs to preserve both behavioral and structural properties. The combination of these preservation requirements gives rise to a semantic gap. It implies that we cannot transform ACP models into UML state machines on a syntactic level only.
We address this semantic gap and propose a way of bridging it. To validate our proposal, we have implemented a tool for automatic transformation of ACP process algebra models into UML state machines.
M. F. van Amstel, M. G. J. van den Brand, Z. Protić, T. Verhoeff
On Specifying and Visualising Long-Running Empirical Studies
Abstract
We describe a graphical approach to formally specifying temporally ordered activity routines designed for calendar scheduling. We introduce a workflow model OWorkflow, for constructing specifications of long running empirical studies such as clinical trials in which observations for gathering data are performed at strict specific times. These observations, either manually performed or automated, are often interleaved with scientific procedures, and their descriptions are recorded in a calendar for scheduling and monitoring to ensure each observation is carried out correctly at a specific time. We also describe a bidirectional transformation between OWorkflow and a subset of Business Process Modelling Notation (BPMN), by which graphical specification, simulation, automation and formalisation are made possible.
Peter Y. H. Wong, Jeremy Gibbons
Programmed Graph Rewriting with Time for Simulation-Based Design
Abstract
The Discrete EVent system Specification (DEVS) formalism allows for highly modular, hierarchical modelling of timed, reactive systems. DEVS can be used to describe complex control structures for programmed graph transformation. A side-effect of this approach is the introduction of an explicit notion of time. In this paper we show how the explicit notion of time allows for the simulation-based design of reactive systems such as modern computer games. We use the well-known game of PacMan as an example and model its dynamics with programmed graph transformation based on DEVS. This also allows the modelling of player behaviour, incorporating data about human players’ behaviour and reaction times. Thus, a model of both player and game is obtained which can be used to evaluate, through simulation, the playability of a game design. We propose a playability performance measure and vary parameters of the PacMan game. For each variant of the game thus obtained, simulation yields a value for the quality of the game. This allows us to choose an “optimal” (from a playability point of view) game configuration. The user model is subsequently replaced by a visual interface to a real player and the game model is executed using a real-time DEVS simulator.
Eugene Syriani, Hans Vangheluwe

Matching and Mapping within Model Transformation Rules

Live Model Transformations Driven by Incremental Pattern Matching
Abstract
In the current paper, we introduce a live model transformation framework, which continuously maintains a transformation context such that model changes to source inputs can be readily identified, and their effects can be incrementally propagated. Our framework builds upon an incremental pattern matcher engine, which keeps track of matches of complex contextual constraints captured in the form of graph patterns. As a result, complex model changes can be treated as elementary change events. Reactions to the changes of match sets are specified by graph transformation rules with a novel transactional execution semantics incorporating both pseudo-parallel and serializable behaviour.
István Ráth, Gábor Bergmann, András Ökrös, Dániel Varró
Semantics-Based Weaving of UML Sequence Diagrams
Abstract
In this paper we briefly introduce an aspect language that can define cross-cutting effects on a set of UML 2.0 sequence diagrams. Our main contribution is to weave aspects and sequence diagrams at the model level. By basing the weaving upon a formal trace model for sequence diagrams, we ensure that the weaving is semantics-based. To avoid the intractability of working on complete trace sets, we define a lifeline-based weaving upon trace-based equivalence classes. A major challenge is to handle unbounded loops which produce infinite trace sets. We establish a systematic way to rewrite the original loop definition so that the weaving can be performed on a finite structure. A weaving tool has been implemented to validate the approach.
Roy Grønmo, Fredrik Sørensen, Birger Møller-Pedersen, Stein Krogdahl
Translation of QVT Relations into QVT Operational Mappings
Abstract
Model transformations play a key role in Model-Driven Engineering solutions. To efficiently develop, specify, and manage model transformations, it is often necessary to use a combination of languages that stand for different transformation approaches. To provide a basis for such hybrid model transformation specification solutions, we developed and implemented a translation of the declarative QVT Relations into the imperative QVT Operational Mappings language.
Raphael Romeikat, Stephan Roser, Pascal Müllender, Bernhard Bauer

Language Support for Model Transformation Reuse and Modularity

Composition Techniques for Rule-Based Model Transformation Languages
Abstract
Model transformation languages have matured to a point where people have started experimenting with model transformation definitions themselves in addition to the language they are written in. In addition to the transformation language properties, the properties of model transformation definitions themselves become important, such as scalability, maintainability and reusability. Composition of model transformations allows for the creation of smaller, maintainable and reusable model transformation definitions that can scale up to a larger model transformation. There are two kinds of composition for model transformations. External composition deals with chaining separate model transformations together by passing models from one transformation to another. Internal composition composes two model transformation definitions into one new model transformation, which typically requires knowledge of the transformation language. This paper focuses on internal composition for two rule-based model transformation languages. One is the ATLAS Transformation Language, which serves as our implementation vehicle. The other is the QVT Relations language, which is a standard transformation language for MOF. We propose a composition technique called module superimposition. We discuss how module superimposition interacts with other composition techniques in ATL, such as helpers, called rules and rule inheritance. Together, these techniques allow for powerful composition of entire transformation modules as well as individual transformation rules. By applying superimposition to QVT Relations, we demonstrate that our composition technique is relevant outside the ATL language as well.
Dennis Wagelaar
Approaches for Model Transformation Reuse: Factorization and Composition
Abstract
Reusability is one of the principal software quality factors. In the context of model driven development (MDD), reuse of model transformations is also considered a key activity to achieve productivity and quality. It is necessary to devote important research efforts to find out appropriate reusability mechanisms for transformation tools and languages. In this paper we present two approaches for reusing model transformation definitions. Firstly, we tackle the creation of related model transformations, showing how the factorization of common parts can be achieved. Secondly, we describe a proposal on the composition of existing, separated transformation definitions so that they can be used to solve a concrete transformation problem. We illustrate both proposals with examples taken from the development of a software product line for adventure games, which has been implemented using the modularization mechanisms of the RubyTL transformation language.
Jesús Sánchez Cuadrado, Jesús García Molina
Code Generation by Model Transformation
A Case Study in Transformation Modularity
Abstract
The realization of model-driven software development requires effective techniques for implementing code generators. In this paper, we present a case study of code generation by model transformation with Stratego, a high-level transformation language based on the paradigm of rewrite rules with programmable strategies that integrates model-to-model, model-to-code, and code-to-code transformations. The use of concrete object syntax guarantees syntactic correctness of code patterns, and enables the subsequent transformation of generated code. The composability of strategies supports two dimensions of transformation modularity. Vertical modularity is achieved by designing a generator as a pipeline of model-to-model transformations that gradually transforms a high-level input model to an implementation. Horizontal modularity is achieved by supporting the definition of plugins which implement all aspects of a language feature. We discuss the application of these techniques in the implementation of WebDSL, a domain-specific language for dynamic web applications with a rich data model.
Zef Hemel, Lennart C. L. Kats, Eelco Visser
Application of Reflection in Model Transformation Languages
Abstract
Computational reflection is a well known technique applied in many existing programming languages ranging from functional to object-oriented languages. In this paper we study the possibilities and benefits of introducing and using reflection in rule-based model transformation languages. The paper identifies some language abstractions to achieve structural and behavioral reflection. Every reflective feature is motivated by examples of problems derived from the experience with currently used transformation languages. Example solutions are given by using an experimental language with reflective capabilities.
The paper also outlines possible implementation strategies for adding reflection to a language and discusses their advantages and disadvantages.
Ivan Kurtev

Correctness and Analysis of Model Transformations

Proofs-as-Model-Transformations
Abstract
This paper provides an overview of how to develop model transformations that are “provably correct” with respect to a given functional specification. The approach is based in a mathematical formalism called Constructive Type Theory (CTT) and a related synthesis formal method known as proofs-as-programs. We outline how CTT can be used to provide a uniform formal foundation for representing models, metamodels and model transformations as understood within the Object Management Group’s Meta-Object Facility (MOF 2.0) and Model Driven Architecture (MDA) suite of standards [6, 8]. CTT was originally developed to provide a unifying foundation for logic, data and programs. It is higher-order, in the sense that it permits representation and reasoning about programs, types of programs and types of types. We argue that this higher-order aspect affords a natural formal definition of metamodel/model/model instantiation relationships within the MOF. We develop formal notions of models, metamodels and model transformation specifications by utilizing the logic that is built into CTT. In proofs-as-programs, a functional program specification is represented as a special kind of type. A program is provably correct with respect to a given specification if it can be typed by that specification. We develop an analogous approach, defining model transformation specifications as types and provably correct transformations as inhabitants of specification types.
Iman Poernomo
Analysing Graph Transformation Rules through OCL
Abstract
In this paper we present an approach to the analysis of graph transformation rules based on an intermediate OCL representation. We translate different semantics of rules into OCL, together with the properties of interest (like rule applicability, conflict or independence). The intermediate representation serves three purposes: (i) allows the seamless integration of graph transformation rules with the MOF and OCL standards, and enables taking into account meta-model and OCL constraints when verifying the correctness of the rules; (ii) permits the interoperability of graph transformation concepts with a number of standards-based model-driven development tools; and (iii) makes available a plethora of OCL tools to actually perform the rule analysis.
Jordi Cabot, Robert Clarisó, Esther Guerra, Juan de Lara
Extracting Object Interactions Out of Software Contracts Using Model Transformations
Abstract
One popular approach to object design proposes to identify responsibilities from software contracts, apply a number of principles to assign them to objects, and finally construct an object interaction that realizes the contract. This three-step activity is currently a manual process that is time-consuming and error-prone, and is among the most challenging activities in object-oriented development. In this paper, we present a model transformation that partially automates this activity. Such a transformation is modularized in three stages. The first stage automatically transforms a software contract to a trace of state modification actions. In the second stage the designer manually extends the trace with design decisions. Finally, the extended trace is automatically transformed to an object interaction in the third stage. A prototype of the whole transformation was developed and successfully applied to a case study from the literature. Our technique allows the extraction of valuable information from software contracts, provides a bridge between analysis and design artifacts, and significantly reduces the effort of interaction design.
Andrés Vignaga, Daniel Perovich, María Cecilia Bastarrica
Backmatter
Metadaten
Titel
Theory and Practice of Model Transformations
herausgegeben von
Antonio Vallecillo
Jeff Gray
Alfonso Pierantonio
Copyright-Jahr
2008
Verlag
Springer Berlin Heidelberg
Electronic ISBN
978-3-540-69927-9
Print ISBN
978-3-540-69926-2
DOI
https://doi.org/10.1007/978-3-540-69927-9

Premium Partner