Towards a Transformation Chain Modeling Language

Information & Software Technology, 2019

In the Model Driven Development (MDD) approach, model transformations are responsible for the semiautomation 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.

2015 IEEE 10th International Conference on Industrial and Information Systems (ICIIS), 2015

Software models play a significant role with the growth of software system development based on Model Driven Development (MDD) approach. Model transformations and compositions are the heart of MDD and allow the development of complex systems and their automated derivation. Moreover, software development of large and complex systems uses a collection of models, where model composition and decomposition are required. Various research studies have been done on specifying and executing MDD processes; however only a few of those have considered the validity of such transformations, thus safe composition and decomposition of models. This paper presents a general approach for model composition for the transformation from UML sequence diagrams to Coloured Petri Nets and validates the correctness of model composition using a mathematical proof. These transformations are based on formal rules, which have already been proven to be strongly consistent.

methods, 2002

MDA (Model Driven Architecture) attempts to solve some common problems of current software architectures to reduce the complexity of software development: i) separation of technology dependent concepts from the independent concepts, ii) automate the software development process, and iii) separation of domain, technology and technological concerns to avoid the confusions because of the combination of different types of concepts. MDA introduces two basic solutions to solve these problems: i) description of specialized modeling languages and ii) model transformations and mappings. Currently, the first concept (description of specialized modeling language) has been widely studied and there are general solutions and standards (Profiles [5] and MOF [12]). But the second solution has not been well studied yet and practical solutions depend on specific script languages, and the standards that include some kind of mapping proposal make an informal description of the mappings. We are going to introduce some solutions to express complex transformations where the source and target modeling structures are not limited to simple modeling elements.

Domain specific languages play an important role in model driven development, as they allow to model a system using modeling constructs carrying implicit semantics specific to a domain. Consequently, possibly many reusable, domain specific languages will emerge. Thereby, certain application areas, such as business process engineering, can be jointly covered by a number of conceptually related DSLs, that are similar in a sense of sharing semantically equal concepts. Although, a crucial role in being able to use, manage and integrate all these DSLs comes to model transformation languages with QVT as one of their most prominent representatives, existing approaches have not aimed at reaping benefit of these semantically overlapping DSLs in terms of providing abstraction mechanisms for shared concepts. Therefore, as opposed to a generalpurpose model transformation language sought after with the QVT-RFP, this work discusses the possibility of employing domain-specific model transformation languages. These are specifically tailored for defining transformations between metamodels sharing certain characteristics. In this context, the paper introduces a basic framework which allows generating the necessary tools to define and execute transformations written in such a domain-specific transformation language. To illustrate the approach, an example language will be introduced and its realization within the framework is shown.

Proceedings of the 6th International Workshop on Modelling, Simulation, Verification and Validation of Enterprise Information Systems, 2008

Model Driven Engineering(MDE) is a model-centric software development approach aims at improving the quality and productivity of software development processes. While some progresses in MDE have been made, there are still many obstacles in realizing the full benefits of model driven engineering. These obstacles include incompleteness in existing modeling notations, inadequate in tools support, and the lack of effective model transformation mechanism. This paper presents a new model driven engineering framework, which is based on a formal modeling notation-Z-based Object-Oriented Modeling notation (ZOOM). It includes a set of supporting tools aiming at delivering the benefits in practical applications of model driven engineering. In particularly, this proposal focuses on one key aspect of MDE-model transformation. A template based model transformation framework using Hierarchical Relational Meta-model (HRM) is introduced. This framework aims to provide a simple, effective, and practical way to define model transformations. The potential benefits of the proposed model transformation framework include: 1) readability and rigorousness of meta-model definitions; 2) simplicity of transformation definition; and 3) extensibility of transformation templates. The architecture and design of the framework is discussed and comparisons with related research work are provided to show the benefits of this framework.

Programming technologies have improved continuously during the last decades, but from an Information Systems perspective, some well-known problems associated to the design and implementation of an Information Systems persists. Object-Oriented Methods, Formal Specification Languages, Component-Based Software Production... This is just a very short list of technologies proposed to solve a very old and, at the same time, very wellknown problem: how to produce software of quality. Programming has been the key task during the last 40 years, and the results have not been successful yet. This work will explore the need of facing a sound software production process from a different perspective: the non-programming perspective, where by nonprogramming we mainly mean modeling. Instead of talking about Extreme Programming, we will introduce a Extreme Non-Programming (Extreme Modeling-Oriented) approach. We will base our ideas on the intensive work done during the last years, oriented to the objective of generating code from a higher-level system specification, normally represented as a Conceptual Schema. Nowadays, though, the hip around MDA has given a new push to these strategies. New methods propose sound model transformations which cover all the different steps of a sound software production process from an Information Systems Engineering point of view. This must include Organizational Modeling, Requirements Engineering, Conceptual Modeling and Model-Based Code Generation techniques. In this context, it seems that the time of Model Transformation Technologies is finally here…

International Journal of Computer Applications in Technology, 2008

Model-driven Software Engineering is one of the most focused research fields. Model processors automatically generate the lower level artefacts. Graph transformation is a widely used technique for model transformations. Especially visual model transformations can be expressed by graph transformations. This paper presents a visual control flow support of the Visual Modelling and Transformation System and discusses the principles of the constraint-driven validated model transformation. The presented approach helps to validate, preserve or guarantee certain model properties not only for individual transformation rules but also for the whole transformation.

Computer Languages, Systems & Structures, 2016

Model-driven engineering (MDE) is considered a well-established software development approach that uses abstraction to bridge the gap between the problem space and the software implementation. In MDE, many problems are solved using model transformation, which is a paradigm that manipulates high-level models to translate, evolve, or simulate them. However, the development of a model transformation for a specific problem is still a hard task. The main reason is the lack of a development process where transformations must be designed before implemented. Design patterns provide experiential reuse to software engineers when faced with recurring problems. Given their various contexts of application, model transformations may also benefit from design patterns. Although several studies have proposed design patterns for model transformation, there is still no accepted common language to express transformation patterns. Therefore, we propose a semi-formal way to describe model transformation design patterns that is independent from a specific transformation language and described in a practical way that is directly implementable by model engineers. This paper presents a catalog of 15 model transformation design patterns. We also demonstrate how it is possible to automatically generate excerpts of a model transformation in various languages given a design pattern. We conducted an initial survey to motivate the need for model transformation design patterns and a user study to validate the methodology we propose to solve problems as model transformations based on design patterns.

Domain specific languages (DSLs) allow domain experts to model parts of the system under development in a problem-oriented notation that is well-known in the respective domain. The introduction of a DSL is often accompanied the desire to transform its instances. Although the modeling language is domain specific, the transformation language used to describe modifications, such as model evolution or refactoring operations, on the underlying model, usually is a rather domain independent language nowadays. Most transformation languages use a generic notation of model patterns that is closely related to typed and attributed graphs or to object diagrams (the abstract syntax). A notation that reflects the transformed elements of the original DSL in its own concrete syntax would be strongly preferable, because it would be more comprehensible and easier to learn for domain experts. In this paper we present a transformation language that reuses the concrete syntax of a textual modeling language for hierarchical automata, which allows domain experts 1 to describe models as well as modifications of models in a convenient, yet precise manner. As an outlook, we illustrate a scenario where we generate transformation languages from existing textual languages.

Science of Computer Programming, 2008

In the context of Model Driven Engineering, models are the main development artifacts and model transformations are among the most important operations applied to models. A number of specialized languages have been proposed, aimed at specifying model transformations. Apart from the software engineering properties of transformation languages, the availability of high quality tool support is also of key importance for the industrial adoption and ultimate success of MDE. In this paper we present ATL: a model transformation language and its execution environment based on the Eclipse framework. ATL tools provide support for the major tasks involved in using a language: editing, compiling, executing, and debugging.