Towards a General Composition Semantics for Rule-Based Model Transformation (original) (raw)
Related papers
Module superimposition: a composition technique for rule-based model transformation languages
Software & Systems Modeling, 2010
As the application of model transformation becomes increasingly commonplace, the focus is shifting from model transformation languages to the model transformations themselves. The properties of model transformations, such as scalability, maintainability and reusability, have become important. Composition of model transformations allows for the creation of smaller, maintainable and reusable transformation definitions that together perform a larger transformation. This paper focuses
A Comparison of Rule Inheritance in Model-to-Model Transformation Languages
Lecture Notes in Computer Science, 2011
Although model transformations presumably play a major role in Model-Driven Engineering, reuse mechanisms such as inheritance have received little attention so far. In this paper, we propose a comparison framework for rule inheritance in declarative model-to-model transformation languages, and provide an in-depth evaluation of three prominent representatives thereof, namely ATL, ETL (declarative subsets thereof), and TGGs. The framework provides criteria for comparison along orthogonal dimensions, covering static aspects, which indicate whether a set of inheriting transformation rules is well-formed at compiletime, and dynamic aspects, which describe how inheriting rules behave at run-time. The application of this framework to dedicated transformation languages shows that, while providing similar syntactical inheritance concepts, they exhibit different dynamic inheritance semantics and offer basic support for checking static inheritance constraints, only.
Composition Techniques for Rule-Based Model Transformation Languages
Lecture Notes in Computer Science, 2008
Model transformation languages have matured to a point where people have started experimenting with model transformation definitions themselves in addition to the language they are written in. In addition to the transformation language properties, the properties of model transformation definitions themselves become important, such as scalability, maintainability and reusability. Composition of model transformations allows for the creation of smaller, maintainable
Surveying Rule Inheritance in Model-to-Model Transformation Languages
The Journal of Object Technology, 2012
Model transformations play a significant role in Model-Driven Engineering. However, their reuse mechanisms have yet to receive much attention. In this paper, we propose a comparison framework for rule inheritance in model-to-model transformation languages, and provide an in-depth evaluation of prominent representatives of imperative, declarative and hybrid transformation languages. The framework provides criteria for comparison along orthogonal dimensions, covering static aspects, which indicate whether a set of inheriting transformation rules is well-formed at compile-time, and dynamic aspects, which describe how inheriting rules behave at run-time. The application of this framework to dedicated transformation languages shows that, while providing similar syntactical inheritance concepts, they exhibit different dynamic inheritance semantics and offer basic support for checking static inheritance semantics, only.
Lecture Notes in Computer Science, 2009
Practitioners of model-driven engineering usually find that producing model transformations still requires much effort. The Model Transformation By-Example (MTBE) approach softens this problem by means of the automated creation of model transformations from pairs of source and target model examples. However, the current techniques and tools for MTBE are limited in the sense that they can only produce transformations rules that are limited to just one element in some of the patterns. In addition, some transformation languages cannot directly represent many-to-many transformation rules. To overcome both limitations, this paper presents an MTBE algorithm, that can generates many-to-many rules in several transformation languages even if the transformation language cannot directly represent this kind of rules. In particular, the implementation of this algorithm with the ATL language is available for practitioners. Finally, the paper compares this algorithm with existing techniques for MTBE.
Implementing a practical declarative logic-based model transformation engine
Proceedings of the 2007 ACM symposium on Applied computing - SAC '07, 2007
Declarative approaches to specifying model-model transformation are an attractive approach because they can offer implicit source model traversal, automatic traceability management, implicit target object creation, and implicit rule ordering. However, when proposing such a declarative logic-based transformation language, there are two common objections. One is programmer unfamiliarity with declarative style, and the other is that of perceived performance problems. In this paper we address these issues, discussing the design of specific features of the Tefkat transformation engine intended to facilitate writing and debugging declarative transformation specifications, and describing important implementation techniques used to avoid performance problems.
The design of a language for model transformations
Software & Systems Modeling, 2006
Model-driven development of software systems envisions transformations applied in various stages of the development process. Similarly, the use of domain-specific languages also necessitates transformations that map domain-specific constructs into the constructs of an underlying programming language. Thus, in these cases, the writing of transformation tools becomes a first-class activity of the software engineer. This paper introduces a language that was designed to support implementing highly efficient transformation programs that perform model-tomodel or model-to-code translations. The language uses the concepts of graph transformations and metamodeling, and is supported by a suite of tools that allow the rapid prototyping and realization of transformation tools.
Selective Traceability for Rule-Based Model-to-Model Transformations
Proceedings of the 15th ACM SIGPLAN International Conference on Software Language Engineering
Model-to-model (M2M) transformation is a key ingredient in a typical Model-Driven Engineering workflow and there are several tailored high-level interpreted languages for capturing and executing such transformations. While these languages enable the specification of concise transformations through task-specific constructs (rules/mappings, bindings), their use can pose scalability challenges when it comes to very large models. In this paper, we present an architecture for optimising the execution of model-to-model transformations written in such a language, by leveraging static analysis and automated program rewriting techniques. We demonstrate how static analysis and dependency information between rules can be used to reduce the size of the transformation trace and to optimise certain classes of transformations. Finally, we detail the performance benefits that can be delivered by this form of optimisation, through a series of benchmarks performed with an existing transformation language (Epsilon Transformation Language-ETL) and EMF-based models. Our experiments have shown considerable performance improvements compared to the existing ETL execution engine, without sacrificing any features of the language. CCS Concepts: • Software and its engineering → Modeldriven software engineering.
ATC: A Low-Level Model Transformation Language
Proceedings of the 2nd International Workshop on Model-Driven Enterprise Information Systems, 2006
Model Transformations constitute a key component in the evolution of Model Driven Software Development (MDSD). MDSD tools base their full potential on transformation specifications between models. Several languages and tools are already in production, and OMG's MDA is currently undergoing a standardization process of these specifications. In this paper, we present Atomic Transformation Code (ATC), an imperative low-level model transformation language which decouples user transformation languages from the underlying transformation engine. Therefore work invested on this engine is protected against variations on the high-level transformation languages supported. This approach can ease the adoption of QVT and other language initiatives. Also it provides MDA modeling tools with a valuable benefit by supporting the seamless integration of a variety of transformation languages simultaneously.
A Domain Specific Transformation Language
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.