Target Metamodel Research Articles

Towards Automation of the FORM/BCS Method

The software industry is facing more complex computer systems, with short development and sustainability issues. To deliver good software with these constraints, software reuse has become a central concept for minimizing design and realization costs. This study improves upon Feature-Oriented Reuse Method with Business Component Semantics (FORM/BCS), a software development method that produces adaptable architectures from reusable domain components. This is a promising method for reusable software assets and model creation. The objective of the FORM/BCS is to bring the industrial production chain to the software. This study proposes a model to automatically transform the FORM/BCS business subsystem component into a process business component. Two metamodels for business subsystems and process business components were developed. In addition, this study establishes correspondences between the source metamodel and target metamodel classes, transformation rules, and the instance of the source metamodel and generates the target metamodel instance. Detailed findings can help practitioners reduce software design costs and development time, and contribute to the advancement of knowledge in software engineering.

Model-driven architecture: generating models from Symfony framework

The web application development industry is constantly growing due to the extensive use of web applications in different devices, most of them run on Android, iOS, and Windows Phone operating systems. However, the development of applications designed for platforms requires more concerns such as code efficiency, interaction with devices, and speed of market penetration. The model-driven approach (MDA) combined with unified modeling language (UML) could provide abstraction and automation for software developers. This paper presents an MDA approach for the development of web applications based on the Symfony framework, UML modeling, model transformation, and then automatic code generation in order to facilitate and accelerate the development of web applications. The first step of this work is to establish the metamodel of Symfony framework and the metamodel of UML class diagram. In the second step, the various transformation rules between the source and target metamodels are first defined. Atlas transformation language (ATL) implements these rules. The result of this transformation is a platform-specific model (PSM) represented by Ecore language. The generated PSM model represents the input model of model-to-code (M2C) transformation for generating the code of web applications. To validate this work, we have implemented a case study.

A query-retyping approach to model transformation co-evolution

In rule-based approaches, a model transformation definition tells how an instance of a source metamodel should be transformed to an instance of a target metamodel. As these metamodels undergo changes, model transformations defined over these metamodels may get out of sync. Restoring conformance between model transformations and the metamodels is a complex and error-prone task. In this paper, we propose a formal approach to automatically co-evolve model transformations according to the evolution of the metamodels. The approach is based on encoding the model transformation definition as a query-retyping combination and the evolution of the metamodels as applications of graph transformation rules. These rules are used to obtain an evolved query over the evolved metamodel together with a new retyping from the target metamodel. We will identify the criteria which need to be fulfilled in order to make this automatic co-evolution possible. We provide a tool support for this procedure, in which, from a traceability model that represents the original model transformation definition, we derive a co-evolved traceability model that represents the evolved transformation definition. Moreover, we use a case study to evaluate the approach with a set of commonly performed metamodel evolutions.

On the value of quality attributes for refactoring ATL model transformations: A multi-objective approach

Abstract Context Model transformations play a fundamental role in Model-Driven Engineering (MDE) as they are used to manipulate models and to transform them between source and target metamodels. However, model transformation programs lack significant support to maintain good quality which is in contrast to established programming paradigms such as object-oriented programming. In order to improve the quality of model transformations, the majority of existing studies suggest manual support for the developers to execute a number of refactoring types on model transformation programs. Other recent studies aimed to automate the refactoring of model transformation programs, mostly focusing on the ATLAS Transformation Language (ATL), by improving mainly few quality metrics using a number of refactoring types. Objective In this paper, we propose a novel set of quality attributes to evaluate refactored ATL programs based on the hierarchical quality model QMOOD. Method We used the proposed quality attributes to guide the selection of the best refactorings to improve ATL programs using multi-objective search. Results We validate our approach on a comprehensive dataset of model transformations. The statistical analysis of our experiments on 30 runs shows that our automated approach recommended useful refactorings based on a benchmark of ATL transformations and compared to random search, mono-objective search formulation, a previous work based on a different formulation of multi-objective search with few quality metrics, and a semi-automated refactoring approach not based on heuristic search. Conclusion All these existing studies did not use our QMOOD adaptation for ATL which confirms the relevance of our quality attributes to guide the search for good refactoring suggestions.

Automated Reuse of Model Transformations through Typing Requirements Models

Model transformations are key elements of model-driven engineering, where they are used to automate the manipulation of models. However, they are typed with respect to concrete source and target meta-models, making their reuse for other (even similar) meta-models challenging. To improve this situation, we propose capturing the typing requirements for reusing a transformation with other meta-models by the notion of a typing requirements model (TRM). A TRM describes the prerequisites that a model transformation imposes on the source and target meta-models to obtain a correct typing. The key observation is that any meta-model pair that satisfies the TRM is a valid reuse context for the transformation at hand. A TRM is made of two domain requirement models (DRMs) describing the requirements for the source and target meta-models, and a compatibility model expressing dependencies between them. We define a notion of refinement between DRMs and see meta-models as a special case of DRM. We provide a catalogue of valid refinements and describe how to automatically extract a TRM from an ATL transformation. The approach is supported by our tool TOTEM. We report on two experiments—based on transformations developed by third parties and meta-model mutation techniques—validating the correctness and completeness of our TRM extraction procedure and confirming the power of TRMs to encode variability and support flexible reuse.

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.

P.1.i.039 - The analysis of TMS brain mapping of plastic changes in scapular-arm replantation patients

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.

Transforming an enterprise model into a use case model in business process systems

One of the responsibilities of requirements engineering is to transform stakeholder requirements into system and software requirements. For enterprise systems, this transformation must consider the enterprise context where the system will be deployed. Although there are some approaches for detailing stakeholder requirements, some of them even considering the enterprise context, this task is executed manually. Based on model-driven engineering concepts, this study proposes a semi-automatic transformation from an enterprise model to a use case model. The enterprise model is used as a source of information about the stakeholder requirements and domain knowledge, while the use case model is used as software requirements model. This study presents the source and target metamodels, a set of transformation rules, and a tool to support the transformation. An experiment analyzes the use of the proposed transformation to investigate its benefits and if it can be used in practice, from the point of view of students in the context of a requirements refinement. The results indicate that the approach can be used in practice, as it did not influence the quality of the generated use cases. However, the empirical analysis does not indicate benefits of using the transformation, even if the qualitative results were positive.

View-based model-driven software development with ModelJoin

Fragmentation of information across instances of different metamodels poses a significant problem for software developers and leads to a major increase in effort of transformation development. Moreover, compositions of metamodels tend to be incomplete, imprecise, and erroneous, making it impossible to present it to users or use it directly as input for applications. Customized views satisfy information needs by focusing on a particular concern, and filtering out information that is not relevant to this concern. For a broad establishment of view-based approaches, an automated solution to deal with separate metamodels and the high complexity of model transformations is necessary. In this paper, we present the ModelJoin approach for the rapid creation of views. Using a human-readable textual DSL, developers can define custom views declaratively without having to write model transformations or define a bridging metamodel. Instead, a metamodel generator and higher-order transformations create annotated target metamodels and the appropriate transformations on-the-fly. The resulting views, which are based on these metamodels, contain joined instances and can effectively express concerns unforseen during metamodel design. We have applied the ModelJoin approach and validated the textual DSL in a case study using the Palladio Component Model.

A model driven engineering process of platform neutral agents for ambient intelligence devices

Ambient intelligence (AmI) systems are now considered a promising approach to assist people in their daily life. AmI proposes the development of context aware systems equipped with devices that can recognize your context and act accordingly. Agents provide an effective way to develop such systems since agents are reactive, proactive and exhibit an intelligent and autonomous behavior. However, current agent approaches do not adequately fulfill the requirements posed by AmI systems. From a modeling point of view, the aim should be to help in the design by providing adequate tools that assist in the development of important properties of AmI systems, such as context-awareness; and from an implementation point of view, agent technologies must be adapted to the diversity of AmI devices and communication technologies. As a solution to these issues we propose a Model driven engineering process, which supports the automatic generation of agent-based AmI systems. The source metamodel is PIM4Agents, a general purpose agent metamodel that we have adapted to support the explicit modeling of context aware systems, and the target metamodel is Malaca, an aspect-oriented agent architecture. Aspect-orientation makes Malaca platform-neutral for FIPA compliant agent platforms, simplifying the model driven process. The solution generates MalacaTiny agents, an implementation of Malaca that is able to run in AmI devices. We have evaluated the convenience of applying a model driven approach by measuring the degree of automation of our process and we have evaluated MalacaTiny for mobile phones by assessing different parameters, related to the scarcity of resources in AmI systems. All the results obtained are satisfactory.

Toolchain Based on MDE for the Transformation of AADL Models to Timed Automata Models

In this work, we propose an approach for the verification of the AADL architecture. This approach is based on Model Driven Engineering (MDE) and assisted by a toolchain. Indeed, we define a source meta-model for AADL and a target meta-model for the timed automata formalism; we define a transformation process in two steps: the first is a Model2 Model transformation which takes an AADL Model and produces the corresponding timed automata model. The second transformation is a Model2 Text transformation which takes a timed automata model and generates a text in ta-format code. This code is accepted by the Uppaal toolbox. A case study has been developed to show the feasibility and validity of the proposed approach.

GReTL: an extensible, operational, graph-based transformation language

This article introduces the graph-based transformation language GReTL. GReTL is operational, and transformations are either specified in plain Java using the GReTL API or in a simple domain-specific language. GReTL follows the conception of incrementally constructing the target metamodel together with the target graph. When creating a new metamodel element, a set-based semantic expression is specified that describes the set of instances that have to be created in the target graph. This expression is defined as a query on the source graph. GReTL is a kernel language consisting of a minimal set of operations, but it is designed for being extensible. Custom higher-level operations can be built on top of the kernel operations easily. After a description of the foundations of GReTL, its most important elements are introduced along with a transformation example in the field of metamodel integration. Insights into the design of the GReTL API are given, and a convenience copy operation is implemented to demonstrate GReTL's extensibility.

Harvesting models from web 2.0 databases

Data rather than functionality are the sources of competitive advantage for Web2.0 applications such as wikis, blogs and social networking websites. This valuable information might need to be capitalized by third-party applications or be subject to migration or data analysis. Model-Driven Engineering (MDE) can be used for these purposes. However, MDE first requires obtaining models from the wiki/blog/website database (a.k.a. model harvesting). This can be achieved through SQL scripts embedded in a program. However, this approach leads to laborious code that exposes the iterations and table joins that serve to build the model. By contrast, a Domain-Specific Language (DSL) can hide these “how” concerns, leaving the designer to focus on the “what”, i.e. the mapping of database schemas to model classes. This paper introduces Schemol, a DSL tailored for extracting models out of databases which considers Web2.0 specifics. Web2.0 applications are often built on top of general frameworks (a.k.a. engines) that set the database schema (e.g., MediaWiki, Blojsom). Hence, table names offer little help in automating the extraction process. In addition, Web2.0 data tend to be annotated. User-provided data (e.g., wiki articles, blog entries) might contain semantic markups which provide helpful hints for model extraction. Unfortunately, these data end up being stored as opaque strings. Therefore, there exists a considerable conceptual gap between the source database and the target metamodel. Schemol offers extractive functions and view-like mechanisms to confront these issues. Examples using Blojsom as the blog engine are available for download.

Reusable model transformations

Model transformations written for an input metamodel may often apply to other metamodels that share similar concepts. For example, a transformation written to refactor Java models can be applicable to refactoring UML class diagrams as both languages share concepts such as classes, methods, attributes, and inheritance. Deriving motivation from this example, we present an approach to make model transformations reusable such that they function correctly across several similar metamodels. Our approach relies on these principal steps: (1) We analyze a transformation to obtain an effective subset of used concepts. We prune the input metamodel of the transformation to obtain an effective input metamodel containing the effective subset. The effective input metamodel represents the true input domain of transformation. (2) We adapt a target input metamodel by weaving it with aspects such as properties derived from the effective input metamodel. This adaptation makes the target metamodel a subtype of the effective input metamodel. The subtype property ensures that the transformation can process models conforming to the target input metamodel without any change in the transformation itself. We validate our approach by adapting well known refactoring transformations (Encapsulate Field, Move Method, and Pull Up Method) written for an in-house domain-specific modeling language (DSML) to three different industry standard metamodels (Java, MOF, and UML).

A transformation contract to generate aspects from access control policies

Access control is an important security issue. It has been addressed since the late 1960s in the early time-sharing computer systems. Many access control models have been proposed since than but of particular interest is Ferraiolo and Khun's role-based access control model (RBAC). It is a simple and yet general model which has been deeply studied and applied both in industry and in academia. A variety of industrial standards have been proposed based on this model. Generating code for an access control policy is an interesting challenge. Understanding access control as a non-functional concern that cross-cuts the functional part of a system raises difficulties quite suitable for a solution based on aspect-oriented programming. In this paper, we address the problems of specification and validation of code generation for access control policies targeting an aspect-based infra-structure. We propose an MDA approach. The code generator is a transformation from SecureUML, an RBAC-based modeling language, to the language Aspects for Access Control (AAC), an aspect-oriented modeling language proposed in this paper. Metamodels are used to represent the languages and to specify the transformation. A metamodel is used to represent the abstract syntax of a language and the constraints that a given instance model of the metamodel must fulfill. We also use a metamodel to specify the code generator. This transformation metamodel, together with all the constraints, that is, from both languages and those constraints regarding the merge of the two languages, we call a transformation contract. It merges and conservatively extends the source and target metamodels of the model transformation it represents. In the context of code-generation for access control policies, the transformation contract specifies the relationships between the abstract syntaxes of SecureUML and AAC and constrains the two languages. The validation of the code generator also uses the transformation contract. For a given access control policy and aspect, represented as instances of the appropriate metamodels, with aspects produced by the code generator, the constraints of the transformation contract must hold. We have prototyped a transformer from SecureUML to aspects on top of ITP/OCL, an OCL interpreter that automatically validates the generated aspect code by applying the constraints of the transformation contract.

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.

From UML/SPT models to schedulability analysis: approach and a prototype implementation using ATL

Model Driven Architecture (MDA) is a software development approach promoted by the OMG. MDA is based on two key concepts, models and model transformations. Several kinds of models are generally used throughout the development process to specify a software system and to support its analysis and validation. UML and its extensions, such as the UML profile for real-time systems (UML/SPT), are commonly used to define the structure and the behavior of software systems while other models, such as performance models or schedulability models, are more suitable for performance or schedulability analysis, respectively. In this paper we discuss a model transformation enabling the derivation of schedulability analysis models from UML/SPT models. As a proof of concepts, we present a prototype implementation of this model transformation using ATL. We provide a definition of the source and target metamodels using the metamodel specification language KM3 and we specify the transformation in an ATL module. We discuss the merits and limitations of our approach and of its implementation.

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.