Model Transformation Language Research Articles

MODEL DRIVEN DEVELOPMENT OF SEMANTIC WEB ENABLED MULTI-AGENT SYSTEMS

Semantic Web evolution brought a new vision into agent research. The interpretation of this second generation web will be realized by autonomous computational entities, called agents, to handle the semantic content on behalf of their human users. Surely, Semantic Web environment has specific architectural entities and a different semantic which must be considered to model a Multi-agent System (MAS) within this environment. Hence, in this study, we introduce a MAS development process which supports the Semantic Web environment. Our approach is based on Model Driven Development (MDD) which aims to change the focus of software development from code to models. We first define an architecture for Semantic Web enabled MASs and then provide a MAS metamodel which consists of the first class meta-entities derived from this architecture. We also define a model transformation process for MDD of such MASs. We present a complete transformation process in which the source and the target metamodels, entity mappings between models and the implementation of the transformation for two different real MAS frameworks by using a well-known model transformation language are all included. In addition to the model-to-model transformation, the implementation of the model-to-code transformation is given as the last step of the system development process. The evaluation of the proposed development process by considering its use within the scope of a real commercial software project is also discussed.

Model transformations to bridge concrete and abstract syntax of web rule languages

This paper presents a solution to bridging the abstract and concrete syntax of a Web rule languages by using model transformations. Current specifications of Web rule languages such as Semantic Web Rule Language (SWRL) or RuleML define their abstract syntax (e.g., metamodel) and concrete syntax (e.g., XML schema) separately. Although the recent research in the area of Model-Driven Engineering (MDE) demonstrates that such a separation of two types of syntax is a good practice (due to the complexity of languages), one should also have tools that check validity of rules written in a concrete syntax with respect to the abstract syntax of the rule language. In this study, we use the REWERSE I1 Rule Markup Language (R2ML), SWRL, and Object Constraint Language (OCL), whose abstract syntax is defined by using metamodeling, while their textual concrete syntax is defined by using either XML/RDF schema or Extended Backus-Naur Form (EBNF) syntax. We bridge this gap by a bi-directional transformation defined in a model transformation language (ATLAS Transformation Language, ATL). This transformation allowed us to discover a number of issues in both web rule language metamodels and their corresponding concrete syntax, and thus make them fully compatible. This solution also enables for sharing web rules between different web rule languages.

Modularization of model transformations through a phasing mechanism

In recent years a great effort has been devoted to understanding the nature of model transformations. As a result, several mechanisms to improve model transformation languages have been proposed. Phasing has been mentioned in some works as a rule scheduling or organization mechanism, but without any detail. In this paper, we present a phasing mechanism in the context of rule-based transformation languages. We explain the structure and the behavior of the mechanism, and how it can be integrated in a language. We also analyze how the mechanism promotes modularity, internal transformation composition and helps to solve usual transformation problems. Besides, we show several examples of application to illustrate the usefulness of the mechanism.

ATL: A model transformation tool

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.

View Creation of Meta Models by Using Modified Triple Graph Grammars

Model-based software development is a hot topic of the software engineering community. Most activities in this area including the standardization efforts of the OMG are targeted towards the development of meta modeling tools, adaptable code generators, and model transformations tools. The needs for the specification of model views that simplify the definition of model transformation, abstract from details of specific modeling languages and tools or support the adaptation of generic modeling approaches to a specific domain are usually out of scope. This paper presents, therefore, a unified approach for the declarative definition of updatable model views. New interpretations of the well-known concept of triple graph grammars are used for that purpose which support, for the first time, the construction of non-materialized views. The adaptation of the presented approach to the world of the Model Driven Application development standards of the OMG and the recently finalized model transformation language QVT is under development.

Copying Subgraphs Within Model Repositories

The set of operations in state-of-the-art graph transformation tools allows one to conditionally create and remove nodes and edges from input graphs. Node attributes can be initialized or updated with information from other attributes, parameters or constants. These operations appear to be too restricted for expressing model refinements in a concise manner. More specifically, graph transformation lacks an operation for copying subgraphs (multiple connected nodes, including their attributes) to a new location in the host graph. This paper presents a case study that illustrates the need, a syntax and an informal semantics for such an operation. It also discusses how the operation was integrated in an existing graph transformation language. Finally, it indicates how our ongoing effort towards the implementation of a model transformation language based on graph transformation makes optimal reuse of evaluation code for existing language constructs.

A change propagating model transformation Language.

Model transformations are a key component in Model Driven Development, but most approaches only allow ‘one shot' transformations to be expressed. Change propagating model transformations are those which can make suitable updates to models after an initial transformation.

Rule-based modularization in model transformation languages illustrated with ATL

This paper studies ways for modularizing transformation definitions in current rule-based model transformation languages. Two scenarios are shown in which the modular units are identified on the basis of relations between source and target metamodels and on the base of generic transformation functionality. Both scenarios justify modularization by requiring adaptability and reusability in transformation definitions. To enable representation and composition of the identified units, a transformation language must provide proper modular constructs and mechanisms for their integration. We evaluate several implementations of the scenarios by applying different transformation techniques: usage of explicit and implicit rule calls, and usage of rule inheritance. ATLAS Transformation Language (ATL) is used to illustrate these implementations. The experience with these scenarios shows that current languages provide a reasonably full set of modular constructs but may have problems in handling some composition tasks.

On the interoperability of model-to-model transformation languages

Transforming models is a crucial activity in Model Driven Engineering (MDE). With the adoption of the OMG QVT standard for model transformation languages, it is anticipated that the experience in applying model transformations in various domains will increase. However, the QVT standard is just one possible approach for solving model transformation problems. In parallel with the QVT activity, many research groups and companies have been working on their own model transformation approaches and languages. It is important for software developers to be able to compare and select the most suitable languages and tools for a particular problem. This paper compares several model-to-model transformation languages as a step in the direction of gathering knowledge about the existing model transformation approaches. The focus is on the major language components (sublanguages and their features, execution tools, etc.) and how they are related. The major goal is to motivate the need for language interoperability and to explore options and obstacles for such interoperability. We propose a set of heuristics to reason about the problems that must be addressed when translators between languages have to be developed. These heuristics are applied on several examples. The experience from these examples shows that achieving a large degree of interoperability is difficult since some languages expose incompatible features. We managed to identify, however, cases where the interoperability between languages is feasible and brings certain benefits.

The model transformation language of the VIATRA2 framework

We present the model transformation language of the VIATRA2 framework, which provides a rule- and pattern-based transformation language for manipulating graph models by combining graph transformation and abstract state machines into a single specification paradigm. This language offers advanced constructs for querying (e.g. recursive graph patterns) and manipulating models (e.g. generic transformation and meta-transformation rules) in unidirectional model transformations frequently used in formal model analysis to carry out powerful abstractions.

Model transformations in MT

Model transformations are recognised as a vital aspect of Model Driven Development, but current approaches cover only a small part of the possible spectrum. In this paper I present the MT model transformation which shows how a QVT-like language can be extended with novel pattern matching constructs, how tracing information can be automatically constructed and visualized, and how the transformed model is pruned of extraneous elements. As MT is implemented as a DSL within the Converge language, this paper also demonstrates how a general purpose language can be embedded in a model transformation language, and how DSL development can aid experimentation and exploration of new parts of the model transformation spectrum.

Creating and reconciling diagrams after executing model transformations

In this paper we discuss how to create and update diagrams after the execution of a model transformation. This is achieved by creating an independent diagram reconciliation tool component that is based on a mapping language from the abstract syntax to the concrete syntax of a modeling language. This approach allows us to decouple model transformation from diagram handling in model transformation languages and tools.

A metamodeling language supporting subset and union properties

In this article, we describe successive versions of a metamodeling language using a set-theoretic formalization. We focus on language extension mechanisms, particularly on the relatively new subset and union properties of MOF 2.0 and the UML 2.0 Infrastructure. We use Liskov substitutability as the rationale for our formalization. We also show that property redefinitions are not a safe language extension mechanism. Each language version provides new features, and we note how such features cannot be mixed arbitrarily. Instead, constraints over the metamodel and model structures must be established. We expect that this article provides a better understanding of the foundations of MOF 2.0, which is necessary to define new extensions, model transformation languages and tools.

The design of a language for model transformations

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-to-model 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.

A Taxonomy of Model Transformation

This article proposes a taxonomy of model transformation, based on the discussions of a working group on model transformation of the Dagstuhl seminar on Language Engineering for Model-Driven Software Development. This taxonomy can be used, among others, to help developers in deciding which model transformation language or tool is best suited to carry out a particular model transformation activity.

Tool support for MOLA

The paper describes the MOLA Tool, which supports the model transformation language MOLA. MOLA Tool consists of two parts: MOLA definition environment and MOLA execution environment. MOLA definition environment is based on the GMF (Generic Modeling Framework) and contains graphical editors for metamodels and MOLA diagrams, as well as the MOLA compiler. The main component of MOLA execution environment is a MOLA virtual machine, which performs model transformations, using an SQL database as a repository. The execution environment may be used as a plug-in for Eclipse based modeling tools (e.g., IBM Rational RSA). The current status of the tool is truly academic.

A Weaving Framework for Model Transformation

Model transformations are the core and research focus of MDA(model driven architecture). Nowadays, there are many model transformation approaches and tools, and the heterogeneity of them causes that the model transformation code can't be reused easily and the cost of studying and using model transformation increases. To eliminate these shortcomings, inspired by model weaving technique, this paper proposes a QVT(model query/view/transformation)-based model transformation weaving framework named QMTW(QVT-based model transformation weaving framework). The conception, semantics, metamodel and syntax of QMTW added with a mapping from itself to the QVT Relation language are subscribed. A study case is provided to show how developers can use and take advantage of QMTW. The approach promotes the abstraction layer of model transformations, unites other model transformation languages, and supports QVT specification. So it eliminates the heterogeneity of model transformation partly. It is simple, specification-based and extensible.

OCLPrime - Environment and Language for Model Query, Views and Transformations

OCLPrime - Environment and Language for Model Query, Views and Transformations