Bidirectional Model Transformations Research Articles

Termination and Expressiveness of Execution Strategies for Networks of Bidirectional Model Transformations

When developers describe a software system with multiple models, such as architecture diagrams, deployment descriptions, and source code, these models must represent the system in a uniform way, i.e., they must be and stay consistent . One means to automatically preserve consistency after changes to models are model transformations, of which bidirectional transformations that preserve consistency between two models have been well researched. To preserve consistency between multiple models, such transformations can be combined to networks. When transformations are developed independently and reused modularly, the resulting network can be of arbitrary topology. For such networks, no universal strategy exists to orchestrate the execution of transformations such that the resulting models are consistent. In this article, we prove that termination of such a strategy can only be guaranteed if it is incomplete, i.e., if it is allowed to fail to restore consistency for some changes although an execution order of transformations exists that yields consistent models. We propose such a strategy, for which we prove termination and show that and why it makes it easier for users of model transformation networks to understand the reasons whenever the strategy fails. In addition, we provide a simulator for the comparison of different execution strategies. These findings help transformation developers and users in understanding when and why they can expect the execution of a transformation network to terminate and when they can even expect it to succeed. Furthermore, the proposed strategy guarantees them termination and supports them in finding the reason whenever it is not successful.

BXtendDSL at Work: Combining Declarative and Imperative Programming of Bidirectional Model Transformations

BXtendDSL at Work: Combining Declarative and Imperative Programming of Bidirectional Model Transformations

BXtendDSL: A layered framework for bidirectional model transformations combining a declarative and an imperative language

Model-driven software development (MDSD) heavily relies on model transformations. While in a strict forward engineering process unidirectional transformations are used, bidirectional transformations are crucial as soon as roundtrip engineering comes into play. In this paper, we present a hybrid language specifically designed to describe bidirectional model transformations. From a declarative transformation specification code is generated which uses our framework for bidirectional and incremental model transformations. A sophisticated code generation mechanism allows for hooking into the generated transformation code at the imperative level to supply behavior that cannot be expressed declaratively. A thorough evaluation demonstrates conciseness, expressiveness, and scalability of our approach.

IMPLEMENTATION OF NOVEL APPROACHES IN BIDIRECTIONAL MODEL TRANSFORMATION: A SYSTEMATIC LITERATURE REVIEW

In the past few years, software development has seen rapid growth, and developers have adopted different methods to provide efficient procedures in software development, thus reducing the overall bug counts and time delay. Bidirectional model transformation is one such technique that encompasses the development of the object code in both directions enabling an abstract view of the software to the developer; over the year’s researchers, have been able to produce many approaches in bidirectional model transformations (bx), but the cost and best fir for effective model transformation, in particular, a quantities survey will be designed which will discuss the best possible apron in the bx. The methodology for this survey shall be made through SLR to identify around 20 different approaches proposed for bidirectional model transformation; these studies range from the year 2010 till date and are thus, rendered latest in the respective fields of our survey. The gathered results have been calculated on the specific set of parameters that are cost and time of usage time are the main aspects of these approaches, and that is the predicament that has made us produce a systematic literature review (SLR) on this very topic. Thus, this paper investigates different approaches based on their implementation cost and time delay and discusses their limitations, and the approach is implemented. Those approaches have been selected, which culminate in both of these respective parameters. The main objective of this SLR is to provide an insight into the different approaches and establish a well-balanced approach that can be used in bidirectional model transformation in software development.

Model-driven engineering city spaces via bidirectional model transformations

Engineering cyber-physical systems inhabiting contemporary urban spatial environments demands software engineering facilities to support design and operation. Tools and approaches in civil engineering and architectural informatics produce artifacts that are geometrical or geographical representations describing physical spaces. The models we consider conform to the CityGML standard; although relying on international standards and accessible in machine-readable formats, such physical space descriptions often lack semantic information that can be used to support analyses. In our context, analysis as commonly understood in software engineering refers to reasoning on properties of an abstracted model—in this case a city design. We support model-based development, firstly by providing a way to derive analyzable models from CityGML descriptions, and secondly, we ensure that changes performed are propagated correctly. Essentially, a digital twin of a city is kept synchronized, in both directions, with the information from the actual city. Specifically, our formal programming technique and accompanying technical framework assure that relevant information added, or changes applied to the domain (resp. analyzable) model are reflected back in the analyzable (resp. domain) model automatically and coherently. The technique developed is rooted in the theory of bidirectional transformations, which guarantees that synchronization between models is consistent and well behaved. Produced models can bootstrap graph-theoretic, spatial or dynamic analyses. We demonstrate that bidirectional transformations can be achieved in practice on real city models.

From software architecture to analysis models and back: Model-driven refactoring aimed at availability improvement

With the ever-increasing evolution of software systems, their architecture is subject to frequent changes due to multiple reasons, such as new requirements. Appropriate architectural changes driven by non-functional requirements are particularly challenging to identify because they concern quantitative analyses that are usually carried out with specific languages and tools. A considerable number of approaches have been proposed in the last decades to derive non-functional analysis models from architectural ones. However, there is an evident lack of automation in the backward path that brings the analysis results back to the software architecture. In this paper, we propose a model-driven approach to support designers in improving the availability of their software systems through refactoring actions. The proposed framework makes use of bidirectional model transformations to map UML models onto Generalized Stochastic Petri Nets (GSPN) analysis models and vice versa. In particular, after availability analysis, our approach enables the application of model refactoring, possibly based on well-known fault tolerance patterns, aimed at improving the availability of the architectural model. We validated the effectiveness of our approach on an Environmental Control System. Our results show that the approach can generate: (i) an analyzable availability model from a software architecture description, and (ii) valid software architecture models back from availability models. Finally, our results highlight that the application of fault tolerance patterns significantly improves the availability in each considered scenario. The approach integrates bidirectional model transformation and fault tolerance techniques to support the availability-driven refactoring of architectural models. The results of our experiment showed the effectiveness of the approach in improving the software availability of the system.

Testing bidirectional model transformation using metamorphic testing

ContextIn model-based software development, bidirectional model transformation (BX) provides a fundamental solution to model synchronization that can retain the consistency among models. Similar to conventional programs, a BX program may also contain bugs. Accordingly, a BX program must be tested prior to being used in practice. A challenging problem of testing BX programs is to construct test oracles (e.g., assertions and expected output models), which are usually difficult and/or expensive to manually specify. ObjectiveIn we paper, we investigate how to alleviate the oracle problem in BX testing via reducing the costs of developing test oracles. MethodWe propose a metamorphic testing approach for BX. First, we identify three generic metamorphic relations for BX. Afterwards, we define a metamodel MT4MT to establish metamorphic test groups and test scripts. We also propose a testing framework to support metamorphic testing based on MT4MT. ResultsWe conducted an experimental study of mutation analysis and a case study on three ATL-based ad-hoc BXs. The results of the experimental study and the case study showed that our approach killed 79.38% mutants and enabled us to test real-world ATL-based ad-hoc BXs. We also demonstrated that MT4MT can be used to test the semantics properties of BXs. ConclusionOur approach is an effective and practical approach with lower costs of developing test oracles.

EVL+Strace: a novel bidirectional model transformation approach

Context: Model transformation, as one of the cornerstones of Model-Driven Engineering (MDE) paradigm, produces target models from source models. In most of the practical cases, both source and target models are changed independently and it is essential to preserve the consistency between them. Bidirectional transformation (Bx) provides a mechanism to re-establish this inter-model consistency. Bx approaches suffer from several limitations, such as lack of a comprehensive implementation, low learnability, and mismanagement of update conflicts.Objective: To alleviate the aforementioned drawbacks, we propose a novel Bx approach, called EVL+Strace, which is built using the Epsilon Validation Language (EVL) on a domain-specific trace metamodel (Strace). Furthermore, an Eclipse-based toolkit, called MoDEBiTE, is developed to automatically produce the EVL+Strace artifacts including the specific trace metamodel and transformation code.Method: EVL+Strace exploits the ability of EVL to transform user updates on models from source to target and vice versa, simultaneously. The applied trace metamodel should be specific to the domains of source and target metamodels that prevents illegitimate trace elements. Additionally, it enables developers to specify the transformation concepts more precisely. A running example is applied to explain the components of EVL+Strace and application of MoDEBiTE.Result: EVL+Strace is the first practical interactive approach that can provide important bidirectional features, such as preservation and propagation. A feature model of Bx approaches is applied to compare EVL+Strace with the well-known Bx languages. To show the superiority of EVL+Strace and applicability of MoDEBiTE, a comprehensive evaluation on six case studies is performed.Conclusion: EVL+Strace provides an interactive transformation system to manage update conflicts. It uses the EVL language for defining Bx transformation that has an easy-to-learn syntax. It is developed based on Epsilon, which is a comprehensive and actively updated framework.

Enforcing fine-grained access control for secure collaborative modelling using bidirectional transformations

Large-scale model-driven system engineering projects are carried out collaboratively. Engineering artefacts stored in model repositories are developed in either offline (checkout–modify–commit) or online (GoogleDoc-style) scenarios. Complex systems frequently integrate models and components developed by different teams, vendors and suppliers. Thus, confidentiality and integrity of design artefacts need to be protected in accordance with access control policies. We propose a secure collaborative modelling approach where fine-grained access control for models is strictly enforced by bidirectional model transformations. Collaborators obtain filtered local copies of the model containing only those model elements which they are allowed to read; write access control policies are checked on the server upon submitting model changes. We present a formal collaboration schema which provenly guarantees certain correctness constraints, and its adaption to online scenarios with on-the-fly change propagation and the integration into existing version control systems to support offline scenarios. The approach is illustrated, and its scalability is evaluated using a case study of the MONDO EU project.

Change propagation and bidirectionality in internal transformation DSLs

Despite good results in several industrial projects, model-driven engineering (MDE) has not been widely adopted in industry. Although MDE has existed for more than a decade now, the lack of tool support is still one of the major problems, according to studies by Staron and Mohaghegi (Staron, in: Model driven engineering languages and systems, Springer, Berlin, 2006; Mohagheghi et al. in Empir Softw Eng 18(1):89–116, 2013). Internal languages offer a solution to this problem for model transformations, which are a key part of MDE. Developers can use existing tools of host languages to create model transformations in a familiar environment. These internal languages, however, typically lack key features such as change propagation or bidirectional transformations. In our opinion, one reason is that existing formalisms for these properties are not well suited for textual languages. In this paper, we present a new formalism describing incremental, bidirectional model synchronizations using synchronization blocks. We prove the ability of this formalism to detect and repair inconsistencies and show its hippocraticness. We use this formalism to create a single internal model transformation language for unidirectional and bidirectional model transformations with optional change propagation. In total, we currently provide 18 operation modes based on a single specification. At the same time, the language may reuse tool support for C#. We validate the applicability of our language using a synthetic example with a transformation from finite state machines to Petri nets where we achieved speedups of up to multiple orders of magnitude compared to classical batch transformations.

A Posteriori Typing for Model-Driven Engineering

Model-Driven Engineering (MDE) is founded on the ability to create and process models conforming to a meta-model. In this context, classes in a meta-model are used in two ways: as templates to create objects and as (static) classifiers for them. These two aspects are inherently tied in most meta-modelling approaches, which results in unnecessarily rigid systems and hinders reusability of MDE artefacts. In this work, we discuss the benefits of decoupling object creation from typing in MDE. Thus, we rely on standard mechanisms for object creation, and propose a posteriori typing as a means to retype objects and enable multiple, partial, dynamic typings. This approach enhances flexibility; permits unanticipated reuse, as model management operations defined for a meta-model can be reused with other models once they get reclassified; and enables bidirectional model transformation by reclassification. In particular, we propose two mechanisms to realise model retyping and show their underlying theory and analysis methods. We show the feasibility of the approach by an implementation atop our meta-modelling tool M eta D epth and present several applications of retypings (transformations, reuse, and dynamicity).

Testing models and model transformations using classifying terms

This paper proposes the use of equivalence partitioning techniques for testing models and model transformations. In particular, we introduce the concept of classifying terms, which are general OCL terms on a class model enriched with OCL constraints. Classifying terms permit defining equivalence classes, in particular for partitioning the source and target model spaces of the transformation, defining for each class a set of equivalent models with regard to the transformation. Using these classes, a model validator tool is able to automatically construct object models for each class, which constitute relevant test cases for the transformation. We show how this approach of guiding the construction of test cases in an orderly, systematic and efficient manner can be effectively used in combination with Tracts for testing both directional and bidirectional model transformations and for analyzing their behavior.

Case-based exploration of bidirectional transformations in QVT Relations

QVT Relations (QVT-R), a standard issued by the Object Management Group, is a language for the declarative specification of model transformations. This paper focuses on a particularly interesting feature of QVT-R: the declarative specification of bidirectional transformations. Rather than writing two unidirectional transformations separately, a transformation developer may provide a single relational specification which may be executed in both directions. This approach saves specification effort and ensures the consistency of forward and backward transformations. This paper explores QVT-R’s support for bidirectional model transformations through a spectrum of transformation cases. The transformation cases vary with respect to several factors such as the size of the transformation definition or the relationships between the metamodels for source and target models. The cases are solved in QVT-R, but may be applied to other bidirectional transformation languages, as well; thus, they may be used as a benchmark for comparing bidirectional transformation languages. In our work, we focus on the following research questions: functionality of bidirectional transformations in terms of relations between source and target models, solvability (which problems may be solved by a single relational specification of a bidirectional transformation), variability (does a bidirectional transformation contain varying elements, i.e., elements being specific to one direction), comprehensibility (referring to the ease of understanding and constructing QVT-R transformations), and the semantic soundness of bidirectional transformations written in QVT-R.

Feature-based classification of bidirectional transformation approaches

Bidirectional model transformation is a key technology in model-driven engineering (MDE), when two models that can change over time have to be kept constantly consistent with each other. While several model transformation tools include at least a partial support to bidirectionality, it is not clear how these bidirectional capabilities relate to each other and to similar classical problems in computer science, from the view update problem in databases to bidirectional graph transformations. This paper tries to clarify and visualize the space of design choices for bidirectional transformations from an MDE point of view, in the form of a feature model. The selected list of existing approaches are characterized by mapping them to the feature model. Then, the feature model is used to highlight some unexplored research lines in bidirectional transformations.

Least-change bidirectional model transformation with QVT-R and ATL

QVT Relations (QVT-R) is the standard language proposed by the OMG to specify bidirectional model transformations. Unfortunately, in part due to ambiguities and omissions in the original semantics, acceptance and development of effective tool support have been slow. Recently, the checking semantics of QVT-R has been clarified and formalized. In this article, we propose a QVT-R tool that complies to such semantics. Unlike any other existing tool, it also supports meta-models enriched with OCL constraints (thus avoiding returning ill-formed models) and proposes an alternative enforcement semantics that works according to the simple and predictable “principle of least change.” The implementation is based on an embedding of both QVT-R transformations and UML class diagrams (annotated with OCL) in Alloy, a lightweight formal specification language with support for automatic model finding via SAT solving. We also show how this technique can be applied to bidirectionalize ATL, a popular (but unidirectional) model transformation language.

A Comparison of Incremental Triple Graph Grammar Tools

Triple Graph Grammars (TGGs) are a graph-based and visual technique for specifying bidirectional model transformation. TGGs can be used to transform models from scratch (in the batch mode), but the real potential of TGGs lies in propagating updates incrementally. Existing TGG tools differ considerably in their incremental mode concerning underlying algorithms, user-oriented aspects, incremental update capabilities, and formal properties. Indeed, the different foci, strengths, and weaknesses of current TGG tools in the incremental mode are difficult to discern, especially for non-developers. In this paper, we close this gap by (i) identifying a set of criteria for a qualitative comparison of TGG tools in the incremental mode, (ii) comparing three prominent incremental TGG tools with regard to these criteria, and (iii) conducting a quantitative comparison by means of runtime measurements.

Formal analysis of model transformations based on triple graph grammars

Triple graph grammars (TGGs) are a well-established concept for the specification and execution of bidirectional model transformations within model driven software engineering. Their main advantage is an automatic generation of operational rules for forward and backward model transformations, which simplifies specification and enhances usability as well as consistency. In this paper we present several important results for analysing model transformations based on the formal categorical foundation of TGGs within the framework of attributed graph transformation systems.Our first main result shows that the crucial properties of correctness and completeness are ensured for model transformations. In order to analyse functional behaviour, we generate a new kind of operational rule, called aforward translation rule. We apply existing results for the analysis of local confluence for attributed graph transformation systems. As additional main results, we provide sufficient criteria for the verification of functional behaviour as well as a necessary and sufficient condition for strong functional behaviour. In fact, these conditions imply polynomial complexity for the execution of the model transformation. We also analyse information and complete information preservation of model transformations, that is, whether a source model can be reconstructed (uniquely) from the target model computed by the model transformation. We illustrate the results for the well-known model transformation example from class diagrams to relational database models.

A bidirectional-transformation-based framework for software visualization and visual editing

Software visualization and visual editing are important and practical techniques to improve the development of complex software systems. A challenge when applying the two technologies is how to realize the correspondence, a bidirectional relationship, between the data and its visual representation correctly. Although many tools and frameworks have been developed to support the construction of visual tools, it is still complicated and error-prone to realize the bidirectional relationship. In this paper, we propose a model-driven and bidirectional-transformation-based framework for data visualization and visual editing. Our approach mainly focuses on 1) how to define and manage graphical symbols in the model form and 2) how to specify and implement the bidirectional relationship based on the technique of bidirectional model transformation. Then, a prototype tool and four case studies are presented to evaluate the feasibility of our work.

A perspective on architectural re-engineering

Continuous evolution towards very large, heterogeneous, highly dynamic computing systems entails the need for sound and flexible approaches to deal with system modification and re-engineering. The approach proposed in this paper combines an analysis stage, to identify concrete patterns of interaction in legacy code, with an iterative re-engineering process at a higher level of abstraction. Both stages are supported by the tools CoordPat and Archery, respectively. Bi-directional model transformations connecting code level and design level architectural models are defined. The approach is demonstrated in a (fragment of a) case study.

A Solution to the Flowgraphs Case Study using Triple Graph Grammars and eMoflon

After 20 years of Triple Graph Grammars (TGGs) and numerous actively maintained implementations, there is now a need for challenging examples and success stories to show that TGGs can be used for real-world bidirectional model transformations. Our primary goal in recent years has been to increase the expressiveness of TGGs by providing a set of pragmatic features that allow a controlled fallback to programmed graph transformations and Java. Based on the Flowgraphs case study of the Transformation Tool Contest (TTC 2013), we present (i) attribute constraints used to express complex bidirectional attribute manipulation, (ii) binding expressions for specifying arbitrary context relationships, and (iii) post-processing methods as a black box extension for TGG rules. In each case, we discuss the enabled trade-off between guaranteed formal properties and expressiveness. Our solution, implemented with our metamodelling and model transformation tool eMoflon (www.emoflon.org), is available as a virtual machine hosted on Share.