Atlas Transformation Language Research Articles

ADM-Based Hybrid Model Transformation for Obtaining UML Models from PHP Code

In this paper, we present a hybrid-based model transformation, according to the Architecture Driven Modernization (ADM) approach, intended for getting UML (Unified Modeling Language) models from the PHP (Hypertext Preprocessor) code. This latter has been done by offering a tool support for automated generation of UML platform independent models from PHP ASTM (Abstract Syntax Tree Metamodel) representations, which are specific platform models. The model transformation rules are expressed in ATL (Atlas Transformation Language), which is a widely used model transformation language based on the hybrid approach. This work aims to fill the gap between the web-based applications maintenance, especially PHP-based implementations, and the model transformation processes in the ADM context.

The automatic creation of OLAP cube using an MDA approach

SummaryThe Model‐Driven Architecture (MDA) is an approach that aligns modeling and automation for software development. By applying such an approach to data warehouse (DW) projects, we can minimize a great deal of time and cost. Furthermore, most of OnLine Analytical Processing (OLAP) platforms seem to be like black boxes that provide wizards only to business intelligence developers to create and manipulate OLAP objects without allowing their sustainability and migration from a platform to another. That is why many works in the literature have proposed using the MDA approach in DW projects. However, most of them have mainly focused on the generation of the DW relational model from the conceptual one, and they overlooked the OLAP model and the cube implementation.To deal with this problem, we propose in this paper an MDA solution to automate the process of getting OLAP cube and its implementation through a set of metamodels and automatic transformations among them. In fact, the proposal generates the OLAP and DW relational models (PSMs) from the conceptual one, using also a PDM model that describes the target business intelligence platform. After that, the source code to create the cube is got from both PSM models. For this aim, we define a set of transformation rules implemented using the Atlas transformation language. Finally, a case study will be provided to validate our approach.

Toward a Generic Metamodel for Model Composition Using Transformation

One of the recent trends used in the iterative software development is a model presenting the system at the different levels of abstraction. In this context, model composition is assumed to take one or more models as its input and integrated output model. This paradigm is considered as a crucial activity in Model Driven Architecture (MDA). In this paper we present a generic metamodel for model composition and its farther implementation using Atlas Transformation language (ATL) in order to automate the composition process offered.

Full contract verification for ATL using symbolic execution

The Atlas Transformation Language (ATL) is currently one of the most used model transformation languages and has become a de facto standard in model-driven engineering for implementing model transformations. At the same time, it is understood by the community that enhancing methods for exhaustively verifying such transformations allows for a more widespread adoption of model-driven engineering in industry. A variety of proposals for the verification of ATL transformations have arisen in the past few years. However, the majority of these techniques are either based on non-exhaustive testing or on proof methods that require human assistance and/or are not complete. In this paper, we describe our method for statically verifying the declarative subset of ATL model transformations. This verification is performed by translating the transformation (including features like filters, OCL expressions, and lazy rules) into our model transformation language DSLTrans. As we handle only the declarative portion of ATL, and DSLTrans is Turing-incomplete, this reduction in expressivity allows us to use a symbolic-execution approach to generate representations of all possible input models to the transformation. We then verify pre-/post-condition contracts on these representations, which in turn verifies the transformation itself. The technique we present in this paper is exhaustive for the subset of declarative ATL model transformations. This means that if the prover indicates a contract holds on a transformation, then the contract’s pre-/post-condition pair will be true for any input model for that transformation. We demonstrate and explore the applicability of our technique by studying several relatively large and complex ATL model transformations, including a model transformation developed in collaboration with our industrial partner. As well, we present our ‘slicing’ technique. This technique selects only those rules in the DSLTrans transformation needed for contract proof, thereby reducing proving time.

Model Transformation with ATL into MDA from CIM to PIM Structured through MVC

Models transformation is the most important key in Model Driven Architecture (MDA). The first transformation in MDA is Computing Independent Model (CIM) to Platform Independent Model (PIM) transformation, the second is PIM to Platform Specific Model (PSM) transformation. This latter transformation deals the two less abstract levels, PIM and PSM, for that most researchers focused on this kind of transformation. Nevertheless, the top level of abstraction, CIM, and its transformation to PIM is rarely discussed in research topics. Our goal in this paper is to represent an approach that allows mastering transformation from CIM to PIM in accordance with MDA. Our method based on creating a good CIM level, using construction rules, to facilitate the transformation to PIM level. Next, our transformation rules, implemented with Atlas Transformation Language (ATL), ensure a semi-automatic transformation from CIM to PIM. Our approach conforms to MDA, because it allows considering the business dimension in the CIM level, and it allows modelling this latter level by using Business Process Model and Notation (BPMN), this latter is the OMG standard for modelling the business process. However, we founded on UML to model PIM level, because UML is advocated by MDA in PIM. Our proposal results a set of classes, organized according to the Model View Controller (MVC).

A Multidimensional Knowledge Model for Business Process Modeling

This work deals with the Business Process Management (BPM) and the Knowledge Management (KM). Indeed, the knowledge has a fairly important role in the business process modeling. This importance leads us to talk about the business knowledge notion which can be decomposed in many dimensions. In this paper, we first define business knowledge and its different dimensions. Then, we propose a multidimensional business knowledge model using a set of rules that formalize of these dimensions organized around the three-key perspectives of business processes: (i) process perspective, (ii) organizational perspective and (iii) informational perspective. In this way, we have used ATL (Atlas Transformation Language) language, as a means to implement the whole of formalization rules, so as to construct the target model starting from the business process model(s).

PTL: A model transformation language based on logic programming

In this paper we present a model transformation language based on logic programming. The language, called PTL (Prolog based Transformation Language), can be considered as a hybrid language in which ATL (Atlas Transformation Language)-style rules are combined with logic rules for defining transformations. ATL-style rules are used to define mappings from source models to target models while logic rules are used as helpers. The implementation of PTL is based on the encoding of the ATL-style rules by Prolog rules. Thus, PTL makes use of Prolog as a transformation engine. We have provided a declarative semantics to PTL and proved the semantics equivalent to the encoded program. We have studied an encoding of OCL (Object Constraint Language) with Prolog goals in order to map ATL to PTL. Thus a subset of PTL can be considered equivalent to a subset of ATL. The proposed language can be also used for model validation, that is, for checking constraints on models and transformations. We have equipped our language with debugging and tracing capabilities which help developers to detect programming errors in PTL rules. Additionally, we have developed an Eclipse plugin for editing PTL programs, as well as for debugging, tracing and validation. Finally, we have evaluated the language with several transformation examples as well as tested the performance with large models.

An Agent-Mediated Platform for Business Processes

Business processes have been widely becoming crucial assets of organisations across various industries and domains. The flexibility in dealing with changes when business processes are executed has significant impact on the success of an organisation's business operations, especially in the current ever-changing business environment. In this context, agent-based systems offer a promisingly powerful platform for business process execution. In this paper, the authors propose an agent-mediated platform for business processes with the aim to contribute to bridge the gap between business process management and agent-oriented development. They present a conceptual mapping method for a seamless transition from business process models in Business Process Modelling Notation (BPMN) to agent-oriented models in the Prometheus methodology, which is implemented using the ATLAS Transformation Language. The authors also developed an Eclipse-based plug-in which allows the designer to import BPMN models into the Eclipse-based Prometheus Design Tool.

Exploring AADL verification tool through model transformation

Architecture Analysis and Design Language (AADL) is often used to model safety-critical real-time systems. Model transformation is widely used to extract a formal specification so that AADL models can be verified and analyzed by existing tools. Timed Abstract State Machine (TASM) is a formalism not only able to specify behavior and communication but also timing and resource aspects of the system. To verify functional and nonfunctional properties of AADL models, this paper presents a methodology for translating AADL to TASM. Our main contribution is to formally define the translation rules from an adequate subset of AADL (including thread component, port communication, behavior annex and mode change) into TASM. Based on these rules, a tool called AADL2TASM is implemented using Atlas Transformation Language (ATL). Finally, a case study from an actual data processing unit of a satellite is provided to validate the transformation and illustrate the practicality of the approach.

A Component Model for Model Transformations

Model-driven engineering promotes an active use of models to conduct the software development process. In this way, models are used to specify, simulate, verify, test and generate code for the final systems. Model transformations are key enablers for this approach, being used to manipulate instance models of a certain modelling language. However, while other development paradigms make available techniques to increase productivity through reutilization, there are few proposals for the reuse of model transformations across different modelling languages. As a result, transformations have to be developed from scratch even if other similar ones exist. In this paper, we propose a technique for the flexible reutilization of model transformations. Our proposal is based on generic programming for the definition and instantiation of transformation templates, and on component-based development for the encapsulation and composition of transformations. We have designed a component model for model transformations, supported by an implementation currently targeting the Atlas Transformation Language (ATL). To evaluate its reusability potential, we report on a generic transformation component to analyse workflow models through their transformation into Petri nets, which we have reused for eight workflow languages, including UML Activity Diagrams, YAWL and two versions of BPMN.

Dynamic Adaptors to Support Model-Driven Interoperability and Enhance Sensing Enterprise Networks

In an increasingly complex environment, the enterprises of the future should become Sensing Enterprises, evidencing intelligent, dynamic and self-organizing capabilities for understanding and responding to the shifts that impact the networks they belong to. Reconfiguration and reprioritization of industrial processes, information models, and even terminology is now seen as a requirement for survivability, which means that software systems need to become more agile. Hence, software adaptor technologies such as the ATLAS Transformation Language (ATL) are gaining momentum due to the potential to define and regulate peer-to-peer communication among networks of enterprise systems. At present, ATL is the de facto standard for transformations within the framework of model-driven interoperability (MDI), nonetheless it lacks the dynamism required to streamline complex systems, which demand adaptors to be frequently redesigned whenever information models change. This paper presents a novel solution, which aims to reduce the setbacks that arise from this lack of dynamism.

Facilitating the specification of WSMO ontology using model-driven development

A semantic web service extends the capabilities of a web service by associating a semantic description of the web service in order to enable better search, discovery, selection, composition and integration. Semantically rich language such as Web Service Modeling Ontology WSMO has been created in order to provide a mechanism for describing the semantics of semantic web services. Unfortunately, for the common developer the learning curve for such languages can be steep, providing a barrier for adoption and widespread use. In this paper, we present a Model-Driven Architecture MDA approach for facilitating the specification of WSMO ontology through the use of meta-model and UML profile for modelling semantic web services; we concentrate our efforts to develop a transformation approach based on MDA to automate the generation of code by translating XMI specifications e.g. XML encodings of UML into equivalent WSMO specifications using Atlas Transformation Language ATL transformations.

Model transformations for migrating legacy deployment models in the automotive industry

Many companies in the automotive industry have adopted model-driven development in their vehicle software development. As a major automotive company, General Motors (GM) has been using a custom-built, domain-specific modeling language, implemented as an internal proprietary metamodel, to meet the modeling needs in its control software development. Since AUTomotive Open System ARchitecture (AUTOSAR) has been developed as a standard to ease the process of integrating components provided by different suppliers and manufacturers, there has been a growing demand to migrate these GM-specific, legacy models to AUTOSAR models. Given that AUTOSAR defines its own metamodel for various system artifacts in automotive software development, we explore applying model transformations to address the challenges in migrating GM-specific, legacy models to their AUTOSAR equivalents. As a case study, we have built and validated a model transformation using the MDWorkbench tool, the Atlas Transformation Language, and the Metamodel Coverage Checker tool. This paper reports on the case study, makes observations based on our experience to assist in the development of similar types of transformations, and provides recommendations for further research.

Automatic generation of built-in contract test drivers

Automatic generation of platform-independent and -dependent built-in contract test drivers that check pairwise interactions between client and server components is presented, focusing on the built-in contract testing (BIT) method and the model-driven testing approach. Components are specified by UML diagrams that define the contract between client and server, independent of a specific platform. MDA approaches are applied to formalize and perform automatic transformations from a platform-independent model to a platform-independent test architecture according to a BIT profile. The test architecture is mapped to Java platform models and then to test code. All these transformations are specified by a set of transformation rules written in the Atlas Transformation Language (ATL) that are automatically performed by the ATL engine. The solution named the MoBIT tool is applied to case studies in order to investigate the expected benefits and challenges to be faced.

Model Refinement in the Model Driven Architecture Context

Problem statement: Model Driven Architecture (MDA) is a software development approach based on the design and the transformation of models. In MDA, models are systematically translated to other models and to a source code. Model transformation plays a key role in MDA. Several model transformation languages have been launched lately, aiming to facilitate the translation of input models to output models. The employment of such languages in practical contexts has succeed, although quite often those languages cannot be directly applied to a particular type of model transformation, called refinement. Approach: This study provides a general overview on model refinement and investigates two approaches for model refinement based on Atlas Transformation Language (ATL) referred to as: Refining mode and module superimposition. ATL is a widely adopted language for solving model transformation problems in the MDA approach. Results: This study presents the comparative results obtained from the analysis of the Refining Mode and the Module Superimposition approaches, emphasizing their application benefits. Conclusion: The increasing use of MDA for the design of software systems empowered researches on how developers may benefit from approaches that perform model refinement. The main advantages achieved with the use of the Module Superimposition technique are maintainability and reusability improvement, obtained through module composition and rule superimposition. In its turn, the Refining Mode stands out for its ease of use.

Execution of natural language requirements using State Machines synthesised from Behavior Trees

This paper defines a transformation from Behavior Tree models to UML state machines. Behavior Trees are a graphical modelling notation for capturing and formalising dynamic system behaviour described in natural language requirements. But state machines are more widely used in software development, and are required for use with many tools, such as test case generators. Combining the two approaches provides a formal path from natural language requirements to an executable model of the system. This in turn facilitates requirements validation and transition to model-driven software development methods. The approach is demonstrated by defining a mapping from Behavior Trees to UML state machines using the ATLAS Transformation Language (ATL) in the Eclipse Modeling Framework. A security-alarm system case study is used to illustrate the use of Behavior Trees and execution to debug requirements.

A TRANSFORMATION APPROACH FOR COLLABORATION BASED REQUIREMENT MODELS

Distributed software engineering is widely recognized as a complex task. Among the inherent complexities is the process of obtaining a system design from its global requirement specification. This paper deals with such transformation process and suggests an approach to derive the behavior of a given system components, in the form of distributed Finite State Machines, from the global system requirements, in the form of an augmented UML Activity Diagrams notation. The process of the suggested approach is summarized in three steps: the definition of the appropriate source Meta-Model (requirements Meta-Model), the definition of the target Design Meta-Model and the definition of the rules to govern the transformation during the derivation process. The derivation process transforms the global system requirements described as UML diagram activities (extended with collaborations) to system roles behaviors represented as UML finite state machines. The approach is implemented using Atlas Transformation Language (ATL).

A Transformation Approach for Collaboration Based Requirement Models

Distributed software engineering is widely recognized as a complex task. Among the inherent complexities is the process of obtaining a system design from its global requirement specification. This paper deals with such transformation process and suggests an approach to derive the behavior of a given system components, in the form of distributed Finite State Machines,from the global system requirements, in the form of an augmented UML Activity Diagrams notation. The process of the suggested approach is summarized in three steps: the definition of the appropriate source Meta -Model (requirements Meta Model), the definition of the target Design Meta-Model and the definition of the rules to govern the transformation during the derivation process. The derivation process transforms the global system requirements described as UML diagram activities (extended with collaborati ons) to system roles behaviors represented as UML finite state machines. The approach is implemented using Atlas Transformation Language (ATL).

Automatic execution of business process models: Exploiting the benefits of Model-driven Engineering approaches

The business goals of an enterprise process are traced to business process models with the aim of being carried out during the execution stage. The automatic translation from these models to fully executable code which can be simulated and round-trip engineered is still an open challenge in the Business Process Management field. Model-driven Engineering has proposed a set of methodologies with which to solve the existing gap between business analysts and software developers, but the expected results have not as yet been achieved. In this paper, a new approach to solve this challenge is proposed. This approach is based on the integration of SOD-M, a model-driven method for the development of service-oriented systems, and DENEB, a platform for the development and execution of flexible business processes. SOD-M provides business analysts with a methodology that can be used to transform their business goals into composition service models, a type of model that represents business processes. The use of the Eclipse Modelling Framework and the ATLAS Transformation Language allows this model to be automatically transformed into a DENEB workflow model, resulting in a business process that is coded by a class of high-level Petri-nets and is directly executable in DENEB. The application of the proposal presented herein is illustrated by means of a real system related to the management of medical images.

Bridging the gap between requirements and design: An approach based on Problem Frames and SysML

The relation between the requirements specification and the design has been widely investigated with the aim to bridge the gap between the two artifacts. The goal is to find effective mechanisms to generate the system design starting from the analysis and specification of the requirements.This paper contributes to this research stream with an approach to create early design models from requirement artifacts. The approach weaves together the analysis and design phases favoring a tight collaboration between analysts and designers. It is based on Problem Frames, decomposition and re-composition patterns and supported by the System Modeling Language. The proposed solution has the potentiality of easing the development, shortening the development cycle and reducing the associated cost.The proposed design generation guidelines have been implemented as ATLAS Transformation Language rules in a model-based transformation process. The entire approach is model driven, allowing for the generation of the design model through transformations applied to the requirements model. The design model is automatically generated through the application of the transformation rules described in the paper. The proposed rules are fairly general and can be applied to any analysis model built according to the proposed analysis guidelines. The transformation process can be easily re-implemented using any suitable modeling tool that includes the ATLAS Transformation Language interpretation engine.