A Rigouous Framework for Model-Driven Development

Author(s):  
Liliana María Favre

The model-driven architecture (MDA) is an approach to model-centric software development. The concepts of models, metamodels, and model transformations are at the core of MDA. Model-driven development (MDD) distinguishes different kinds of models: the computation-independent model (CIM), the platform-independent model (PIM), and the platform-specific model (PSM). Model transformation is the process of converting one model into another model of the same system, preserving some kind of equivalence relation between them. One of the key concepts behind MDD is that models generated during software developments are represented using common metamodeling techniques. In this chapter, we analyze an integration of MDA metamodeling techniques with knowledge developed by the community of formal methods. We describe a rigorous framework that comprises the NEREUS metamodeling notation (open to many other formal languages), a system of transformation rules to bridge the gap between UML/OCL and NEREUS, the definition of MDA-based reusable components, and model/metamodeling transformations. In particular, we show how to integrate NEREUS with algebraic languages using the Common Algebraic Specification Language (CASL). NEREUS focuses on interoperability of formal languages in MDD.

Author(s):  
Liliana Favre

The model-driven architecture (MDA) is an approach to model-centric software development. The concepts of models, metamodels, and model transformations are at the core of MDA. Model-driven development (MDD) distinguishes different kinds of models: the computation-independent model (CIM), the platform-independent model (PIM), and the platform-specific model (PSM). Model transformation is the process of converting one model into another model of the same system, preserving some kind of equivalence relation between them. One of the key concepts behind MDD is that models generated during software developments are represented using common metamodeling techniques. In this chapter, we analyze an integration of MDA metamodeling techniques with knowledge developed by the community of formal methods. We describe a rigorous framework that comprises the NEREUS metamodeling notation (open to many other formal languages), a system of transformation rules to bridge the gap between UML/OCL and NEREUS, the definition of MDA-based reusable components, and model/metamodeling transformations. In particular, we show how to integrate NEREUS withalgebraic languages using the Common Algebraic Specification Language (CASL). NEREUS focuses on interoperability of formal languages in MDD.


Author(s):  
Yashwant Singh ◽  
Manu Sood

The Model-Driven Architecture approach to software development uses transformation models for transforming Platform-Independent Models (PIM) into Platform-Specific Models (PSM) as its core software development strategy. The Model-Driven Architecture (MDA) approach and corresponding standards of the software development based on models have been initiated by the Object Management Group. In this chapter, the authors analyze the basic models of MDA (i.e., Computational Independent Model [CIM], PIM, and PSM) using a suitable example and formalize the model transformations for transforming PIM into PSM. These transformations have been illustrated through the generation of a Relational Model, an Enterprise Java Bean (EJB) Model, and a Web Model from PIM for the example under consideration, using UML profile, and keeping in mind the property of reusability of models in MDA transformations. The focus has been on the specification and formalization of rules needed to get the Relational PSM, EJB PSM, and Web PSM from PIM. A transformation tool, whose functionality of transformation of PIM into Relational PSM, EJB PSM, and Web PSM, is illustrated in this chapter.


Author(s):  
Liliana María Favre ◽  
Claudia Teresa Pereira ◽  
Liliana Inés Martinez

The model driven architecture (MDA) is an initiative proposed by the object management group (OMG), which is emerging as a technical framework to improve productivity, portability, interoperability, and maintenance (MDA, 2003). MDA promotes the use of models and modelto- model transformations for developing software systems. All artifacts, such as requirement specifications, architecture descriptions, design descriptions, and code are regarded as models. MDA distinguishes four main kinds of models: computation independent model (CIM), platform independent model (PIM), platform specific models (PSM), and implementation specific model (ISM).


Author(s):  
Liliana María Favre ◽  
Claudia Teresa Pereira ◽  
Liliana Inés Martinez

The model driven architecture (MDA) is an initiative proposed by the object management group (OMG), which is emerging as a technical framework to improve productivity, portability, interoperability, and maintenance (MDA, 2003). MDA promotes the use of models and model-to-model transformations for developing software systems. All artifacts, such as requirement specifications, architecture descriptions, design descriptions, and code are regarded as models. MDA distinguishes four main kinds of models: computation independent model (CIM), platform independent model (PIM), platform specific models (PSM), and implementation specific model (ISM). A CIM describes a system from the computation independent viewpoint that focuses on the environment of and the requirements for the system. In general, it is called domain model. A PIM is a model that contains no reference to the platforms that are used to realize it. A PSM describes a system with full knowledge of the final implementation platform. In this context, a platform is “a set of subsystems and technologies that provide a coherent set of functionality which any application supported by that platform can use without concern for the details of how the functionality is implemented” (MDA, 2003, p. 2-3). PIMs and PSMs are expressed using the unified modeling language (UML) combined with the object constraint language (OCL) (Favre, 2003; OCL, 2004; UML, 2004). The idea behind MDA is to manage the evolution from CIMs to PIMs and PSMs that can be used to generate executable components and applications. In MDA is crucial to define, manage, and maintain traces and relationships between different models and automatically transform them and produce code that is complete and executable. Metamodeling has become an essential technique in model-centric software development. The metamodeling framework for the UML itself is based on architecture with four layers: meta-metamodel, metamodel, model, and user objects. A metamodel is an explicit model of the constructs and rules needed to build specific models, its instances. A meta-metamodel defines a language to write metamodels. OCL can be used to attach consistency rules to models and metamodels. Related OMG standard metamodels and metametamodels such as meta object facility (MOF), software process engineering metamodel (SPEM) and common warehouse model (CWM) share a common design philosophy (CWM, 2001; MOF, 2005; SPEM, 2005). MOF defines a common way for capturing all the diversity of modeling standards and interchange constructs. MOF uses an object modeling framework that is essentially a subset of the UML core. The four main modeling concepts are “classes, which model MOF metaobjects; associations, which model binary relationships between metaobjects; data types, which model other data; and packages, which modularize the models” (MOF, 2005, p. 2-6). The query, view, transformation (QVT) standard depends on MOF and OCL for specifying queries, views, and transformations. A query selects specific elements of a model, a view is a model derived from other model, and a model transformation is a specification of a mechanism to convert the elements of a model, into elements of another model, which can be instances of the same or different metamodels (QVT, 2003).


Computers ◽  
2019 ◽  
Vol 8 (4) ◽  
pp. 89 ◽  
Author(s):  
Imane Essebaa ◽  
Salima Chantit ◽  
Mohammed Ramdani

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.


Author(s):  
Liliana Maria Favre

Systems and applications aligned with new paradigms such as cloud computing and internet of the things are becoming more complex and interconnected, expanding the areas in which they are susceptible to attacks. Their security can be addressed by using model-driven engineering (MDE). In this context, specific IoT or cloud computing metamodels emerged to support the systematic development of software. In general, they are specified through semiformal metamodels in MOF style. This article shows the theoretical foundations of a method for automatically constructing secure metamodels in the context of realizations of MDE such as MDA. The formal metamodeling language Nereus and systems of transformation rules to bridge the gap between formal specifications and MOF are described. The main contribution of this article is the definition of a system of transformation rules called NEREUStoMOF for transforming automatically formal metamodeling specifications in Nereus to semiformal-MOF metamodels annotated in OCL.


Author(s):  
Francisco José Domínguez-Mayo ◽  
María José Escalona ◽  
Manuel Mejías ◽  
Isabel Ramos ◽  
Luis Fernández

Diverse development web methodologies currently exist in the field of Model-Driven Web Engineering (MDWE), each of which covers different Levels of Abstraction on Model-Driven Architecture (MDA): Computation Independent Model (CIM), Platform Independent Model (PIM), Platform Specific Model (PSM), and Code. Given the high number of methodologies available, it has become necessary to define objective evaluation tools to enable development teams to improve their methodological environment and help designers of web methodologies design new effective and efficient tools, processes and techniques. Since proposals are constantly evolving, the need may arise not only to evaluate the quality but also to find out how it can be improved. This paper presents an approach named QuEF (Quality Evaluation Framework) oriented towards evaluating, through objectives measures, the quality of information technology infrastructure, mainly in MDWE methodology environments.


Author(s):  
Pablo Nicolás Díaz Bilotto ◽  
Liliana Favre

Software developers face several challenges in deploying mobile applications. One of them is the high cost and technical complexity of targeting development to a wide spectrum of platforms. The chapter proposes to combine techniques based on MDA (Model Driven Architecture) with the HaXe language. The outstanding ideas behind MDA are separating the specification of the system functionality from its implementation on specific platforms, managing the software evolution, increasing the degree of automation of model transformations, and achieving interoperability with multiple platforms. On the other hand, HaXe is a very modern high level programming language that allows us to generate mobile applications that target all major mobile platforms. The main contributions of this chapter are the definition of a HaXe metamodel, the specification of a model-to-model transformation between Java and HaXe and, the definition of an MDA migration process from Java to mobile platforms.


Author(s):  
Samia Nasiri ◽  
Yassine Rhazali ◽  
Mohammed Lahmer

Model-driven architecture (MDA) is an alternative approach of software engineering that allows an automatic transformation from business process model to code model. In MDA there are two transformation kinds: transformation from computing independent model (CIM) to platform independent model (PIM) and transformation from PIM to platform specific model (PSM). In this chapter, the authors based on CIM to PIM transformation. This transformation is done by developing a platform that generates class diagram, presented in XMI file, from specifications that are presented in user stories, which are written in natural language (English). They used a natural language processing (NLP) tool named “Stanford Core NLP” for extracting of the object-oriented design elements. The approach was validated by focusing on two case studies: firstly, comparing the results with the results other researchers; and secondly, comparing the results with the results obtained manually. The benefits of the approach are aligned with agile methods goals.


Sign in / Sign up

Export Citation Format

Share Document