Managing Complexity with MDSD

2011 ◽  
pp. 200-230
Author(s):  
Jorn Bettin
Keyword(s):  
Software Development ◽  
Source Code ◽  
Natural Extension ◽  
Design By Contract ◽  
Model Driven ◽  
Managing Complexity ◽  
Guiding Principles ◽  
Principles Of Design ◽  
Iterative Software

This chapter addresses the question of how to successfully create durable and scalable software architectures that enable the underlying design intent of a system to survive over a period of many years, such that no accidental dependencies are introduced as part of further software development and maintenance. The answer involves looking beyond object-orientation and traditional iterative software development. In order to prevent long-term design degradation, and in order to efficiently execute software development in the large, the introduction of dependencies between components needs to be actively managed, relying on a set of guiding principles for component encapsulation and abstraction. The guiding principles required turn out to be a natural extension to the principles of design by contract, they have a direct impact on the modular structure of software source code, and they form a foundation for model-driven approaches to software development.

Automate Model Transformation From CIM to PIM up to PSM in Model-Driven Architecture

2020 ◽  
pp. 262-283
Author(s):  
Yassine Rhazali ◽  
Asma El Hachimi ◽  
Idriss Chana ◽  
Mohammed Lahmer ◽  
Abdallah Rhattoy
Keyword(s):  
Life Cycle ◽  
Software Development ◽  
Business Process ◽  
Model Transformation ◽  
Source Code ◽  
Elementary Transformation ◽  
Multiple Points ◽  
Model Driven ◽  
Computer Scientists ◽  
Synthesis Methodology

The CIM, PIM, and PSM models are the main levels of the MDA approach. Model transformation is an important step in the MDA process. Indeed, in MDA there are two elementary transformation kinds: CIM to PIM transformation and PIM to PSM transformation. However, most searches propose approaches transforming PIM to PSM, since there are multiple points in common between PIM and PSM. Nevertheless, transforming CIM to PIM is rarely addressed in research because these two levels are mainly different. However, there is not a synthesis work that makes it possible to carry out a model transformation from CIM to PIM towards PSM until obtaining the code. This synthesis methodology allows controlling models transformation from CIM to PIM to PSM, indeed, up to obtaining code according the MDA. This approach makes it possible to limit the intervention of computer scientists in the life cycle of software development. Indeed, this methodology allows modeling only CIM, the business process, and then obtains the source code through successive semi-automatic transformations.

scholarly journals Improving Consistency of UML Diagrams and Its Implementation Using Reverse Engineering Approach

2018 ◽  
Vol 7 (4) ◽  
pp. 665-672
Author(s):  
Vasanthi Kaliappan ◽  
Norhayati Mohd Ali
Keyword(s):  
Software Development ◽  
Reverse Engineering ◽  
Source Code ◽  
Unified Modeling Language ◽  
Software Project ◽  
Structural Class ◽  
Model Driven ◽  
Engineering Approach ◽  
Huge Impact ◽  
Uml Diagrams

Software development deals with various changes and evolution that cannot be avoided due to the development processes which are vastly incremental and iterative. In Model Driven Engineering, inconsistency between model and its implementation has huge impact on the software development process in terms of added cost, time and effort. The later the inconsistencies are found, it could add more cost to the software project. Thus, this paper aims to describe the development of a tool that could improve the consistency between Unified Modeling Language (UML) design models and its C# implementation using reverse engineering approach. A list of consistency rules is defined to check vertical and horizontal consistencies between structural (class diagram) and behavioral (use case diagram and sequence diagram) UML diagrams against the implemented C# source code. The inconsistencies found between UML diagrams and source code are presented in a textual description and visualized in a tree view structure.

scholarly journals Propuesta para generar artefactos basados en modelos [Proposal for generation of software model-based artifacts]

2012 ◽  
Author(s):  
Vicente García Díaz ◽  
Edward Rolando Núñez Valdez ◽  
B. Cristina Pelayo García-Bustelo ◽  
Jordan Pascual Espada ◽  
Carlos Enrique Montenegro Marín
Keyword(s):  
Software Development ◽  
Source Code ◽  
Automatic Generation ◽  
Model Driven Engineering ◽  
New Paradigm ◽  
Natural Evolution ◽  
Model Driven ◽  
Software Model ◽  
Development Approach ◽  
The Impact

ResumenLa ingeniería Dirigida por Modelos es una aproximación de desarrollo en continua evolución. Prueba de ello sin los numerosos estándares que están surgiendo y la reciente aparición de herramientas que facilitan el trabajo con este reciente paradigma de la ingeniería del software. Al trabajar con modelos, un aspecto clave esla generación automática de código de menor nivel de abstracción. Sin embargo, la forma de llevar a cabo dicha generación no tiene en cuenta la evolución de los sistemas, y esa es la razón por la que el proceso es lento y repetitivo. En este trabajo se presenta una propuesta para generar código incrementalmente a partir de modelos, de forma que se minimice el impacto sobre aplicaciones que ya podrían estar en funcionamiento y se permita obtener la evolución exacta que han tenido los sistemas desde su origen.Palabras ClaveEvolución, matamodelos, modelo, generación de artefactos.Abstract The Model-Driven Engineering is a software development approach that continues evolving. In fact, there are some emerging standards and tools that facilitate working with this new paradigm of software engineering. Working with models, a key point is the automatic generation of source code of lower level of abstraction. However, the natural evolution of systems is not taken into account and that is the reason for which the process is usually slow and repetitive. In this work, we are going to show a proposal for incremental generation of source code from models. That way, we will minimize the impact on deployed applications and we will make the traceability of the evolution of systems. KeywordsArtifacts generation, evolution, metamodel, model. 

An approach to classification of MDA tools

2009 ◽  
Vol 38 (38) ◽  
pp. 72-83 ◽  
Author(s):  
Anton Chernichkin ◽  
Oksana Nikiforova
Keyword(s):  
Software Development ◽  
Development Process ◽  
Methodological Approach ◽  
Source Code ◽  
Software Development Process ◽  
Code Transformations ◽  
Model Driven ◽  
Stage Of Development ◽  
Development Life Cycle

An approach to classification of MDA tools Nowadays there is a wide variety of tools, supporting the idea of software development process to be enriched by the principles of modelling—the source code is being generated from the model. Many of these purporting to be "MDA complaint" as well. Model driven architecture offers an approach to software development process that provides a separation of concerns, keeping the appropriate level of abstraction on each stage of development. Furthermore, the source code can be generated in a formal way, requiring no interference from the developer. There are two types of software development tools: the former type represents the semiautomatic approach, where the software is supposed to be created using system's model and code transformations, also considering different types of routines, which are done manually, while the latter type is an automatic solution, where no manual steps or routines are required. The original article defines various perspectives on positioning of MDA tools among CASE tools for software development, as well as proposes a methodological approach on classification of MDA tools. One of the perspectives that can be used in the MDA tool classification approach corresponds with the Model Driven Development life cycle, while the other one defines the role of modelling and model application levels in a whole development process. In addition, various sets of features have been defined, in order to clarify the accordance level of these tools from the MDA perspective.

A Source Code Change Impact Analysis Algorithm for Iterative Software Development

2012 ◽  
Vol 4 (4) ◽  
pp. 60-75
Author(s):  
Jerod W. Wilkerson
Keyword(s):  
Software Development ◽  
Impact Analysis ◽  
Source Code ◽  
Development Projects ◽  
Change Impact Analysis ◽  
Analysis Algorithm ◽  
Code Change ◽  
Change Impact ◽  
Program Entry ◽  
Iterative Software

CHA-AS is a source code change impact analysis algorithm for Java programs. CHA-AS differs from other algorithms in that it does not require the program versions it compares to be whole programs with a well-defined program entry point. The need for such an algorithm is evident in iterative software development projects and projects involving the development of code libraries and frameworks—all of which may not have a well-defined program entry point at the time when change impact analysis needs to be performed. The CHA-AS algorithm supports the development of Decision Support Systems for software development managers and programmers working on iterative software development projects, or projects to develop source code libraries and frameworks. This paper describes the CHA-AS algorithm and demonstrates it to be efficient and effective in calculating source code change impact.

scholarly journals Quantools: A MDA transformation approach

2010 ◽  
Vol 16 (2) ◽  
pp. 53-56
Author(s):  
Paulo Lumertz ◽  
Ana Paula Terra Bacelo ◽  
Toacy Oliveira
Keyword(s):  
Software Development ◽  
Code Generation ◽  
Source Code ◽  
Model Driven Architecture ◽  
Model Driven ◽  
Transformation Rules ◽  
Transformation Approach

Model driven architecture (MDA) represents a challenge for the companies to increase the benefits of code generation, creating systems by using common libraries and standards. This paper presents the Quantools that is a result of a 5-year project, introducing the benefits of MDA in a Brazilian software development company. Quantools is based on the concept of cartridges that specify the transformation rules and constraints for a particular domain. The tool may be integrated to the modeling activities of the system to check the correctness of models according to the standards previously defined. The Quantools and its Cartridges execute transformations to generate the source code in a particular domain.

scholarly journals Model-Driven Approach and Library of Reusable Source Code for Automation of IT Operations

2017 ◽  
Vol 21 (1) ◽  
pp. 5-12
Author(s):  
Artūrs Bartusevičs ◽  
Andrejs Lesovskis ◽  
Viktorija Ponomarenko
Keyword(s):  
Software Development ◽  
Source Code ◽  
Configuration Management ◽  
Development Projects ◽  
Software Configuration Management ◽  
Model Driven ◽  
Software Configuration ◽  
Bug Tracking ◽  
Model Driven Approach ◽  
It Operations

Abstract Large software development projects with high levels of agility require several IT operations: software configuration management, bug tracking management, making software builds and deployments. Due to high agility in projects, the starting phases are very chaotic and sometimes in a few days customer is willing to get the first release of software. It means that all IT operations should be automated as soon as possible. The study presents a model-driven approach for automation of IT operations through the reuse of the existing source code. In addition, it presents a method for the development of library of reusable source code. The paper contains a brief description of the model-driven approach, library of source code and meta-models developed for a new methodology. The paper ends with the results of the practical experiments and conclusions on how this approach could be improved in the future.

Sign in / Sign up

Export Citation Format

Share Document