A Tool Environment for Managing Families of Model Transformation Rules

2016 ◽  
pp. 89-101 ◽  
Author(s):  
Daniel Strüber ◽  
Stefan Schulz
Keyword(s):  
Model Transformation ◽  
Transformation Rules

scholarly journals Incremental execution of rule-based model transformation

2020 ◽  
Author(s):  
Artur Boronat
Keyword(s):  
Model Transformation ◽  
Source Model ◽  
Model Transformations ◽  
Propagation Mechanism ◽  
Change Propagation ◽  
Computational Costs ◽  
Domain Specific ◽  
Transformation Rules ◽  
Domain Models ◽  
Event Based

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.

Constructing optimized constraint-preserving application conditions for model transformation rules

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

Evolution in Model-Driven Software Product-Line Architectures

2009 ◽  
pp. 1280-1312 ◽  
Author(s):  
Gan Deng ◽  
Jeff Gray ◽  
Douglas C. Schmidt ◽  
Yuehua Lin ◽  
Aniruddha Gokhale ◽  
...  
Keyword(s):  
Model Transformation ◽  
Software Product Line ◽  
Product Line ◽  
Domain Model ◽  
Modeling Language ◽  
Model Driven ◽  
Transformation Rules ◽  
Domain Evolution ◽  
Software Product

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.

Evolution in Model-Driven Software Product-Line Architectures

2009 ◽  
pp. 102-132 ◽  
Author(s):  
Gan Deng ◽  
Douglas C. Schmidt ◽  
Aniruddha Gokhale ◽  
Jeff Gray ◽  
Yuehua Lin ◽  
...  
Keyword(s):  
Model Transformation ◽  
Product Line ◽  
Domain Model ◽  
Modeling Language ◽  
Model Driven Engineering ◽  
Model Driven ◽  
Transformation Rules ◽  
Domain Evolution ◽  
Software Product

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.

A Meta-Model-Based Approach to the Definition of the Analysis Results of Petri-Net Models

2013 ◽  
pp. 104-116
Author(s):  
Simona Bernardi ◽  
José Merseguer
Keyword(s):  
Petri Net ◽  
Model Transformation ◽  
Common Method ◽  
System Behavior ◽  
Modeling And Analysis ◽  
Meta Model ◽  
Transformation Rules ◽  
Model Based ◽  
Modeling Techniques ◽  
Definition Of

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.

A Contribution to the Specification of Model Transformations with Metamodel Matching Approach

2017 ◽  
Vol 8 (3) ◽  
pp. 1-23 ◽  
Author(s):  
Karima Berramla ◽  
El Abbassia Deba ◽  
Abou El Hassen Benyamina ◽  
Djilali Benhamamouch
Keyword(s):  
Model Transformation ◽  
Model Transformations ◽  
Abstract Representation ◽  
Model Driven ◽  
Transformation Rules ◽  
Transformation Language ◽  
Matching Technique ◽  
Concrete Syntax ◽  
Abstract Level ◽  
Use Of Models

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.

Research on Conversion from UML Activity Diagram to Procedure Blueprint

2011 ◽  
Vol 135-136 ◽  
pp. 766-769
Author(s):  
Jian Bin Liu ◽  
Tie Qiang Li
Keyword(s):  
Process Modeling ◽  
Model Transformation ◽  
Data Exchange ◽  
Modeling Language ◽  
Static Structure ◽  
General Transformation ◽  
Activity Diagram ◽  
Transformation Rules ◽  
Static Modeling ◽  
Uml Activity Diagram

UML, as an international standard, is not suitable for static modeling of the program procedure. While Procedure Blueprint is a visual process modeling language and is suitable for modeling the procedure, which can supplement the UML deficiencies during the process of modeling the program static structure. In this paper, taking XMI as a common data structure and a data exchange bridge, proposed the general transformation idea, the transformation rules and the transformation algorithm from activity diagram to the procedure blueprint. This has laid the foundations for achieving the model transformation at last.

Sign in / Sign up

Export Citation Format

Share Document