Differencing of Model Transformation Rules: Towards Versioning Support in the Development and Maintenance of Model Transformations

Author(s):  
Timo Kehrer ◽  
Christopher Pietsch ◽  
Daniel Strüber
Author(s):  
Artur Boronat

Abstract When model transformations are used to implement consistency relations between very large models, incrementality plays a cornerstone role in detecting and resolving inconsistencies efficiently when models are updated. Given a directed consistency relation between two models, the problem studied in this work consists in propagating model changes from a source model to a target model in order to ensure consistency while minimizing computational costs. The mechanism that enforces such consistency is called consistency maintainer and, in this context, its scalability is a required non-functional requirement. State-of-the-art model transformation engines with support for incrementality normally rely on an observer pattern for linking model changes, also known as deltas, to the application of model transformation rules, in so-called dependencies, at run time. These model changes can then be propagated along an already executed model transformation. Only a few approaches to model transformation provide domain-specific languages for representing and storing model changes in order to enable their use in asynchronous, event-based execution environments. The principal contribution of this work is the design of a forward change propagation mechanism for incremental execution of model transformations, which decouples dependency tracking from change propagation using two innovations. First, the observer pattern-based model is replaced with dependency injection, decoupling domain models from consistency maintainers. Second, a standardized representation of model changes is reused, enabling interoperability with EMF-compliant tools, both for defining model changes and for processing them asynchronously. This procedure has been implemented in a model transformation engine, whose performance has been evaluated experimentally using the VIATRA CPS benchmark. In the experiments performed, the new transformation engine shows gains in the form of several orders of magnitude in the initial phase of the incremental execution of the benchmark model transformation and change propagation is performed in real time for those model sizes that are processable by other tools and, in addition, is able to process much larger models.


Author(s):  
Karima Berramla ◽  
El Abbassia Deba ◽  
Abou El Hassen Benyamina ◽  
Djilali Benhamamouch

Model-driven engineering (MDE) is a paradigm based on the intensive use of models throughout the life cycle of an application, where model transformation plays an important role. Various model transformation approaches have been proposed, but developers are still faced with the complexity of model transformation specifications. Most of these approaches are based on the specification of transformation rules with a concrete syntax at a low level where the developer must master the transformation language. The question at this level is how to generate a model transformation specification that must be at a very abstract level, independent of any transformation language. This article aims to propose an approach to generate an abstract representation of transformation rules and these are used to produce a source code written in a chosen transformation language. The transformation rules are calculated semi-automatically by using a matching technique on elements of source and target metamodels. This idea is illustrated by different transformation examples.


Author(s):  
Liliana María Favre

The model-driven architecture (MDA) is an approach to model-centric software development. The concepts of models, metamodels, and model transformations are at the core of MDA. Model-driven development (MDD) distinguishes different kinds of models: the computation-independent model (CIM), the platform-independent model (PIM), and the platform-specific model (PSM). Model transformation is the process of converting one model into another model of the same system, preserving some kind of equivalence relation between them. One of the key concepts behind MDD is that models generated during software developments are represented using common metamodeling techniques. In this chapter, we analyze an integration of MDA metamodeling techniques with knowledge developed by the community of formal methods. We describe a rigorous framework that comprises the NEREUS metamodeling notation (open to many other formal languages), a system of transformation rules to bridge the gap between UML/OCL and NEREUS, the definition of MDA-based reusable components, and model/metamodeling transformations. In particular, we show how to integrate NEREUS with algebraic languages using the Common Algebraic Specification Language (CASL). NEREUS focuses on interoperability of formal languages in MDD.


Author(s):  
Liliana Favre

The model-driven architecture (MDA) is an approach to model-centric software development. The concepts of models, metamodels, and model transformations are at the core of MDA. Model-driven development (MDD) distinguishes different kinds of models: the computation-independent model (CIM), the platform-independent model (PIM), and the platform-specific model (PSM). Model transformation is the process of converting one model into another model of the same system, preserving some kind of equivalence relation between them. One of the key concepts behind MDD is that models generated during software developments are represented using common metamodeling techniques. In this chapter, we analyze an integration of MDA metamodeling techniques with knowledge developed by the community of formal methods. We describe a rigorous framework that comprises the NEREUS metamodeling notation (open to many other formal languages), a system of transformation rules to bridge the gap between UML/OCL and NEREUS, the definition of MDA-based reusable components, and model/metamodeling transformations. In particular, we show how to integrate NEREUS withalgebraic languages using the Common Algebraic Specification Language (CASL). NEREUS focuses on interoperability of formal languages in MDD.


2020 ◽  
Vol 114 ◽  
pp. 100564 ◽  
Author(s):  
Nebras Nassar ◽  
Jens Kosiol ◽  
Thorsten Arendt ◽  
Gabriele Taentzer

2009 ◽  
pp. 1280-1312 ◽  
Author(s):  
Gan Deng ◽  
Jeff Gray ◽  
Douglas C. Schmidt ◽  
Yuehua Lin ◽  
Aniruddha Gokhale ◽  
...  

This chapter describes our approach to modeldriven engineering (MDE)-based product line architectures (PLAs) and presents a solution to address the domain evolution problem. We use a case study of a representative software-intensive system from the distributed real-time embedded (DRE) systems domain to describe key challenges when facing domain evolution and how we can evolve PLAs systematically and minimize human intervention. The approach uses a mature metamodeling tool to define a modeling language in the representative DRE domain, and applies a model transformation tool to specify model-tomodel transformation rules that precisely define metamodel and domain model changes. Our approach automates many tedious, time consuming, and error-prone tasks of model-to-model transformation, thus significantly reducing the complexity of PLA evolution.


Author(s):  
Gan Deng ◽  
Douglas C. Schmidt ◽  
Aniruddha Gokhale ◽  
Jeff Gray ◽  
Yuehua Lin ◽  
...  

This chapter describes our approach to model-driven engineering (MDE)-based product line architectures (PLAs) and presents a solution to address the domain evolution problem. We use a case study of a representative software-intensive system from the distributed real-time embedded (DRE) systems domain to describe key challenges when facing domain evolution and how we can evolve PLAs systematically and minimize human intervention. The approach uses a mature metamodeling tool to define a modeling language in the representative DRE domain, and applies a model transformation tool to specify modelto- model transformation rules that precisely define metamodel and domain model changes. Our approach automates many tedious, time consuming, and error-prone tasks of model-to-model transformation, thus significantly reducing the complexity of PLA evolution.


Author(s):  
Simona Bernardi ◽  
José Merseguer

Multi-formalism modeling techniques enable the modeling and analysis of different aspects of a system. One of the main issues in the integration of multiple tools to support multi-formalisms is how to provide a common method to report the results of the analysis and how to interchange them between models, based on different formalisms, that often represent the system behavior at different granularity levels. In this chapter, the authors focus on the Petri Net formalism, and they present a preliminary work toward the definition of a common XML-based language for the specification of the results obtained from the analysis of Petri net models. The authors use a meta-model based approach, where first a structured set of meta-models representing the Petri net result concepts and their relationships are defined. Then, model transformation rules enable the mapping of meta-models to XML constructs.


Sign in / Sign up

Export Citation Format

Share Document