Atlas Transformation Language Research Articles

Enhanced performance prediction of ATL model transformations

Model transformation languages are domain-specific languages used to define transformations of models. These transformations consist of the translation from one modeling formalism into another or just the updating of a given model. Such transformations are often described declaratively and are often implemented based on very small models that cover the language of the input model. As a result, transformation developers are often unable to assess the time required to transform a larger model.Hence, we propose a prediction approach based on machine learning which uses a set of model characteristics as input and provides a prediction of the execution time of a transformation defined in the Atlas Transformation Language (ATL). In our previous work (Groner et al., 2023), we already showed that support vector regression in combination with a model characterization based on the number of model elements, the number of references, and the number of attributes is the best choice in terms of usability and prediction accuracy for the transformations considered in our experiments.A major weakness of our previous approach is that it fails to predict the performance of transformations that also transform attribute values of arbitrary length, such as string values. Therefore, we investigate in this work whether an extension of our feature sets that describes the average size of string attributes can help to overcome this weakness.Our results show that the random forest approach in combination with model characterizations based on the number of model elements, the number of references, the number of attributes, and the average size of string attributes filtered by the 85th percentile of their variance is the best choice in terms of the simple way to describe a model and the quality of the obtained prediction. With this combination, we obtained a mean absolute percentage error (MAPE) of 5.07% over all modules and a MAPE of 4.82% over all modules excluding the transformation for which our previous approach failed. Whereas, we obtained previously a MAPE of 38.48% over all modules and a MAPE of 4.45% over all modules excluding the transformation for which our previous approach failed.

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.

Approach by modeling to generate an e-commerce web code from laravel model

The world of web is constantly evolving. Today, we no longer speak of a website but of a web application. The growing difficulty of designing web applications has given rise to solutions and tools. The framework is one of them. Providing a serious framework for development by offering strict development rules, as well as generic and out-of-the-box components, PHP laravel framework is one of them. This paper aims to present the different stages of modeling and development of an enterprise resource planning (ERP) system that will be implemented by PHP laravel by defining the main concepts involved in this information system modeling and development process. To lead and implement the end-to-end development of the said system, we apply the model-driven architecture (MDA) approach. This approach is based on atlas transformation language (ATL). The result of this paper is an Ecore file, a reliable MVC2 web model of e-commerce ERP, which will be the input file to generate the aforementioned system code. To validate this approach, we implemented a case study. The result of this work is very satisfying. Thus, we arrived to generate all necessary elements for this ERP code generation by respecting the MVC2 model and the PHP coding.

An automatic alignment of the business process and business value models: a novel MDA method

With the massive development of end-users requirements, the model alignment has become an essential stage in software engineering, especially in the model driven architecture (MDA) approach, to absorb the end-user’s need. The purpose is to facilitate the alignment of new models from existing ones. Our contribution in this paper is to deal with the MDA higher abstraction lever by focusing on the automatic alignment of the business value with the business process models for the information system (IS). For our case, the data-flow diagram (DFD) illustrates the business process model, and the E<sup>3</sup>value model illustrates the business value model. However, the ATLAS-transformation language (ATL) ensures automatic alignment. The main goal is to facilitate and accelerate IS implementation while enhancing its quality.

Interaction Multi-Agent Models' Automatic Alignment with MDA Higher Abstraction Level

With the massive growth of the software sector as well as the erratic needs of end users, agent-based information systems and Model Driven Architecture (MDA) approach are among the liveliest and significant fields of experimentation and improvement to emerge in the recent decade. In this vein, we suggest in this research an innovative method that automates the construction and the generation processes of the interaction multi-agent models from the business requirements engineering models at the MDA highest abstraction levels. So, our defiance is to align the Agent Modeling Language (AML) Communicative Interaction diagram with the E3value model dealing with the MDA approach. The ATLAS-Transformation Language (ATL) is applied to automate the model alignment process. The goal is to reduce project effort, time, and development costs as all alignment process is automatically done, boosting the chances of being more competitive in the software business.

A model-driven transformation approach for the modelling of processes in clinical practice guidelines

Clinical Practice Guidelines (CPGs) include recommendations aimed at optimising patient care, informed by a review of the available clinical evidence. To achieve their potential benefits, CPG should be readily available at the point of care. This can be done by translating CPG recommendations into one of the languages for Computer-Interpretable Guidelines (CIGs). This is a difficult task for which the collaboration of clinical and technical staff is crucial. However, in general CIG languages are not accessible to non-technical staff. We propose to support the modelling of CPG processes (and hence the authoring of CIGs) based on a transformation, from a preliminary specification in a more accessible language into an implementation in a CIG language. In this paper, we approach this transformation following the Model-Driven Development (MDD) paradigm, in which models and transformations are key elements for software development. To demonstrate the approach, we implemented and tested an algorithm for the transformation from the BPMN language for business processes to the PROforma CIG language. This implementation uses transformations defined in the ATLAS Transformation Language. Additionally, we conducted a small experiment to assess the hypothesis that a language such as BPMN can facilitate the modelling of CPG processes by clinical and technical staff.

Graphical user Interfaces Generation from BPMN (Business Process Model and Notation) via IFML (Interaction Flow Modeling Language) up to PSM (Platform Specific Model) Level

The fundamental concept behind the MDA (Model Driven Architecture) approach is the development of many models, first the Computation Independent Model (CIM), then the Platform Independent Model (PIM), and lastly the Platform Specific Model (PSM) for the concrete implementation of the system. Web applications are just one example of customized software that is now being developed at an increasing rate. Interaction Flow Modeling Language (IFML) was developed to represent the front end of any program that necessitates a powerful interaction with a user through the use of an interface, regardless of the technical details of its implementation. There are various modeling tools for IFML; the Webratio tool is an illustration that facilitates the generation of the entire web application. This article discusses the model transformations in the MDA’s approach, starting from the CIM level up to the PSM level through the PIM level. To begin, we created the Business Process Model and Notation (BPMN) and IFML metamodels in Eclipse tool, we created also the BPMN model, and we get the IFML model by applying the shift rules in Atlas Transformation Language (ATL). Finally, we generated the application using a standard tool that implements IFML Webratio tool. A CRUD (Create, Read, Update, and Delete) features for the after-sales service case study were provided to illustrate the conversion strategy from the CIM level via the PIM level to the PSM level.

Transformation of sequence diagram to timed Petri net using Atlas Transformation Language metamodel approach

AbstractReal‐time systems are complex and composed of time‐bounded events that must satisfy the real‐time constraints for their proper functioning. To cope with the complexity of real‐time systems, model‐driven approaches such as model‐driven architecture (MDA) can be followed, which uses the conceptual models for system representation. This paper presents an MDA‐based automated approach for an early stage performance evaluation and verification of a real‐time system using the Unified Modeling Language (UML)/Modeling and Analysis of Real‐Time and Embedded systems (MARTE) sequence diagram. A metamodel‐based model‐to‐model transformation technique is used for mapping the UML/MARTE sequence diagram into the generalized Petri Net Markup Language (PNML) representation of the timed Petri net model using Atlas Transformation Language (ATL). The derived PNML representation has the advantage to support the interoperability between different Petri net tools when compared over the existing methods that produce tool‐specific representation. The proposed approach enables the system designers to create and evaluate alternate system designs and predict their behavior, contributing to improving the system quality. The contribution of the proposed technique for identifying the optimal system design is analyzed using a real‐time embedded sensor application. The proposed transformation approach is also validated using a real‐time system from the manufacturing domain.

Contrasting dedicated model transformation languages versus general purpose languages: a historical perspective on ATL versus Java based on complexity and size

Model transformations are among the key concepts of model-driven engineering (MDE), and dedicated model transformation languages (MTLs) emerged with the popularity of the MDE pssaradigm about 15 to 20 years ago. MTLs claim to increase the ease of development of model transformations by abstracting from recurring transformation aspects and hiding complex semantics behind a simple and intuitive syntax. Nonetheless, MTLs are rarely adopted in practice, there is still no empirical evidence for the claim of easier development, and the argument of abstraction deserves a fresh look in the light of modern general purpose languages (GPLs) which have undergone a significant evolution in the last two decades. In this paper, we report about a study in which we compare the complexity and size of model transformations written in three different languages, namely (i) the Atlas Transformation Language (ATL), (ii) Java SE5 (2004–2009), and (iii) Java SE14 (2020); the Java transformations are derived from an ATL specification using a translation schema we developed for our study. In a nutshell, we found that some of the new features in Java SE14 compared to Java SE5 help to significantly reduce the complexity of transformations written in Java by as much as 45%. At the same time, however, the relative amount of complexity that stems from aspects that ATL can hide from the developer, which is about 40% of the total complexity, stays about the same. Furthermore we discovered that while transformation code in Java SE14 requires up to 25% less lines of code, the number of words written in both versions stays about the same. And while the written number of words stays about the same their distribution throughout the code changes significantly. Based on these results, we discuss the concrete advancements in newer Java versions. We also discuss to which extent new language advancements justify writing transformations in a general purpose language rather than a dedicated transformation language. We further indicate potential avenues for future research on the comparison of MTLs and GPLs in a model transformation context.

Obtaining secure business process models from an enterprise architecture considering security requirements

PurposeSecurity requirements play an important role in software development. These can be specified both in enterprise architecture models and in business processes. Enterprises increasingly carry out larger amounts of business processes where security plays a major role. Business processes including security can be automatically obtained from enterprise architecture models by applying a model-driven architecture approach, through a CIM to CIM transformation. The aim of this article is to present the specification of transformation rules for the correspondence between enterprise architecture and business process model elements focusing on security.Design/methodology/approachThis work utilizes motivational aspects of the ArchiMate language to model security in the business layer of enterprise architectures. Next, a set of transformation rules defined with the Atlas Transformation Language are utilized to obtain the correspondence of the enterprise architecture elements in a business process, modelled with a security extension of BPMN.FindingsA total of 19 transformation rules have been defined. These rules are more complex than element to element relations, as they take into consideration the context of the elements for establishing the correspondence. Additionally, the prototype of a tool that allows the automatic transformation between both models has been developed.Originality/valueThe results of this work demonstrate the possibility to tackle complex transformations between both models, as previous literature focuses on semantic correspondences. Moreover, the obtained models can be of use for software developers applying the model-driven approach.

Transformation of the CIM Model into A PIM Model According to The MDA Approach for Application Interoperability: Case of the "COVID-19 Patient Management" Business Process

<p>Model-Driven Engineering (MDE) plays a very important role in improving the development of complex systems. It focuses more on modeling than on classical programming. In this sense, model transformation is at the heart of the Model Driven Architecture (MDA) approach which advocates the use of models throughout the software development cycle on two levels. The first being the transformation of the Computing Independent Model (CIM) into the Platform Independent Model (PIM) and the second concerning the transformation of PIM into Platform Specific Model (PSM).</p><p>The latter has been dealt with in the majority of research works while the transformation from CIM to PIM which represents the highest level is rarely discussed in research topics. It is for this reason and in the spirit of improving the process of transforming the CIM model into PIM according to the MDA approach, that we have developed this research work in order to propose a new method and new transformation rules for optimization of the business process "COVID-19 patient management". Our contribution consists of the semi-automatic transformation of the CIM model presented by the BPMN (Business Process Model and Notation) source model into a PIM target model presented by a class diagram by using a set of transformation and correspondence rules that we performed manually using the language ATL (Atlas Transformation Language). This automatic transformation of the two source and target models is provided by the Eclipse Modeling Framework (EMF) which executes the transformation rules described manually in ATL and generates the PIM target model as an XMI (XML Metadata Interchange) file representing the target class diagram.</p>

Metamodel based approach to generate user interface mockup from UML class diagram

Abstract Interface and interaction design take up most of the times in software creation. Human Computer Interaction (HCI) is mainly the best way to interact with a computer. During software development, class diagram is the only required step and process to design an information system according to UML notation. In addition, creating class diagram is a mandatory activity during the software creation process. The aim of this paper is to automatically generate the HCI mockup from class diagram to make easy and extremely fast software design. For example, the SEF (Schema d’Enchainement de Fenetre), is an interface model allowing to create a new interface mockup. It offers more widgets to design the HCI. And MACAO (Methode d’Analyse et de Conception d’Applications Orientees-objets) is one of the methods which helps computer scientist to easily create software. The model transformation is based on Model Driven Engineering (MDE). We use UML notation to design the class diagrams. We also adopt MDA architecture to create the model-based transformation process. Transformation rules are created using Atlas Transformation Language (ATL) to automatically generate a specific interface from the class diagram.

An UML Based Performance Evaluation of Real-Time Systems Using Timed Petri Net

Performance is a critical non-functional parameter for real-time systems and performance analysis is an important task making it more challenging for complex real-time systems. Mostly performance analysis is performed after the system development but an early stage analysis and validation of performance using system models can improve the system quality. In this paper, we present an early stage automated performance evaluation methodology to analyse system performance using the UML sequence diagram model annotated with modeling and analysis of real-time and embedded systems (MARTE) profile. MARTE offers a performance domain sub-profile that is used for representing real-time system properties essential for performance evaluation. In this paper, a transformation technique and transformation rules are proposed to map the UML sequence diagram model into a Generalized Stochastic Timed Petri net model. All the transformation rules are implemented using a metamodel based approach and Atlas Transformation Language (ATL). A case study from the manufacturing domain a Kanban system is used for validating the proposed technique.

Wodel-Test: a model-based framework for language-independent mutation testing

Mutation testing (MT) targets the assessment of test cases by measuring their efficiency to detect faults. This technique involves modifying the program under test to emulate programming faults, and assessing whether the existing test cases detect such mutations. MT has been extensively studied since the 70’s, and many tools have been proposed for widely used languages like C, Java, Fortran, Ada and SQL; and for notations like Petri-nets. However, building MT tools is costly and error-prone, which may prevent their development for new programming and domain-specific (modelling) languages. In this paper, we propose a framework called Wodel-Test to reduce the effort to create MT tools. For this purpose, it follows a model-driven approach by which MT tools are synthesized from a high-level description. This description makes use of the domain-specific language Wodel to define and execute model mutations. Wodel is language-independent, as it allows the creation of mutation operators for any language defined by a meta-model. Starting from the definition of the mutation operators, Wodel-Test generates a MT environment which parses the program under test into a model, applies the mutation operators, and evaluates the test-suite against the generated mutants, offering a rich collection of MT metrics. We report on an evaluation of the approach based on the creation of MT tools for Java and the Atlas transformation language.

Automatic Code Generation for Language-Learning Applications

Language-learning applications define exercises that are pedagogical tools to introduce new language concepts. The development of this type of applications is complex due to the diversity of language-learning methodologies, the variety of execution environments and the number of different technologies that can be used. This article proposes a complete Model-Driven Architecture (MDA) approach, from the definition of the Computational Independent Model (CIM layer) to the Implementation Specific Model (ISM layer), and the process of the necessary transformations for the automatic generation of the source code (in HTML and JavaScript) of language-learning applications. To carry out the model-to-model and model-to-text transformations, the ATLAS Transformation Language (ATL) and Acceleo transformation languages have been used respectively. The proposal has been validated through the modeling and the complete automatic generation of source code of two Learning Activity Mechanisms (LAM), which are used within methodologies such as Duolingo and Busuu: LAM Image-Audio-Text and LAM Audio-Text Options.

Multi-criteria test cases selection for model transformations

Model transformations play an important role in the evolution of systems in various fields such as healthcare, automotive and aerospace industry. Thus, it is important to check the correctness of model transformation programs. Several approaches have been proposed to generate test cases for model transformations based on different coverage criteria (e.g., statements, rules, metamodel elements, etc.). However, the execution of a large number of test cases during the evolution of transformation programs is time-consuming and may include a lot of overlap between the test cases. In this paper, we propose a test case selection approach for model transformations based on multi-objective search. We use the non-dominated sorting genetic algorithm (NSGA-II) to find the best trade-offs between two conflicting objectives: (1) maximize the coverage of rules and (2) minimize the execution time of the selected test cases. We validated our approach on several evolution cases of medium and large ATLAS Transformation Language programs.

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.

AN AUTOMATIC TRANSFORMATION METHOD FROM THE E3VALUE MODEL TO UML2 SEQUENCE DIAGRAMS: AN MDA APPROACH

Since the Model Driven Architecture (MDA) approach appearance, model’s transformation has been considered as one of the main computing keys in the software industry, which grows exponentially to ensure competitiveness. For that, the Object Management Group (OMG) offers for the MDA approach three abstraction levels, which are Computation Independent Model (CIM), Platform Independent Model (PIM) and Platform Specific Model (PSM). Most researchers put much focus on the PIM to PSM transformation because these levels have multiple common points, but they disregard the CIM to PIM transformation. So, our defiance in this paper is to propose a disciplined method that generates the UML2 Sequence diagrams automatically from the E3value model. Therefore, we produce the UML’s behavior and interaction model in the PIM level, from the value-based requirements model in the CIM level. The transformations are done automatically using the Atlas transformation language (ATL). The purpose is to reduce the effort, time, and the development cost of projects as all transformations is automated, increasing the chance of being more competitive in the software industry.

Towards the Meta-Modeling of Complex Inter-Organisationnel Collaborative Processes

Enterprises are progressively embedded in business to business atmospheres, in order to achieve their common business objectives. Such collaborations lead to Inter-Organizational Business Processes. Therefore, IOBP modeling involves new challenges, mainly the ability to deal with autonomy, privacy, heterogeneity. As a contribution in this area, a IOBP meta-model was designed. This model takes into account the maximum concepts related to the collaboration. Where, the process is complex, and its model in a global way affects its vision and complicates its implementation and hence the idea of its analysis into sub-IOBP to reduce the complexity of the global collaborative process, to streamline information exchange and to facilitate the understanding of the process by partners. A set of Atlas Transformation Language (ATL) transformation rules has been defined to convert Unified Modeling Language (UML) models to Business Process Model and Notation. Finally, the application of our approach has been demonstrated through a framework which can solve the problem of generic IOBP.

A Framework for Knowledge Models Transformation: A Step Towards Knowledge Integration and Warehousing

An intelligent decision support system should based on a knowledge warehouse (KW). A KW gathers knowledge initially expressed in different formalisms and therefore heterogeneous. Consequently, the KW building process requires knowledge homogenisation. This paper deals with this main issue; it introduces a three-layer architecture for a KW; more precisely, it focuses on the first layer architecture called Knowledge Acquisition and Transformation. This layer aims to transform heterogeneous knowledge models into the MOT (Modeling with Object Types) semi-formal language [Paquette, G (2002). Knowledge and Skills Modeling: A Graphical Language for Designing and Learning. Sainte-Foy: University of Quebec Press (in French).] that we have selected as a pivot knowledge model. For this transformation step, first, we design four meta-models; one for MOT and one for each of the three explicit knowledge models, namely, decision tree, association rules and clustering. Secondly, we define 15 transformation rules that we formalise in ATL (Atlas Transformation Language). Finally, we exemplify the knowledge transformation in order to show its usefulness for the KW building process.