Definition Of Model Transformations Research Articles

A query-retyping approach to model transformation co-evolution

In rule-based approaches, a model transformation definition tells how an instance of a source metamodel should be transformed to an instance of a target metamodel. As these metamodels undergo changes, model transformations defined over these metamodels may get out of sync. Restoring conformance between model transformations and the metamodels is a complex and error-prone task. In this paper, we propose a formal approach to automatically co-evolve model transformations according to the evolution of the metamodels. The approach is based on encoding the model transformation definition as a query-retyping combination and the evolution of the metamodels as applications of graph transformation rules. These rules are used to obtain an evolved query over the evolved metamodel together with a new retyping from the target metamodel. We will identify the criteria which need to be fulfilled in order to make this automatic co-evolution possible. We provide a tool support for this procedure, in which, from a traceability model that represents the original model transformation definition, we derive a co-evolved traceability model that represents the evolved transformation definition. Moreover, we use a case study to evaluate the approach with a set of commonly performed metamodel evolutions.

Grammar-based model transformations: Definition, execution, and quality properties

Model transformation is a key concept in model-driven software engineering. The definition of model transformations is usually based on meta-models describing the abstract syntax of languages. While meta-models are thereby able to abstract from superfluous details of concrete syntax, they often loose structural information inherent in languages, like information on model elements always occurring together in particular shapes. As a consequence, model transformations cannot naturally re-use language structures, thus leading to unnecessary complexity in their development as well as in quality assurance.In this paper, we propose a new approach to model transformation development which allows to simplify the developed transformations and improve their quality via the exploitation of the languages׳ structures. The approach is based on context-free graph grammars and transformations defined by pairing productions of source and target grammars. We show that such transformations have important properties: they terminate and are sound, complete, and deterministic.

Institution-based foundations for verification in the context of model-driven engineering

Within the Model-Driven Engineering (MDE) paradigm, a separation of duties between software developers is usually proposed to cope with formal verification issues. MDE experts are responsible for the definition of models and model transformations, while formal verification experts conduct the verification process. This schema should be aided by (semi)automatic translations from the MDE elements to their formal representation in the potentially many semantic domains used for verification, and also by translations between these domains. Translations may be useful to perform a heterogeneous verification, i.e. using different domains for the verification of each part of the whole problem, and also to integrate MDE elements with the specification and verification of other traditional software artifacts. However, this schema requires formal foundations allowing the representation of the MDE elements in such a way that it is possible to ensure that translations are semantic-preserving. The aim of this paper is to present a formalization of the MDE elements using the Theory of Institutions. We provide institutions for the representation of MDE elements based on the MOF and QVT-Relations standards. We also show how the theory assists with these requirements for the definition of an environment for the formal verification of MDE elements using heterogeneous verification approaches.

Generating Domain-Specific Visual Language Tools from Abstract Visual Specifications

Domain-specific visual languages support high-level modeling for a wide range of application domains. However, building tools to support such languages is very challenging. We describe a set of key conceptual requirements for such tools and our approach to addressing these requirements, a set of visual language-based metatools. These support definition of metamodels, visual notations, views, modeling behaviors, design critics, and model transformations and provide a platform to realize target visual modeling tools. Extensions support collaborative work, human-centric tool interaction, and multiplatform deployment. We illustrate application of the metatoolset on tools developed with our approach. We describe tool developer and cognitive evaluations of our platform and our exemplar tools, and summarize key future research directions.

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 two (or more) models must be kept consistent in the face of changes to either or both. 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. A precise understanding of checkonly mode transformations is prerequisite to a precise understanding of enforce mode transformations, and this is the focus of this paper. In order to give semantics to checkonly QVT-R transformations, 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 no translation from QVT-R to QVT Core can be semantics-preserving, and hence no such translation can be helpful in defining the semantics of QVT-R. Treating QVT-R directly, we propose a simple game-theoretic semantics. We demonstrate its behaviour on examples and show how it can be used to prove an example result comparing two QVT-R transformations. 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.

A Proposed Compiler to Integrate Model Driven Architecture with Web Services Road Map

Model Driven Architecture (MDA) technique is mainly depend on two processes; mapping specification and transformation definition, this last one (sometimes called model transformation definition) has a tool to implement, which the most used one is Query/View/Transformation (QVT) Relational Language. This language sponsored by Object Management Group (OMG), and we found that it needs a repository for the both target model and source model, that mean these two models must be exist before execute the transformation definition (QVT Code). To eliminate this repository problem we propose in this paper a solution for this problem that we can compile the QVT code into Business Process Execution Language for Web Services (BPEL4WS). This solution will provide valuable contribution especially for MDA infrastructure, firstly to eliminate repository requirements for target model, secondly to make model transformation as web services. General Terms Model Driven Architecture; Model Transformation; Integration of Web Services with other Techniques.

An Approach to use MDE in Dynamically Reconfigurable Networked Embedded SOAs

AbstractIntegration, reuse, flexibility and adaptability are some of the characteristics demanded by current complex embedded applications in order to adapt to a rapidly changing and competitive market. Besides, commonly they must be distributed in open and heterogeneous environments and able to be flexible enough in order to cope with dynamic changes of its environment (dynamic reconfiguration). Model Driven Engineering (MDE) is a software development methodology that promotes an intensive use of models, or abstractions, to cope with the complexity inherent to the application design. This paper proposes a modelling approach, in the context of the ARTEMIS iLAND project, for networked embedded service oriented applications, having specific dynamic reconfiguration requirements assuring an optimum usage of the limited system resources. The modelling approach focuses on the definition of models and model transformations, from the application requirements to code generation, emphasizing dynamic reconfiguration of the application.

A semi‐automatic approach for bridging DSMLs with UML

PurposeThe definition of modeling languages is a key‐prerequisite for model‐driven engineering. In this respect, Domain‐Specific Modeling Languages (DSMLs) defined from scratch in terms of metamodels and the extension of Unified Modeling Language (UML) by profiles are the proposed options. For interoperability reasons, however, the need arises to bridge modeling languages originally defined as DSMLs to UML. Therefore, the paper aims to propose a semi‐automatic approach for bridging DSMLs and UML by employing model‐driven techniques.Design/methodology/approachThe paper discusses problems of the ad hoc integration of DSMLs and UML and from this discussion a systematic and semi‐automatic integration approach consisting of two phases is derived. In the first phase, the correspondences between the modeling concepts of the DSML and UML are defined manually. In the second phase, these correspondences are used for automatically producing UML profiles to represent the domain‐specific modeling concepts in UML and model transformations for transforming DSML models to UML models and vice versa. The paper presents the ideas within a case study for bridging ComputerAssociate's DSML of the AllFusion Gen CASE tool with IBM's Rational Software Modeler for UML.FindingsThe ad hoc definition of UML profiles and model transformations for achieving interoperability is typically a tedious and error‐prone task. By employing a semi‐automatic approach one gains several advantages. First, the integrator only has to deal with the correspondences between the DSML and UML on a conceptual level. Second, all repetitive integration tasks are automated by using model transformations. Third, well‐defined guidelines support the systematic and comprehensible integration.Research limitations/implicationsThe paper focuses on the integrating direction DSMLs to UML, but not on how to derive a DSML defined in terms of a metamodel from a UML profile.Originality/valueAlthough, DSMLs defined as metamodels and UML profiles are frequently applied in practice, only few attempts have been made to provide interoperability between these two worlds. The contribution of this paper is to integrate the so far competing worlds of DSMLs and UML by proposing a semi‐automatic approach, which allows exchanging models between these two worlds without loss of information.

Semantic Interoperability through the Definition of Conceptual Model Transformations

AbstractThe integration of distributed geospatial data is a great issue in GI Science. Hereby, the collection of data from different systems and different structures as well as across country borders is a problem. We explain a model‐based four‐step approach to conceptual data modelling. Within this approach, we introduce a methodology to map data models on the conceptual level without touching data formats. First, we developed a conceptual mapping language called “UMLT” which is the core of our approach. Furthermore, we integrated UMLT into the Model‐Driven Architecture where a conceptual model mapping is referred to as a platform independent model mapping. Finally, the data format transformation is deduced from the model mapping automatically. This represents the implementation mapping from a platform independent model to a platform specific model. Together with transformation operations for attribute mapping, this approach is a means for effective and enhanced semantic interoperability.

Graph Transformation Semantics for a QVT Language

It has been claimed by many in the graph transformation community that model transformation, as understood in the context of Model Driven Architecture, can be seen as an application of graph transformation. In this paper we substantiate this claim by giving a graph transformation-based semantics to one of the original QVT language proposals; that is, we define a mechanism that will translate any model transformation definition in the QVT language to a graph production system whose effect is to apply that model transformation. The translation has been fully implemented.

From Process Models to Navigational Models

The navigational model, in many methods for hypermedia development, is built based on the structural elements. The dynamic aspects that affect the navigation are not taken in account, although some recent approaches include these dynamic aspects after the generation of a navigational model based on the data structures. In this work we show how to obtain navigational models from process models, as a result the navigational model are more realistic. The method follows a model driven and object oriented approach, for the definition of model transformations. The transformations between the elements in the process model and the navigational model are given. Finally, the applications of that rules are shown through an example.

Definition and validation of model transformations

With model transformations becoming more widely used, there is an increasing need for approaches focussing on a systematic development of model transformations. Although a number of approaches for specifying model transformations exist, none of them focusses on systematically validating model transformations with respect to termination and confluence. Termination and confluence ensure that a model transformation always produces a unique result. Also called functionality, these properties are important requirements for practical applications of model transformations. In this paper, we introduce our approach to model transformation. Using and extending results from the theory of graph transformation, we investigate termination and confluence properties of model transformations specified in our approach. We establish a set of criteria for termination and confluence to be checked at design time by static analysis of the transformation rules and the underlying metamodels. Moreover, the criteria are formulated in such a way that they require less experience with the theory of graph transformation. Our concepts are illustrated by a running example of a model tranformation from statecharts to the process algebra Communicating Sequential Processes.