Specification Of Model Transformations Research Articles

MoTrans-BDI: Leveraging the Beliefs-Desires-Intentions agent architecture for collaborative model transformation by example

Due to the growing interest in model-driven system development techniques, the efficient design of automated model transformations between heterogeneous models has become a major challenge in software development. While a number of specialized languages have been proposed, aiming at specifying model transformations, there is currently no matured foundation for specifying transformations between such models that are based on designers/experts collaboration in order to propose a solution that satisfies users’ requirements and application constraints. This transformation process is a complex task and must emulate how designers and experts with different perspectives behave and reflect about model transformations. In this paper, we propose a framework based on a novel approach for the specification and design of model transformations called MoTrans-BDI, which leverages Evolutionary Multi-Agent System (EMAS) to simulate designers’ expertise for the transformation of models. Our approach is based on the Belief-Desire-Intention (BDI) agent model and the Contract Net Protocol where agents’ beliefs feed from a series of transformation examples. The emphasis of using the specific model is the opportunity to produce a target model that may be composed of parts from different experts’ designs. We first experimentally evaluate MoTrans-BDI on twelve handmade UML2REL model transformation problems. All types of agents are able to produce perfect target models compared to human experts’ collaboratively-produced target models. Second, we empirically evaluate MoTrans-BDI’s proposal in terms of response time on Star Schema Benchmark (SSB) queries. An application of MoTrans-BDI in the case of UML2REL transformation is performed to stress and highlight the transformation process steps.

Implementing QVT-R via semantic interpretation in UML-RSDS

The QVT-Relations (QVT-R) model transformation language is an OMG standard notation for model transformation specification. It is highly declarative and supports (in principle) bidirectional (bx) transformation specification. However, there are many unclear or unsatisfactory aspects to its semantics, which is not precisely defined in the standard. UML-RSDS is an executable subset of UML and OCL. It has a precise mathematical semantics and criteria for ensuring correctness of applications (including model transformations) by construction. There is extensive tool support for verification and for production of 3GL code in multiple languages (Java, C#, C++, C, Swift and Python). In this paper, we define a translation from QVT-R into UML-RSDS, which provides a logically oriented semantics for QVT-R, aligned with the RelToCore mapping semantics in the QVT standard. The translation includes variation points to enable specialised semantics to be selected in particular transformation cases. The translation provides a basis for verification and static analysis of QVT-R specifications and also enables the production of efficient code implementations of QVT-R specifications. We evaluate the approach by applying it to solve benchmark examples of bx.

A comparison of quality flaws and technical debt in model transformation specifications

The quality of model transformations (MT) has high impact on model-driven engineering (MDE) software development approaches, because of the central role played by transformations in MDE for refining, migrating, refactoring and other operations on models.For programming languages, a popular paradigm for code quality is the concept of technical debt (TD), which uses the analogy that quality flaws in code are a debt burden carried by the software, which must either be ‘redeemed’ by expending specific effort to remove its flaws, or be tolerated, with ongoing additional costs to maintenance due to the flaws.Whilst the analysis and management of quality flaws and TD in programming languages has been investigated in depth over several years, less research on the topic has been carried out for model transformations. In this paper we investigate the characteristics of quality flaws and technical debt in model transformation languages, based upon systematic analysis of over 100 transformation cases in four leading MT languages.Based on quality flaw indicators for TD, we identify significant differences in the level and kinds of technical debt in different MT languages, and we propose ways in which TD in MT can be reduced and managed.

Model driven transformation development (MDTD): An approach for developing model to model transformation

Abstract Context In the Model Driven Development (MDD) approach, model transformations are responsible for the semi-automation of software development process converting models between different abstraction levels. The development of model transformations involves a complexity inherent to the transformation domain, in addition to the complexity of software development in general. Therefore, the construction of model transformations requires software engineering feature such as processes and languages to facilitate its development and maintenance. Objective This paper presents a framework to develop unidirectional relational model transformation using the MDD approach itself, which integrates: (i) a software development process suitable for the model transformation domain (ii) a Domain specific language for transformation modeling (iii) a transformation chain, to (semi) automate the proposed process, and (iv) a development environment to support it. Methods The proposal systematizes the development of model transformation, following the MDD principles. An iterative and incremental process guides transformation development from requirement specification to transformation codification. The proposal has been evaluated through a case study and a controlled experiment. Results The framework enables model transformation specification at a high abstraction level and (semi) automatically transforms it into models at a low abstraction level until the transformation code. The results of the case study showed that people with different levels of knowledge of MDD, or without experience in transformation languages, were able to develop transformations through the framework and generated executable code. Conclusions The framework integrates the essential elements involved in the development of model transformation and enables the abstraction of technological details. The results of the case study and controlled experiment showed the feasibility of the proposal and its use in dealing with the complexity involved in model transformation development.

Agile validation of model transformations using compound F-Alloy specifications

• We introduce Hybrid Analysis as an efficient way to validate F-Alloy specifications. • We propose an F-Alloy extension to specify compound model transformations. • We describe VBV, a domain specific validation process for model transformations. • VBV is based on compound model transformations. Model transformations play a key role in model driven software engineering approaches. Validation of model transformations is crucial for the quality assurance of software systems to be constructed. The relational logic based specification language Alloy and its accompanying tool the Alloy Analyzer have been used in the past to validate properties of model transformations. However Alloy based analysis of transformations suffers from several limitations. On one hand, it is time consuming and does not scale well. On the other hand, the reliance on Alloy, being a formal method, prevents the effective involvement of domain experts in the validation process which is crucial for pinpointing domain pertinent errors. Those limitations are even more severe when it comes to transformations whose input and/or output are themselves transformations (called compound transformations) because they are inherently more complex. To tackle the performance and scalability limitations, in previous work, we proposed an Alloy-based Domain Specific Language (DSL), called F-Alloy, that is tailored for model transformation specifications. Instead of pure analysis based validation, F-Alloy speeds up the validation of model transformations by applying a hybrid strategy that combines analysis with interpretation. In this paper, we formalize the notion of “hybrid analysis” and further extended it to also support efficient validation of compound transformations. To enable the effective involvement of domain experts in the validation process, we propose in this paper a new approach to model transformation validation, called Visualization-Based Validation (briefly VBV). Following VBV, representative instances of a to-be-validated model transformation are automatically generated by hybrid analysis and shown to domain experts for feedback in a visual notation that they are familiar with. We prescribe a process to guide the application of VBV to model transformations and illustrate it with a benchmark model transformation.

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.

Model-Transformation Design Patterns

This paper defines a catalogue of patterns for the specification and design of model transformations, and provides a systematic scheme and classification of these patterns, together with pattern application examples in leading model transformation languages such as ATL, QVT, GrGen.NET, and others. We consider patterns for improving transformation modularization and efficiency and for reducing data storage requirements. We define a metamodel-based formalization of model transformation design patterns, and measurement-based techniques to guide the selection of patterns. We also provide an evaluation of the effectiveness of transformation patterns on a range of different case studies.

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 Novel Executable Modeling Approach for System-of-Systems Architecture

A novel executable modeling approach is proposed for system-of-systems architecture by taking full advantage of the Department of Defense Architecture Framework (DoDAF) Meta-model (DM2) and defining the common model transformation specification at the metamodel level. This methodology provides more flexibility and adaptability for the automated construction of executable models directly from the architectural data rather than from static models. More specifically, the architectural data metamodel is first established to guide architectural data modeling of core data elements and associations in DM2 as the common and consistent data dictionary for architecture modeling, while the executable formalism metamodel is designed to formally define executable models. Then, the mapping rules between both metamodels are presented as the common transformation specification regardless of which modeling language or methodology is employed in developing architectural descriptions. Finally, eXtensible Markup Language (XML) technology, like XML schema languages and eXtensible Stylesheet Language specifications, is discussed to facilitate the automated transformation of executable models from architectural instance data. The feasibility of the proposed approach is illustrated using a published example where colored Petri net (CPN) is used as the executable formalism.

Model Checking Healthcare Workflows Using Alloy

Workflows are used to organize business processes, and workflow management tools are used to guide users in which order these processes should be performed. These tools increase organizational efficiency and enable users to focus on the tasks and activities rather than complex processes. Workflow models represent real life workflows and consist mainly of a graph-based structure where nodes represent tasks and arrows represent the flows between these tasks. From workflow models, one can use model transformations to generate workflow software. The correctness of the software is dependent on the correctness of the models, hence verification of the models against certain properties like termination, liveness and absence of deadlock are crucial in safety critical domains like healthcare. In previous works we presented a formal diagrammatic framework for workflow modelling and verification which uses principles from model-driven engineering. The framework uses a metamodelling approach for the specification of workflow models, and a transformation module which creates DiVinE code used for verification of model properties. In this paper, in order to improve the scalability and efficiency of the verification, we introduce a new encoding of the workflow models using the Alloy specification language, and we present a bounded verification approach for workflow models based on relational logic. We automatically translate the workflow metamodel into a model transformation specification in Alloy. Properties of the workflow can then be verified against the specification; especially, we can verify properties about loops. We use a running example to explain the metamodelling approach and the encoding to Alloy.

Correct-by-construction synthesis of model transformations using transformation patterns

Model transformations are an essential part of model-based development approaches, such as Model-driven Architecture (MDA) and Model-driven Development (MDD). Model transformations are used to refine and abstract models, to re-express models in a new modelling language, and to analyse, refactor, compare and improve models. Therefore, the correctness of model transformations is critically important for successful application of model-based development: software developers should be able to rely upon the correct processing of their models by transformations in the same way that they rely upon compilers to produce correct executable versions of their programs. In this paper, we address this problem by defining standard structures for model transformation specifications and implementations, which serve as patterns and strategies for constructing a wide range of model transformations. These are incorporated into a tool-supported process which automatically synthesises implementations of model transformations from their specifications, these implementations are correct-by-construction with respect to their specifications.

Constraint-based specification of model transformations

Model transformations are a central element of model-driven development (MDD) approaches. The correctness, modularity and flexibility of model transformations is critical to their effective use in practical software development. In this paper we describe an approach for the automated derivation of correct-by-construction transformation implementations from high-level specifications. We illustrate this approach on a range of model transformation case studies of different kinds (re-expression, refinement, quality improvement and abstraction transformations) and describe ways in which transformations can be composed and evolved using this approach.

Bridging the gap between formal semantics and implementation of triple graph grammars

The correctness of model transformations is a crucial element for model-driven engineering of high-quality software. A prerequisite to verify model transformations at the level of the model transformation specification is that an unambiguous formal semantics exists and that the implementation of the model transformation language adheres to this semantics. However, for existing relational model transformation approaches, it is usually not really clear under which constraints particular implementations really conform to the formal semantics. In this paper, we will bridge this gap for the formal semantics of triple graph grammars (TGG) and an existing efficient implementation. While the formal semantics assumes backtracking and ignores non-determinism, practical implementations do not support backtracking, require rule sets that ensure determinism, and include further optimizations. Therefore, we capture how the considered TGG implementation realizes the transformation by means of operational rules, define required criteria, and show conformance to the formal semantics if these criteria are fulfilled. We further outline how static and runtime checks can be employed to guarantee these criteria.

Formal Specification of Model Transformations by Triple Graph Grammars with Application Conditions

Triple graph grammars are a successful approach to describe exogenous model transformations, i.e. transformations between models conforming to differ- ent meta-models. Source and target models are related by some connection part, triple rules describe the simultaneous construction of these parts, and forward and backward rules can be derived modeling the forward and backward model transfor- mations. As shown already for the specification of visual models by typed attributed graph transformation, the expressiveness of the approach can be enhanced signifi- cantly by using application conditions, which are known to be equivalent to first order logic on graphs. In this paper, we extend triple rules with a specific form of application conditions, which enhance the expressiveness of formal specifications for model transforma- tions. We show how to extend results concerning information preservation, termi- nation, correctness, and completeness of model transformations to the case with application conditions. We illustrate our approach and results with a model trans- formation from statecharts to Petri nets.

Specification and Verification of Model Transformations

Model transformations are a key concept within model driven development and there is an enormous need for suitable formal analysis techniques for model transformations, in particular with respect to behavioural equivalence of source models and their corresponding target models. For this reason, we discuss the general challenges that arise for the specification and verification of model transformations and present suitable formal techniques that are based on graph transformation. In this context, triple graph grammars show many benefits for the specification process, e.g. modelers can work on an intuitive level of abstraction and there are formal results for syntactical correctness, completeness and efficient execution. In order to verify model transformations with respect to behavioural equivalence we apply well-studied techniques based on the double pushout approach with borrowed context, for which the model transformations specified by triple graph transformation rules are flattened to plain (in-situ) graph transformation rules. The potential and adequateness of the presented techniques are demonstrated by an intuitive example, for which we show the correctness of the model transformation with respect to bisimilarity of source and target models.

Guest editorial to the special section on model transformation

Models have become essential for dealing with the numerous aspects involved in developing and maintaining complex IT systems. Models assist in capturing the relevant aspects of a system from a given perspective and at a precise level of abstraction. Model transformation represents a key activity in model-driven engineering by supporting the definition and implementation of the operations on models, which can provide a chain that enables the automated development of a system from its correspondingmodels. Furthermore, amodel transformation may also be considered a model in its own right, which presents opportunities for higher-order transformations, i.e., transformations that manipulate models representing other model transformations. There exist several approaches that support model transformation specification, implementation, and execution, which are beginning to be used by model engineers, endusers, and practitioners. However, model transformations need specialized support in several areas in order to realize their full potential. The challenges go beyond the need to have specific languages to represent model transformations; it is also necessary to understand foundational principles, such as the key concepts and operators supporting model transformation languages, their semantics, and their structuring