Round-trip Engineering UML Class Models and Java Models

2016 ◽  
Vol 7 (3) ◽  
pp. 72-92 ◽  
Author(s):  
Sandra Greiner ◽  
Thomas Buchmann
Keyword(s):  
Source Code ◽  
Model Transformations ◽  
Tool Support ◽  
Round Trip ◽  
Model Driven ◽  
Engineering Discipline ◽  
Model Driven Software Development ◽  
Model Transformation Language ◽  
Class Models

Model transformations constitute the key technology for model-driven software development, a software engineering discipline which became more and more important during the last decade. While tool support for unidirectional batch transformations is rather mature, bidirectional and incremental transformations are only weakly investigated. Nevertheless, several usage scenarios demand for incremental and bidirectional transformations, like round-trip engineering between UML class models and Java source code. This paper presents a bidirectional transformation between UML class models and a Java model which is obtained from Java source code. The transformation is written in QVT Relations, a declarative model transformation language provided by the OMG. While the case study demonstrates that it is possible to specify bidirectional transformations between heterogeneous metamodels in a single relational specification, it also reveals some inherent limitations of the language and the corresponding tool support.

scholarly journals MoDAr-WA: Tool Support to Automate an MDA Approach for MVC Web Application

Computers ◽  
2019 ◽  
Vol 8 (4) ◽  
pp. 89 ◽  
Author(s):  
Imane Essebaa ◽  
Salima Chantit ◽  
Mohammed Ramdani
Keyword(s):  
Web Application ◽  
Source Code ◽  
Specific Model ◽  
Model Transformations ◽  
Tool Support ◽  
Model Driven Architecture ◽  
Application Development ◽  
Model Driven ◽  
Constraints Model ◽  
Independent Model

Model-driven engineering (MDE) uses models during the application development process. Thus, the MDE is particularly based on model-driven architecture (MDA), which is one of the important variants of the Object Management Group (OMG). MDA aims to generate source code from abstract models through several model transformations between, and inside the different MDA levels: computation independent model (CIM), platform independent model (PIM), and platform specific model (PSM) before code. In this context, several methods and tools were proposed in the literature and in the industry that aim to automatically generate the source code from the MDA levels. However, researchers still meet many constraints—model specifications, transformation automation, and level traceability. In this paper, we present a tool support, the model-driven architecture for web application (MoDAr-WA), that implements our proposed approach, aiming to automate transformations from the highest MDA level (CIM) to the lowest one (code) to ensure traceability. This paper is a continuity of our previous works, where we automate transformation from the CIM level to the PIM level. For this aim, we present a set of meta-models, QVT and Acceleo transformations, as well as the tools used to develop our Eclipse plug-in, MoDAr-WA. In particular, we used QVT rules for transformations between models and Acceleo for generating code from models. Finally, we use MoDAr-WA to apply the proposed approach to the MusicStore system case study and compare the generated code from CIM to the original application code.

MoDSEL

2012 ◽  
pp. 572-594
Author(s):  
Ersin Er ◽  
Bedir Tekinerdogan
Keyword(s):  
Software Development ◽  
Impact Analysis ◽  
Software Evolution ◽  
Academic Research ◽  
Model Driven ◽  
Model Driven Software Development ◽  
Basic Concepts ◽  
The Impact ◽  
Development And Evolution

Model-Driven Software Development (MDSD) aims to support the development and evolution of software intensive systems using the basic concepts of model, metamodel, and model transformation. In parallel with the ongoing academic research, MDSD is more and more applied in industrial practices. Like conventional non-MDSD practices, MDSD systems are also subject to changing requirements and have to cope with evolution. In this chapter, the authors provide a scenario-based approach for documenting and analyzing the impact of changes that apply to model-driven development systems. To model the composition and evolution of an MDSD system, they developed the so-called Model-Driven Software Evolution Language (MoDSEL) which is based on a megamodel for MDSD. MoDSEL includes explicit language abstractions to specify both the model elements of an MDSD system and the evolution scenarios that might apply to model elements. Based on MoDSEL specifications, an impact analysis is performed to assess the impact of evolution scenarios and the sensitivity of model elements. A case study is provided to show different kind of evolution scenarios and the required adaptations to model elements.

MDA-Based Transformation of LMS Business Components

2013 ◽  
Vol 9 (4) ◽  
pp. 63-84 ◽  
Author(s):  
Rachid Dehbi ◽  
Mohamed Talea ◽  
Abderrahim Tragha
Keyword(s):  
Complete Solution ◽  
Model Transformations ◽  
Generative Programming ◽  
System Generator ◽  
Model Driven ◽  
Business Component ◽  
Component Approach ◽  
Uml Class Diagram

The model driven engineering and generative programming are revolutionizing software development just as automation and computerization revolutionized the manufacturing process. The key technologies of these approaches are the model transformations, and development in the XML technologies. In this paper the authors show the contribution of these two techniques in the implementation of LMSGENERATOR, a Multi-target Learning management system generator with a model-driven methodology based on MDA approach coupled with component approach. Based on generative programming, from user specifications (abstract models) and the desired technologies, software bricks will be generated and assembled to produce a complete solution adapted to the area and the users’ needs. This paper focuses on the transformation rules implemented in the LMSGENERATOR cores, in particular the transformation of a detailed UML class diagram, representing a business model, into the LMS Business component. Thus, the authors show the role of programming in model transformations through the use of API manipulating UML diagrams and XML files. Also this work presents a case study to illustrate this proposed plan.

Towards Measuring the Change Impact in ATL Model Transformations

2016 ◽  
Vol 26 (02) ◽  
pp. 153-181 ◽  
Author(s):  
Andreza Vieira ◽  
Franklin Ramalho
Keyword(s):  
Software Development ◽  
Static Analysis ◽  
Development Time ◽  
Development Process ◽  
Model Transformations ◽  
Software Development Process ◽  
Model Driven ◽  
Change Impact ◽  
The Impact

The Model-Driven Development (MDD) approach shifts the focus on code to models in the software development process. In MDD, model transformations are elements that play an important role. MDD-based projects evolve along their lifecycle in a way that changes in their transformations are frequent. Before applying changes it is important to measure their impacts within the transformation. However, currently no technique helps practitioners in this direction. We propose an approach to measure the change impact in ATL model transformations. Based on static analysis, it detects the elements impacted by a change and calculates the change impact value through three metrics we defined. By using our approach, practitioners can (i) save effort and development time since the elements impacted with the change are automatically detected and (ii) better schedule and prioritize changes according to the impact value. To empirically evaluate our approach we conducted a case study.

scholarly journals Teaching pragmatic model-driven software development

2015 ◽  
Vol 12 (2) ◽  
pp. 683-705 ◽  
Author(s):  
Jaroslav Porubän ◽  
Michaela Bacíková ◽  
Sergej Chodarev ◽  
Milan Nosál’
Keyword(s):  
Software Development ◽  
Development Process ◽  
Model Driven Development ◽  
Model Driven ◽  
Visualisation Tool ◽  
Big Picture ◽  
Model Driven Software Development ◽  
Positive Results

Model-driven software development is surrounded by numerous myths and misunderstandings that hamper its adoption. For long, our students were victims of these myths and considered MDSD impractical and only applied in academy. In this paper we discuss these myths and present our experience with devising an MDSD course that challenges them and motivates students to understand MDSD principles. The main contribution of this work is a set of MDSD teaching guidelines that can make the course pragmatic in the eyes of students - programmers. These guidelines introduce MDSD from the viewpoint of a programmer as a pragmatic tool for solving concrete problems in the development process. In our MDSD course we implemented the presented guidelines. The course shows several techniques and principles of model-driven development in multiple incremental iterations instead of concentrating on a single tool. At the same time we unite these techniques by using a dynamic visualisation tool that shows to the students the whole infrastructure in the big picture. The course is implemented as an iterative incremental MDSD case study. The paper concludes with a survey performed with our students that indicates positive results of the approach.

scholarly journals Implementing QVT-R via semantic interpretation in UML-RSDS

2020 ◽  
Author(s):  
K. Lano ◽  
S. Kolahdouz-Rahimi
Keyword(s):  
Model Transformation ◽  
Semantic Interpretation ◽  
Model Transformations ◽  
Tool Support ◽  
Transformation Language ◽  
Efficient Code ◽  
Model Transformation Language ◽  
Multiple Languages ◽  
Mathematical Semantics ◽  
Qvt Relations

Abstract The QVT-Relations (QVT-R) model transformation language is an OMG standard notation for model transformation specification. It is highly declarative and supports (in principle) bidirectional (bx) transformation specification. However, there are many unclear or unsatisfactory aspects to its semantics, which is not precisely defined in the standard. UML-RSDS is an executable subset of UML and OCL. It has a precise mathematical semantics and criteria for ensuring correctness of applications (including model transformations) by construction. There is extensive tool support for verification and for production of 3GL code in multiple languages (Java, C#, C++, C, Swift and Python). In this paper, we define a translation from QVT-R into UML-RSDS, which provides a logically oriented semantics for QVT-R, aligned with the RelToCore mapping semantics in the QVT standard. The translation includes variation points to enable specialised semantics to be selected in particular transformation cases. The translation provides a basis for verification and static analysis of QVT-R specifications and also enables the production of efficient code implementations of QVT-R specifications. We evaluate the approach by applying it to solve benchmark examples of bx.

Model-driven development of multiagent systems: a survey and evaluation

2013 ◽  
Vol 28 (4) ◽  
pp. 479-503 ◽  
Author(s):  
Geylani Kardas
Keyword(s):  
Software Development ◽  
Multiagent Systems ◽  
Code Generation ◽  
Model Transformations ◽  
Tool Support ◽  
Model Driven Development ◽  
Model Driven ◽  
Abstraction Level ◽  
Agent Oriented Software Engineering ◽  
Research Activities

AbstractTo work in a higher abstraction level is of critical importance for the development of multiagent systems (MAS) since it is almost impossible to observe code-level details of such systems due to their internal complexity, distributedness and openness. As one of the promising software development approaches, model-driven development (MDD) aims to change the focus of software development from code to models. This paradigm shift, introduced by the MDD, may also provide the desired abstraction level during the development of MASs. For this reason, MDD of autonomous agents and MASs has been recognized and become one of the research topics in agent-oriented software engineering (AOSE) area. Contributions are mainly based on the model-driven architecture (MDA), which is the most famous and in-use realization of MDD. Within this direction, AOSE researchers define MAS metamodels in various abstraction levels and apply model transformations between the instances of these metamodels in order to provide rapid and efficient implementation of the MASs in various platforms. Reorganization of the existing MAS development methodologies to support model-driven agent development is another emerging research track. In this paper, we give a state of the art survey on above mentioned model-driven MAS development research activities and evaluate the introduced approaches according to five quality criteria we define on model-driven MAS engineering: (1) definition of a platform independent MAS metamodel, (2) model-to-model transformability, (3) model-to-code transformability, (4) support for multiple MAS platforms and finally (5) tool support for software modeling and code generation. Our evaluation has shown that the researchers contributed to the area by providing MDD processes in which design of the MASs are realized at a very high abstraction level and the software for these MASs are developed as a result of the application of a series of model transformations. However, most of the approaches are incapable of supporting multiple MAS environments due to the restricted specifications of their metamodels and model transformations. Also efficiency and practicability of the proposed methodologies are under debate since the amount and quality of the executable MAS components, gained automatically, appear to be not sufficient.

scholarly journals Possible realizations of multiplicity constraints

2013 ◽  
Vol 10 (4) ◽  
pp. 1621-1646 ◽  
Author(s):  
Zdeněk Rybola ◽  
Karel Richta
Keyword(s):  
Relational Databases ◽  
Source Code ◽  
Model Transformations ◽  
Experimental Comparison ◽  
Extended Version ◽  
Model Driven ◽  
Application Data ◽  
The Common ◽  
And Behavior ◽  
Independent Model

Model Driven Development (MDD) approach is often used to model application data and behavior by a Platform Independent Model (PIM) and to generate Platform Specific Models (PSMs) and even the source code by model transformations. However, these transformations usually omit constraints of the binary association multiplicities, especially the source class optionality constraint. This paper is an extended version of the paper ?Transformation of Special Multiplicity Constraints - Comparison of Possible Realizations? presented at MDASD workshop at the FedCSIS 2012 conference. In this paper, we summarize the process of the transformation of a binary association from a PIM into a PSM for relational databases. We suggest several possible realizations of the source class optionality constraint to encourage the automatically transformation and discuss their advantages and disadvantages.We also provide experimental comparison of our suggested realizations to the common realization where this constraint is omitted.

Sign in / Sign up

Export Citation Format

Share Document