Computation Independent Model Research Articles

A Web-based Methodology to Automate foundation of business process model in MDA by AI

MDA represents a fundamental standard established by the Object Management Group (OMG) that serves as a foundation for model-driven development. Within the MDA framework, the computation-independent model (CIM) holds the position of the initial abstraction level. As a business model, the CIM describes the requirements and environment of a business, playing a pivotal role in influencing all other levels of the MDA approach. Recognizing the significance of this stage in MDA, the primary objective of this paper is to propose a web-based approach for automating the construction of CIM. This approach utilizes web interfaces to gather relevant information from users about the business model. Furthermore, an illustrative example is presented to provide a clearer demonstration of the application of this approach.

Considerations on Utilizing the Object-Oriented Paradigm in the Development of an MRP-based Production Planning SystemConsiderations on Utilizing the Object-Oriented Paradigm in the Development of an MRP-based Production Planning System

Manufacturing companies today face an increasingly dynamic environment. Development of production planning systems requires approaches that offer flexibility in development of solutions. Applying the UML (Unified Modeling Language) and MDA (Model Driven Architecture) paradigm can ensure compatibility between applications developed on different platforms. The MDA approach to software development becomes an obvious choice. In this approach, the models drive the process of software development. These models are defined at different levels of abstraction to represent various aspects of the system. The transformation of models from one level of abstraction to another, or the transformation of models to executable code is performed by using automated transformation tools. The strength of MDA lies in the fact that it is based on widely used industry standards for visualizing, storing and exchanging software designs and models. The models in MDA are abstracted at three different levels – the Computation Independent Model (CIM), the Platform Independent Model (PIM) and the Platform Specific Model (PSM). The key to the success of MDA lies in automated or semi-automated model-to-model and model-to-code transformations. In this paper, we examine how a platform-independent model of an MRP-based production planning system can be created using MDA approach, from which several platform-specific systems can be achieved, as required.

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.

MDA-Based Approach for Blockchain Smart Contract Development

Blockchain smart contracts can support the decentralisation of business processes, but due to smart contracts’ specifics, their development is a complicated process. Introducing model-driven development principles in smart contract development can facilitate requirement specification, design, and implementation activities. This paper presents a model-driven development method MDAsmartCD (Model-Driven Architecture-based Smart Contract Development) to alleviate smart contract development by supporting the complete MDA life cycle, covering the definition of Computation-Independent Model, Platform-Independent Model, and two instances of Platform-Specific Models. In MDAsmartCD, model transformations (model-to-model and model-to-text) are used to produce smart contract code in the Hyperledger Fabric platform Go and the Ethereum platform Solidity programming languages. The method application was demonstrated by implementing the smart contract for the hackathon solution and executing the generated Solidity and Go smart contracts in the workflow of issuing certificates for hackathon participants. During the execution of the workflow, both deployed smart contracts behaved identically and recorded analogous results in respective blockchain data storages. This demonstrated that the MDAsmartCD method enables the generation of compilable and executable smart contract code, ready for deployment on a blockchain platform.

A methodology for transforming BPMN to IFML into MDA

Responding to rising information system complexity and the high expense of technological migration, model driven architecture (MDA) was created. As a result, the OMG advocates raising the abstraction level to overcome technological limitations. MDA seeks to describe the functional and performance requirements of an application on a platform independently. Using the MDA approach, the business process model and notation (BPMN), and interaction flow modeling language (IFML) standards, we represent a methodology that allows transforming semi-automatically from the computation independent model (CIM) level to the platform independent model (PIM) level; to achieve this a collection of unique rules for transforming in a semi-automatic manner from CIM to PIM were developed. At the CIM level, we create models of business process using the notation standard BPMN, and IFML is used to adapt PIM models with web-oriented graphical user interfaces (GUI). To properly demonstrate the transformation procedure from CIM to PIM models a case study of the order management process was presented.

Gathering Platform Independent Model from Computation Independent Model by using Ontologies

Gathering Platform Independent Model from Computation Independent Model by using Ontologies

Automatic Generation of Object-Oriented Code from the ReLEL Requirements Model

The final executable code should no longer be considered as a central element in a software development process but rather a naturally important component that results from a model transformation. The objective of the MDA (Model Driven Architecture) approach is to lift the lock of software development automation from the CIM (Computation Independent Model) requirements until the code of an application is obtained. Therefore, we have proposed in the framework of MDA an approach that consists of automatically generating object-oriented code from the CIM model represented by ReLEL (Restructuring extended Lexical Elaborate Language). ReLEL is a natural language-oriented model that represents both the client requirements and the conceptual level of a system. However, the MDA framework does not recommend the type of UML model that corresponds to each business activity. Consequently, automating the software development process from the CIM model specified by ReLEL becomes a complex task. Our strategy in this paper includes the instantiation of the ReLEL model in the Praxeme methodology, which models each of the company's concerns, grouped in a homogeneous whole, using the UML (Unified Modeling Language) and which considers the articulation of these aspects by adopting the MDA principle. To do this, we propose to automate the articulation that covers the intentional, semantic, logical, and software aspects of Praxeme. To validate our approach, we measure the coupling and cohesion of the UML class diagram obtained from the Java code generated from this article using the slicing technique. The results show that the coupling is weak, and the cohesion is strong. It can be deduced that the method proposed in this paper can produce a more reliable and efficient system.

A method and tools for prototyping components of intelligent systems based on transformations

The paper describes a method and tools for prototyping components of intelligent systems. These means are the parts of the PESoT technology based on generative and visual programming as well as the model transformations. The proposed method redefines the main stages and models of the standardized model-driven approach, in particular, Model Driven Architecture in the context of developing knowledge bases and expert systems that use the logical rules formalism. The description of the method is presented. Proposed tools include languages and software. Specifically, the Rule Visual Modeling Language and Personal Knowledge Base Designer are used for knowledge bases engineering including modeling and codification; the Transformation Model Representation Language and Knowledge Base Development System support model transformations and the rapid creation of computation-independent models. Described tools were applied to solve problems in the field of reliability and safety of technical systems.

A MBSE Application to Controllers of Autonomous Underwater Vehicles Based on Model-Driven Architecture Concepts

In this paper, a hybrid realization model is proposed for the controllers of autonomous underwater vehicles (AUVs). This model is based on the model-based systems engineering (MBSE) methodology, in combination with the model-driven architecture (MDA), the real-time unified modeling language (UML)/systems modeling language (SysML), the extended/unscented Kalman filter (EKF/UKF) algorithms, and hybrid automata, and it can be reused for designing controllers of various AUV types. The dynamic model and control structure of AUVs were combined with the specialization of MDA concepts as follows. The computation-independent model (CIM) was specified by the use-case model combined with the EKF/UKF algorithms and hybrid automata to intensively gather the control requirements. Then, the platform-independent model (PIM) was specialized using the real-time UML/SysML to design the capsule collaboration of control and its connections. The detailed PIM was subsequently converted into the platform-specific model (PSM) using open-source platforms to promptly realize the AUV controller. On the basis of the proposed hybrid model, a planar trajectory-tracking controller, which allows a miniature torpedo-shaped AUV to autonomously track the desired planar trajectory, was implemented and evaluated, and shown to have good feasibility.

A Model-Driven Realization of AUV Controllers Based on the MDA/MBSE Approach

This paper introduces a model-driven control realization, which is based on the systems engineering concepts of the model-driven architecture (MDA)/model-based systems engineering (MBSE) approach combined with the real-time UML/SysML, extended/unscented Kalman filter (EKF/UKF) algorithms, and hybrid automata, in order to conveniently deploy controllers of autonomous underwater vehicles (AUVs). This model also creates a real-time communication pattern, which can permit the designed components to be customizable and reusable in new application developments of different AUV types. The paper brings out stepwise adapted AUV dynamics for control that are then combined with the specialization of MDA/MBSE features as follows: the computation independent model (CIM) is defined by the specification of the use-case model together with hybrid automata to gather the requirement analysis for control; the platform-independent model (PIM) is then designed by specializing the real-time UML/SysML’s features including main control capsules that depict structures and behaviors of controllers in detail; and the detailed PIM is subsequently converted into the platform-specific model (PSM) by object-oriented platforms to rapidly implement the AUV controller. Based on this proposed model, a horizontal planar trajectory-tracking controller was deployed and tested that permits a miniature AUV possessing a torpedo shape to reach and follow the desired horizontal planar trajectory.

A Practical Specialization of MDA/MBSE Approach to Develop AUV Controllers

The model-driven architecture (MDA)/model-based systems engineering (MBSE) approach, in combination with the real-time Unified Modeling Language (UML)/Systems Modeling Language (SysML), unscented Kalman filter (UKF) algorithm, and hybrid automata, are specialized to conveniently analyze, design, and implement controllers of autonomous underwater vehicles (AUVs). The dynamics and control structure of AUVs are adapted and integrated with the specialized features of the MDA/MBSE approach as follows. The computation-independent model is defined by the specification of a use case model together with the UKF algorithm and hybrid automata and is used in intensive requirement analysis. The platform-independent model (PIM) is then built by specializing the real-time UML/SysML’s features, such as the main control capsules and their dynamic evolutions, which reflect the structures and behaviors of controllers. The detailed PIM is subsequently converted into the platform-specific model by using open-source platforms to quickly implement and deploy AUV controllers. The study ends with a trial trip and deployment results for a planar trajectory-tracking controller of a miniature AUV with a torpedo shape.

An Object-Oriented Systems Engineering Point of View to Develop Controllers of Quadrotor Unmanned Aerial Vehicles

The aerospace industry needs to be provided with system solutions to technologically challenging and mission-critical problems. Based on the industrial control point of view, development engineers must take costs and existing standards into account in order to effectively design, implement, and deploy control systems with reasonable costs. The customization and reusability are important factors associated with the production of new applications in order to reduce their costs, resources, and development time. In this work, the Model-Driven Architecture (MDA)/Model-Based Systems Engineering (MBSE) approach combined with the real-time Unified Modeling Language (UML)/Systems Modeling Language (SysML), Unscented Kalman Filter (UKF) algorithm, and hybrid automata is specialized to obtain a hybrid control model in order to conveniently deploy controllers of Quadrotor Unmanned Aerial Vehicles (Q-UAVs). This hybrid control model also provides a real-time capsule pattern, which allows the designed elements to be customizable and reusable in new applications of various multirotor UAVs of the Vertical Take-Off and Landing (VTOL) type. The Q-UAV dynamics and control architecture are combined with the MDA/MBSE specialization as follows: the Computation Independent Model (CIM) is defined by specifying the use-case model together with the UKF algorithm and hybrid automata to intensively gather the control requirements. The Platform Independent Model (PIM) is then designed by specializing the real-time UML/SysML’s features to obtain the main control capsules, ports, and protocols, together with their dynamic evolution. The detailed PIM is subsequently transformed into the PSM by open-source platforms to rapidly implement and deploy the Q-UAV controller. The paper ends with trial flights and deployment results that show good feasibility to be used for a trajectory-tracking controller of a low-cost Q-UAV. In this case study, the Q-UAV controller is implemented with the simulation model in the OpenModelica tool. The obtained simulation results then allow the main control elements and their properties to be defined, as well as building the implementation libraries in the Arduino environment based on C++ language to quickly perform the realization model in the ATMEGA32-U2 and STM32 Cortex-M4 microcontrollers.

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.

Transformations’ Study Between Requirements Models and Business Process Models in MDA Approach

Abstract Models transformation has become in the last decade, the primary key in the Model Driven Architecture (MDA) approach. Most of these models’ transformation are made between one or many abstraction levels (higher level, average level, or lower level). For that, the Object Management Group (OMG) offers for the MDA approach three abstraction levels, which are “Computation Independent Model” (CIM: the higher abstraction level), “Platform Independent Model” (PIM: average abstraction level) and “Platform Specific Model” (PSM: lower abstraction level). Hitherto, most researchers focused on the transformation between average abstraction level and lower abstraction level because those levels have multiple common points. However, the transformation between higher abstraction level and average abstraction level is rarely discussed because they are two distinct levels that can contain higher abstraction model nature, such as Requirements models and Business Process models. Therefore, our contribution in this paper is to study different transformations approaches between Requirements and Business Process models in the higher and average MDA abstraction levels. To do so, we study the selected approaches, analyze the results descriptively, then discuss them, plus propose new taxonomies based on the deduced evaluation criteria.

Towards a Generation of Class Diagram from User Stories in Agile Methods

Abstract Model-Driven Architecture (MDA) is a framework for software development processes that allows an automatic transformation from a business process model to the code model. In MDA there are two transformation kinds: Transformation from the Computation independent model (CIM) to platform-independent model (PIM), and transformation from PIM to platform-specific model (PSM). In this paper, we based on CIM to PIM transformation. This transformation is done by developing a platform that generates a class diagram, presented in XMI file, from specifications that are presented in user stories, which are written in natural language (English). We used a natural language processing (NLP) tool named Stanford CoreNLP for extracting of the object-oriented design elements. Applying our approach to several case studies has given good results.

Model-driven development of self-adaptive multi-agent systems with context-awareness

Self-adaptive systems are complex and operate in dynamic and heterogeneous environments. They have to dynamically modify their behaviour at run-time in response to different kinds of changes. This paper presents a methodology to develop context-aware self-adaptive systems by employing the model driven architecture (MDA) and agent-oriented technology advantages. The approach aims to combine these two promising technologies to overcome the complexity of developing such systems. The methodology focuses on the key issues in the analysis and design of self-adaptive multi-agent systems. Different abstraction levels based on MDA has been proposed and mappings between models in these levels provided. These mappings bridge the gap between the high-level models produced in computation independent (CIM) and platform independent models (PIM) as well as the low-level models based on specific implementation platform called SADE (Self-adaptation Development Environment). The proposed approach has been evaluated through a case study described in the paper.

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

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.

An ontological model based on the ontology driven architecture paradigm for a middleware in the management of nano-devices in a smart environment

In this paper is proposed an ontology framework for an autonomic reflective middleware for the management of nanodevices, which is based on the ontology-driven architecture paradigm. In this paper are presented the different levels of the ontology driven architecture model. At the first level, the computation independent model level defines the different ontologies of the nanotechnology domain, like a taxonomy of nanodevices, among others. The second level is the platform independent model level, where are defined the different ontologies for the deployment of the platform, which are the autonomic computation for the autonomous behavior of the middleware, data analytics that describes the analysis process of nanodata, and service-oriented architecture because the autonomic reflective middleware is defined as a multi-agent system oriented by services.

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.

An Automatic Transformation Method from the E3value Model to IFML Model: An MDA Approach

Nowadays the software industry has known a significant growth, while the end-users have become very demanding. In this sense, the model transformation has become one of the essential solutions to ensure competitiveness in the field of the software industry domain. For that, the Object Management Group (OMG) proposes for the Model-Driven Architecture (MDA) approach three abstraction levels, namely Computation Independent Model (CIM), Platform Independent Model (PIM) and Platform Specific Model (PSM). Therefore, our contribution in this paper is to shed more light on the first MDA transformation, which is the transformation from CIM to PIM levels. We propose a disciplined Model-Driven approach for the e-business information system, which generates the IFML (Interaction Flow Modeling Language) model automatically in the PIM level from business value model in the CIM level, using the ATL transformation language. For this purpose, the business value model is illustrated by the E3value model, whereas, the IFML model exhibits the front-end applications content, interface composition, user interaction and control behavior for several kinds of applications, such as web applications, mobile applications and desktop applications.