scholarly journals A UML 2.0 Activity Diagrams/CSP Integrated Approach for Modeling and Verification of Software Systems

2021 ◽  
Vol 22 (2) ◽  
Author(s):  
Raida Elmansouri ◽  
Said Meghzili ◽  
Allaoua Chaoui
Keyword(s):  
Model Transformation ◽  
Integrated Approach ◽  
Software Systems ◽  
Sequential Process ◽  
Model Checker ◽  
Model Driven Engineering ◽  
Model Driven ◽  
Activity Diagrams ◽  
Uml 2.0

This paper proposes an approach integrating UML 2.0 Activity Diagrams (UML2-AD) and Communicating Sequential Process (CSP) for modeling and verication of software systems. A UML2-AD is used for modeling a software system while CSP is used for verication purposes. The proposed approach consists of another way of transforming UML2-AD models to Communicating Sequential Process (CSP) models. It focuses also on checking the correctness of some properties of the transformation itself. These properties are specified using Linear Temporal Logic (LTL) and verified using the GROOVE model checker. This approach is based on Model Driven Engineering (MDE). The meta-modelling is realized using AToMPM tool while the model transformation and the correctness of its properties are realized using GROOVE tool. Finally, we illustrated this approach through a case study.

Evolution in Model-Driven Software Product-Line Architectures

2009 ◽  
pp. 102-132 ◽  
Author(s):  
Gan Deng ◽  
Douglas C. Schmidt ◽  
Aniruddha Gokhale ◽  
Jeff Gray ◽  
Yuehua Lin ◽  
...  
Keyword(s):  
Model Transformation ◽  
Product Line ◽  
Domain Model ◽  
Modeling Language ◽  
Model Driven Engineering ◽  
Model Driven ◽  
Transformation Rules ◽  
Domain Evolution ◽  
Software Product

This chapter describes our approach to model-driven engineering (MDE)-based product line architectures (PLAs) and presents a solution to address the domain evolution problem. We use a case study of a representative software-intensive system from the distributed real-time embedded (DRE) systems domain to describe key challenges when facing domain evolution and how we can evolve PLAs systematically and minimize human intervention. The approach uses a mature metamodeling tool to define a modeling language in the representative DRE domain, and applies a model transformation tool to specify modelto- model transformation rules that precisely define metamodel and domain model changes. Our approach automates many tedious, time consuming, and error-prone tasks of model-to-model transformation, thus significantly reducing the complexity of PLA evolution.

Metamodel Matching Techniques

2014 ◽  
Vol 5 (2) ◽  
pp. 70-94 ◽  
Author(s):  
Lamine Lafi ◽  
Jamel Feki ◽  
Slimane Hammoudi
Keyword(s):  
Model Transformation ◽  
Transformation Process ◽  
Software Systems ◽  
Model Driven Engineering ◽  
Modeling Framework ◽  
Model Driven ◽  
Systems Model ◽  
Model Transformation Language ◽  
Automatic Matching ◽  
Matching Techniques

During the last decade, Model Driven Engineering (MDE) has been proposed for supporting the development, maintenance and evolution of software systems. Model Driven Architecture (MDA), Software Factories and Eclipse Modeling Framework (EMF) are among the most representatives MDE approaches. Nowadays, it is well recognized that model transformation is at the heart of MDE approaches and, consequently represents one of the most important operations in MDE. However, despite the multitude of model transformation language proposals emerging from academic world and industry, these transformations are often manually specified; which is a tedious and error-prone task, and therefore an expensive process. Matching operation between metamodels is the keystone toward a (semi-)automatic transformation process. In this paper, the authors review metamodel matching techniques of the literature and then analyze their pros and cons in order to show how they can be useful for a semi-automatic transformation process. The result is a comparison of metamodel matching techniques, highlighting their similarities and differences in terms of information used for matching, demonstrating significant similarities between these techniques. Next, the authors compare four well-known metamodel matching techniques namely Similarity flooding, SAMT4MDE+ (extended Semi-Automatic Matching Tool for Model Driven Engineering), ModelCVS and AML (AtlanMod Matching Language) on ten couples of metamodels. For this comparison, the authors define a set of six criteria inspired from the database schema matching. One among these criteria is relevant to the quality of matching and for which we define a quality measure metrics. Furthermore, the authors develop a plug-in under Eclipse to support our comparison using ten couples of metamodels.

An Approach for the Transformation and Verification of BPMN Models to Colored Petri Nets Models

2020 ◽  
Vol 8 (1) ◽  
pp. 17-49 ◽  
Author(s):  
Said Meghzili ◽  
Allaoua Chaoui ◽  
Martin Strecker ◽  
Elhillali Kerkouche
Keyword(s):  
Petri Nets ◽  
Structural Properties ◽  
Graph Transformation ◽  
Colored Petri Nets ◽  
Model Checker ◽  
Model Driven Engineering ◽  
Model Driven ◽  
Successful Termination ◽  
Cpn Tools

The correctness of transformations has recently begun to attract the attention of the researchers in Model Driven Engineering (MDE). The objective of this article is twofold. First, it presents an approach for transforming BPMN models to Colored Petri nets models using GROOVE and EMF/Xpand tools. Second, it proposes an approach for checking the correctness of the transformation itself. More precisely, we have defined the termination property of the transformation and the preservation of some structural properties of BPMN models by the transformation using the GROOVE graph transformation tool. The authors have also applied the approach on a case study through which the authors have verified the successful termination of the transformation using GROOVE Model Checker and the target model properties using CPN Tools.

scholarly journals Mixed-semantics composition of statecharts for the component-based design of reactive systems

2020 ◽  
Vol 19 (6) ◽  
pp. 1483-1517
Author(s):  
Bence Graics ◽  
Vince Molnár ◽  
András Vörös ◽  
István Majzik ◽  
Dániel Varró
Keyword(s):  
Code Generation ◽  
Composite System ◽  
Formal Semantics ◽  
Reactive Systems ◽  
Cyber Physical System ◽  
Test Case ◽  
Model Checker ◽  
Model Driven Engineering ◽  
Design Decisions ◽  
Model Driven

Abstract The increasing complexity of reactive systems can be mitigated with the use of components and composition languages in model-driven engineering. Designing composition languages is a challenge itself as both practical applicability (support for different composition approaches in various application domains), and precise formal semantics (support for verification and code generation) have to be taken into account. In our Gamma Statechart Composition Framework, we designed and implemented a composition language for the synchronous, cascade synchronous and asynchronous composition of statechart-based reactive components. We formalized the semantics of this composition language that provides the basis for generating composition-related Java source code as well as mapping the composite system to a back-end model checker for formal verification and model-based test case generation. In this paper, we present the composition language with its formal semantics, putting special emphasis on design decisions related to the language and their effects on verifiability and applicability. Furthermore, we demonstrate the design and verification functionality of the composition framework by presenting case studies from the cyber-physical system domain.

Model-driven engineering applied to the development of embedded software for B-mode ultrasound imaging systems - A case study

2014 ◽  
Author(s):  
Haroldo Jose Onisto ◽  
Tiago de Moraes Machado ◽  
Ramon Cravo Fernandes ◽  
Johannes Dantas de Medeiros ◽  
Iliezer Tamagno ◽  
...  
Keyword(s):  
Ultrasound Imaging ◽  
Embedded Software ◽  
Imaging Systems ◽  
Model Driven Engineering ◽  
Model Driven

scholarly journals Editorial to theme issue on model-driven engineering of component-based software systems

2017 ◽  
Vol 18 (1) ◽  
pp. 7-10 ◽  
Author(s):  
Federico Ciccozzi ◽  
Jan Carlson ◽  
Patrizio Pelliccione ◽  
Massimo Tivoli
Keyword(s):  
Software Systems ◽  
Model Driven Engineering ◽  
Theme Issue ◽  
Model Driven

scholarly journals XRTSDIC: model transformation from PIM to PSM

2018 ◽  
Vol 7 (1.8) ◽  
pp. 92
Author(s):  
G Ramesh
Keyword(s):  
Software Design ◽  
Model Transformation ◽  
Source Code ◽  
Object Oriented ◽  
Proof Of Concept ◽  
Model Driven Engineering ◽  
Model Driven ◽  
Relationship Analysis ◽  
Uml Class Diagram ◽  
Computer Aided Software Engineering

Computer Aided Software Engineering (CASE) has been growing faster in software industry. As part of it Model Driven Engineering (MDE) has been around for focusing on models and transforming them from one model to other model. The tool named Extensible Real Time Software Design Inconsistency Checker (XRTSDIC) proposed by us in previous paper supports UML modelling, design inconsistency checking and model transformation from UML to ERD to SQL. In this paper it is extended further to facilitate model transformation from PIM (UML class diagram) to PSM (source code). We proposed an algorithm and defined model transformation and consistency rules. The extended framework has provision for class relationship analysis and support for choosing different object oriented languages like C#, C++ and Java. While transforming the model, we used the concept of dialects. Dialect is the class with transformation functionality which has ability to adapt to syntax and semantics of chosen language. Different dialects are made available for different languages. Thus the proposed system is capable of transforming models and the prototype application we built and extended demonstrates the proof of concept. The empirical results revealed that the model transformation is consistent and accurate.

scholarly journals Using MDE to Develop Suitable User Interfaces for Older Adults: A Case Study

Proceedings ◽  
2018 ◽  
Vol 2 (19) ◽  
pp. 1201
Author(s):  
Yonatan Pineda Olarte ◽  
Fáber D. Giraldo ◽  
William J. Giraldo ◽  
Sergio F. Ochoa ◽  
Ramón Hervás
Keyword(s):  
Older Adults ◽  
User Interfaces ◽  
Emotional Support ◽  
Development Process ◽  
Model Driven Engineering ◽  
Adult Care ◽  
Model Driven ◽  
Software Applications ◽  
Important Challenge

Software applications have been identified as potentially suitable tools to assist older adults in several aspects of their lives, like healthcare, emotional support and personal security. However, developing usable and useful applications for this population represents an important challenge, given that no systematic solutions have been proposed to support such a process. This article hypothesizes that a model-driven engineering (MDE) approach can help generate suitable user interfaces for elderly people, making the development process repeatable and allowing the systematic reuse of design knowledge about products for these end-users. To determine the validity of such hypothesis, the article presents the results of a case study where a healthcare supporting system for older adults, developed by using an MDE approach, was evaluated in four older adult care centers. The results obtained were highly positive, showing MDE as a possible path to address systematically the development of these applications.

A Model Driven Engineering Approach to Reduce Large Queueing Networks

2017 ◽  
Vol 10 (2) ◽  
pp. 1-18 ◽  
Author(s):  
Ahlem Nasri ◽  
Abdelhabib Bourouis
Keyword(s):  
Residence Time ◽  
Queueing Networks ◽  
Model Transformation ◽  
Discrete Event Systems ◽  
Discrete Event ◽  
Exact Results ◽  
Model Driven Engineering ◽  
Transformation Techniques ◽  
Model Driven ◽  
Global Mean

Modeling complex systems, including discrete event systems, remains a challenge. The complexity and the size of such systems prevent understanding their models. This article proposes an approach for reducing queuing networks large models into smaller ones. The objective is to reduce the analysis as well as the simulation times in addition to the better understanding of the system under study. The basic idea is to divide the model into a set of smaller, hierarchically organized and more manageable sub-models, which are analyzed in isolation. The key contributions of this work are the substitution of each sub-model by a single M/G/8 station and the automation of the decomposition process using model transformation techniques. The main conclusion is that the reduction approach provides exact results for the global mean number of clients and mean residence time at the whole network.

Evolution in Model-Driven Software Product-Line Architectures

2009 ◽  
pp. 1280-1312 ◽  
Author(s):  
Gan Deng ◽  
Jeff Gray ◽  
Douglas C. Schmidt ◽  
Yuehua Lin ◽  
Aniruddha Gokhale ◽  
...  
Keyword(s):  
Model Transformation ◽  
Software Product Line ◽  
Product Line ◽  
Domain Model ◽  
Modeling Language ◽  
Model Driven ◽  
Transformation Rules ◽  
Domain Evolution ◽  
Software Product

This chapter describes our approach to modeldriven engineering (MDE)-based product line architectures (PLAs) and presents a solution to address the domain evolution problem. We use a case study of a representative software-intensive system from the distributed real-time embedded (DRE) systems domain to describe key challenges when facing domain evolution and how we can evolve PLAs systematically and minimize human intervention. The approach uses a mature metamodeling tool to define a modeling language in the representative DRE domain, and applies a model transformation tool to specify model-tomodel transformation rules that precisely define metamodel and domain model changes. Our approach automates many tedious, time consuming, and error-prone tasks of model-to-model transformation, thus significantly reducing the complexity of PLA evolution.

Sign in / Sign up

Export Citation Format

Share Document