Model-driven Engineering Process Research Articles

Agile model-driven re-engineering

AbstractIn this paper we describe an Agile model-driven engineering (MDE) approach, AMDRE, for the re-engineering of legacy systems. The objective is to support the reuse of business-critical functionality from such systems and the porting of legacy code to modernised platforms, together with technical debt reduction to improve the system maintainability and extend its useful life. AMDRE uses a lightweight MDE process which involves the automated abstraction of software systems to UML specifications and the interactive application of refactoring and rearchitecting transformations to remove quality flaws and architectural flaws. We demonstrate the approach on Visual Basic, COBOL and Python legacy codes, including a finance industry case. Significant quality improvements are achieved, and translation accuracy over 80% is demonstrated. In comparison to other MDE re-engineering approaches, AMDRE does not require high MDE skills and should be usable by mainstream software practitioners.

Guest editorial to the theme section on AI-enhanced model-driven engineering

This theme section brings together the latest research at the intersection of artificial intelligence (AI) and model-driven engineering (MDE). Over the past years, we have witnessed a substantial rise of AI successfully applied to different domains, including software development and MDE. Dedicated events at the intersection of AI and MDE have been created, too, such as the MDE Intelligence workshop series co-located with the MODELS conference. This theme section covers research contributions integrating AI components into MDE approaches—increasing the current benefits of MDE processes and tools and pushing the limits of “classic” MDE with the goal to provide software and systems engineers with the right techniques to develop the next generation of highly complex model-based systems—and applications of MDE to the development of AI components. In total, nine submissions were accepted in the theme section after a thorough peer-reviewing process.

Computer-aided design for building multipurpose routing processes in discrete event simulation models

Good domain-modeling enables an appropriate separation of concerns that improves quality properties in the simulation models, such as modifiability and maintainability. In this paper, the interplay of abstraction and concreteness in advancing the theory and practice of Modelling and Simulation is improved using the Model-Driven Engineering levels for building simulation models devoted to routing processes. The definition of this type of processes is detailed as a domain-model conceived as an abstraction defined in a graph model. Such abstraction turns into a set of formal simulation models that are (later) translated into an executable implementation. The final simulation models are specified using Routed DEVS formalism. The methodological proposal is accomplished with the development of a Modelling and Simulation graphical software tool that uses the set of models (defined in terms of the Model-Driven Engineering approach) as the core of its operation. This graphical software tool is developed as a plug-in for Eclipse Integrated Development Environment with aims to take advantage of existent Modeling and Simulation software. Therefore, the usefulness of graphical modeling for supporting the development of the simulation models is empowered with a Model-Driven Engineering process. The main benefit obtained when the Model-Driven Engineering approach is used for modeling an abstraction of the final simulation model is a clear reduction of formalization and implementation times.

A Platform-Aware Model-Driven Embedded Software Engineering Process Based on Annotated Analysis Models

In this work a platform-aware model-driven engineering process for building component-based embedded software systems using annotated analysis models is described. The process is supported by a framework, called MICOBS, that allows working with different component technologies and integrating different tools that, independently of the component technology, enable the analysis of non-functional properties based on the principles of composability and compositionality. An actor, called Framework Architect, is responsible for this integration. Three other actors take a relevant part in the analysis process. The Component Provider supplies the components, while the Component Tester is in charge of their validation. The latter also feeds MICOBS with the annotated analysis models that characterize the extra-functional properties of the components for the different platforms on which they can be deployed. The Application Architect uses these components to build new systems, performing the trade-off between different alternatives. At this stage, and in order to verify that the final system meets the extra-functional requirements, the Application Architect uses the reports generated by the integrated analysis tools. This process has been used to support the validation and verification of the on-board application software for the Instrument Control Unit of the Energetic Particle Detector of the Solar Orbiter mission.

A framework for Model-Driven Engineering of resilient software-controlled systems

Emergent paradigms of Industry 4.0 and Industrial Internet of Things expect cyber-physical systems to reliably provide services overcoming disruptions in operative conditions and adapting to changes in architectural and functional requirements. In this paper, we describe a hardware/software framework supporting operation and maintenance of software-controlled systems enhancing resilience by promoting a Model-Driven Engineering (MDE) process to automatically derive structural configurations and failure models from reliability artifacts. Specifically, a reflective architecture developed around digital twins enables representation and control of system Configuration Items properly derived from SysML Block Definition Diagrams, providing support for variation. Besides, a plurality of distributed analytic agents for qualitative evaluation over executable failure models empowers the system with runtime self-assessment and dynamic adaptation capabilities. We describe the framework architecture outlining roles and responsibilities in a System of Systems perspective, providing salient design traits about digital twins and data analytic agents for failure propagation modeling and analysis. We discuss a prototype implementation following the MDE approach, highlighting self-recovery and self-adaptation properties on a real cyber-physical system for vehicle access control to Limited Traffic Zones.

Automatic verification of behavior preservation at the transformation level for relational model transformation

The correctness of model transformations is a crucial element for model-driven engineering of high-quality software. In particular, behavior preservation is an important correctness property avoiding the introduction of semantic errors during the model-driven engineering process. Behavior preservation verification techniques show some kind of behavioral equivalence or refinement between source and target model of the transformation. Automatic tool support is available for verifying behavior preservation at the instance level, i.e., for a given source and target model specified by the model transformation. However, until now there is no sound and automatic verification approach available at the transformation level, i.e., for all source and target models. In this article, we extend our results presented in earlier work (Giese and Lambers, in: Ehrig et al (eds) Graph transformations, Springer, Berlin, 2012) and outline a new transformation-level approach for the sound and automatic verification of behavior preservation captured by bisimulation resp. simulation for outplace model transformations specified by triple graph grammars and semantic definitions given by graph transformation rules. In particular, we first show how behavior preservation can be modeled in a symbolic manner at the transformation level and then describe that transformation-level verification of behavior preservation can be reduced to invariant checking of suitable conditions for graph transformations. We demonstrate that the resulting checking problem can be addressed by our own invariant checker for an example of a transformation between sequence charts and communicating automata.

A tool to support the definition and enactment of model-driven migration processes

A tool to ease the implementation of MDE-based migration processes is presented.Enactment of MDE-based migration process models is supported.When process models are enacted, manual tasks are added to a task management tool.Lack of enactment of SPEM is overcome with a DSL for defining migration processes.Open source tools (e.g. Mylyn) are used to manage manual tasks in MDE processes. One of the main challenges to achieve the industrial adoption of Model-Driven Engineering (MDE) paradigm is building tools able to support model-driven software processes. We present a tool for the definition and enactment of model-driven migration processes. We have created a SPEM-based language for defining Abstract Migration models that represent an MDE migration solution for a particular pair of source and target technologies. For each legacy application to be migrated, the Abstract Migration model is transformed into a Concrete Migration model which contains all the information needed for the enactment. Then, these models are enacted by means of a process interpreter which generates Trac tickets for executing automated tasks by means of Ant scripts and managing manual tasks with the Mylyn tool.Our work has therefore two main contributions: i) it proposes a novel solution for the enactment that integrates the execution of the automated tasks with the generation of tickets to support the manual tasks, and ii) it describes how MDE techniques can be used to implement process engineering tools, in particular migration processes. The article presents the approach and describes in detail the essential aspects of our tool.

Automatic test case generation from requirements for industrial cyber-physical systems

Abstract Industrial cyber-physical systems require complex software to orchestrate heterogeneous mechatronic components and control physical processes. This software is typically developed and refined iteratively in a model-driven fashion. Testing such multi-dimensional systems is extremely difficult as subsequent refinements may not correspond accurately with previous system models. We propose a framework to generate test-cases from functional requirements at all stages in the model-driven engineering process. A requirements ontology initially created during requirements engineering is iteratively refined such that test-cases can be generated automatically. An industrial water process system case study illustrates the strengths of the proposed formalism. We also present an automatic test-case generation and execution tool called REBATE (REquirements Based Automatic Testing Engine).

Experimental Verification of Ecological Interface Prototype Issued by an Automated Generation Tool

Vicente and Rasmussen have developed a method called Ecological Interface Design (EID) in the field of cognitive engineering .[1] In this context, we proposed a software tool named Anaxagore, that can assist the EID process for a rapid implementation of user interface prototypes. In a first stage, models based on standardized structure-functional diagram are computed .[2] In a second stage, these diagrams as inputs are transformed through a model-driven engineering process, involving a library of ecological graphical representations and an interface background. Then, an ecological interface prototype can be generated. Previously, Anaxagore was used to generate conventional synoptic representation .[3] To validate its EID extended version, an experimental protocol has been established. The experiment was conducted at the National Maritime College, with 14 naval officers randomly divided into two groups according to the used interface. After a preliminary training of participants to the use of the interfaces, four scenarios were simulated during the experiment. For each scenario, the performance was evaluated by a success score and by measuring the time to detect and understand failure. With the EID interface generated by Anaxagore, faster detection time and better diagnosis accuracy were observed. Anaxagore seems to constitute a response for assisting the rapid prototyping of ecological interface.

A Graph Based Approach to Trace Models Composition

A model driven engineering process involves different and heterogeneous models that represent various perspectives of the system under development. The model composition operation allows combining those sub-models into an integrated view, but remains a tedious activity. For that, traceability information must be maintained to comprehend the composition effects and better manage the operation itself. Against this context, the current paper describes a framework for model composition traceability. We consider the traces generation concern as a crosscutting concern where the weaving mechanism is performed using graph transformations. A composition specification case study is presented to illustrate our contribution.

Reusable Aspect Models versus Theme/UML: the Aspect-Oriented Code Generation Perspective

The integration of aspect oriented modeling approaches with model-driven engineering process achieved through their direct transformation to aspect-oriented code is expected to enhance the software development from many perspectives. This study aims to assess the existing UML-based aspect-oriented modeling techniques from the perspective of their suitability with regards to integration into model-driven engineering process through aspect-oriented code generation. For this purpose, we selected two mature aspectoriented modeling approaches, Reusable Aspect Models and Theme/UML, and proceeded to evaluate them in a detailed way from the specific perspectives of design and its mapping to the implementation code. The in-depth comparison reveals some points equally shared by both approaches, and identifies some areas where one has advantage over the other. The study concludes that the Reusable Aspect Models approach may be seen as a preferred approach to handling the task of integration using aspect-oriented code generation.

A model-integrated authoring environment for privacy policies

Privacy policies are rules designed to ensure that individuals’ health data are properly protected. Health Information Systems (HIS) are legally required to adhere to these policies. Since privacy policies are imposed on complex software systems, it is extremely hard to reason about their conformance and consistency. In order to address this problem, we have created a model-driven authoring environment to formally specify privacy policies originally defined in legal terms. In our observation, appropriate formalization of our policy language enabled formal analysis of its policies; these features were key to a successful model-driven engineering process. In this paper we present our modeling language and show its semantic anchoring to analyzable logic programs. We report on several projects where our approach is being applied and validated.

Aspect-Oriented Modeling Approaches and Aspect Code Generation

The integration of aspect oriented modeling approaches with model-driven engineering process achieved through their direct transformation into aspect-oriented code can enhance the software development from many perspectives. However, since no aspect modeling technique has been adopted as the standard so far, it becomes imperative to compare all existing techniques on the basis of some appropriate criteria. This study aims to assess existing UML-based aspect-oriented modeling techniques from the perspective of their suitability with regards to integration into model-driven engineering process through aspect-oriented code generation. For this purpose, an evaluation framework has been defined and employed to evaluate 14 well-published, UML-based aspect-oriented modeling approaches. Results of this comparison show that a majority of these approaches works well to handle the basic modeling tasks. However, in the context of their integration into model-driven engineering process, these approaches need to be improved from various perspectives.

A model driven engineering process of platform neutral agents for ambient intelligence devices

Ambient intelligence (AmI) systems are now considered a promising approach to assist people in their daily life. AmI proposes the development of context aware systems equipped with devices that can recognize your context and act accordingly. Agents provide an effective way to develop such systems since agents are reactive, proactive and exhibit an intelligent and autonomous behavior. However, current agent approaches do not adequately fulfill the requirements posed by AmI systems. From a modeling point of view, the aim should be to help in the design by providing adequate tools that assist in the development of important properties of AmI systems, such as context-awareness; and from an implementation point of view, agent technologies must be adapted to the diversity of AmI devices and communication technologies. As a solution to these issues we propose a Model driven engineering process, which supports the automatic generation of agent-based AmI systems. The source metamodel is PIM4Agents, a general purpose agent metamodel that we have adapted to support the explicit modeling of context aware systems, and the target metamodel is Malaca, an aspect-oriented agent architecture. Aspect-orientation makes Malaca platform-neutral for FIPA compliant agent platforms, simplifying the model driven process. The solution generates MalacaTiny agents, an implementation of Malaca that is able to run in AmI devices. We have evaluated the convenience of applying a model driven approach by measuring the degree of automation of our process and we have evaluated MalacaTiny for mobile phones by assessing different parameters, related to the scarcity of resources in AmI systems. All the results obtained are satisfactory.

Model-driven automation for simulation-based functional verification

Developing testbenches for dynamic functional verification of hardware designs is a software-intensive process that lies on the critical path of electronic system design. The increasing capabilities of electronic components is contributing to the construction of complex verification environments that are increasingly difficult to understand, maintain, extend, and reuse across projects. Model-driven software engineering addresses issues of complexity, productivity, and code quality through the use of high-level system models and subsequent automatic transformations. Reasoning about verification testbench decomposition becomes simpler at higher levels of abstraction. In particular, the aspect-oriented paradigm, when applied at the model level, can minimize the overlap in functionality between modules, improving maintainability and reusability. This article presents an aspect-oriented model-driven engineering process and toolset for the development of hardware verification testbenches. We illustrate how this process and toolset supports modularized design and automatic transformation to verification environment-specific models and source code through an industry case study.

From misuse cases to mal-activity diagrams: bridging the gap between functional security analysis and design

Secure software engineering is concerned with developing software systems that will continue delivering its intended functionality despite a multitude of harmful software technologies that can attack these systems from anywhere and at anytime. Misuse cases and mal-activity diagrams are two techniques to model functional security requirements address security concerns early in the development life cycle. This allows system designers to equip their systems with security mechanisms built within system design rather than relying on external defensive mechanisms. In a model-driven engineering process, misuse cases are expected to drive the construction of mal-activity diagrams. However, a systematic approach to transform misuse cases into mal-activity diagrams is missing. Therefore, this process remains dependent on human skill and judgment, which raises the risk of developing mal-activity diagrams that are inconsistent with the security requirements described in misuse cases, leading to the development of an insecure system. This paper presents an authoring structure for misuse cases and a transformation technique to systematically perform this desired model transformation. A study was conducted to evaluate the proposed technique using 46 attack stories outlined in a book by a former well-known hacker (Mitnick and Simon in The art of deception: controlling the human element of security, Wiley, Indianapolis, 2002). The results indicate that applying the proposed technique produces correct mal-activity diagrams from misuse cases.

Rigorous identification and encoding of trace-links in model-driven engineering

Model-driven engineering (MDE) involves the construction and manipulation of many models of different kinds in an engineering process. In principle, models can be used in the product engineering lifecycle in an end-to-end manner for representing requirements, designs and implementations, and assisting in deployment and maintenance. The manipulations applied to models may be manual, but they can also be automated--for example, using model transformations, code generation, and validation. To enhance automated analysis, consistency and coherence of models used in an MDE process, it is useful to identify, establish and maintain trace-links between models. However, the breadth and scope of trace-links that can be used in MDE is substantial, and managing trace-link information can be very complex. In this paper, we contribute to managing the complexity of traceability information in MDE in two ways: firstly, we demonstrate how to identify the different kinds of trace-links that may appear in an end-to-end MDE process; secondly, we describe a rigorous approach to defining semantically rich trace-links between models, where the models themselves may be constructed using diverse modelling languages. The definition of rich trace-links allows us to use tools to maintain and analyse traceability relationships.

Guest editorial to the theme issue on traceability in model-driven engineering

This issue of Software and Systems Modeling, and part of the issue that follows, are dedicated to the theme of traceability in model-driven engineering (MDE). Traceability is a fundamental concern in MDE processes, where models are related via application of different model management operations, such as model-to-model transformations, modelto-text transformations, model merging, model comparison, and many others. MDE emphasises on the application of automated model management operations, and substantial traceability information can be produced as a side-effect of applying these operations. In addition, in realistic MDE processes, traceability information can be produced by hand, through engineers manually relate MDE artefacts, or relate MDE artefacts with other artefacts (such as requirements documents). Overall, there are many challenges to traceability in MDE, ranging from managing large traceability models, to synchronizing models, and to keep traceability information consistentwhenmodels are beingmodified automatically and manually. This theme issue presents state-ofthe-art research on these and other challenges. Since 2005, the ECMDA-FA/ECMFA Workshop on Traceability has presented the leading research on traceability in MDE. After the 2008 workshop in Berlin, authors of accepted papers from the previous four workshops were invited to submit their latest results (perhaps derived from their workshop papers) to this theme issue. At the same time, an open call was issued, soliciting submissions from the

Using weaving models to automate model-driven web engineering proposals

Model-Driven Web Engineering is a new approach for Web Information Systems development whose basic assumption is the consideration of models as first-class entities. Basically, each step of the process consists of a model transformation that generates one or more target models from one or more source models. However, the special nature of the behavioural models implied at the early stages of a Model-Driven Web Engineering process complicates the specification of a model transformation that works for any input model. In such situations, it is not feasible to automate the whole development process since some design decisions have to be considered before executing each transformation. This work shows how we solve this problem in SOD-M, a model-driven approach for the development of Service-Oriented Web applications. The technique proposed is based on the use of weaving models as annotation models and it can be easily generalised to other domains and contexts.

Model-Driven Constraint Engineering

Precise specification of meta-models is an important prerequisite for the successful application of a model-driven engineering (MDE) process. One means of precise specification are textual constraints. However, the task of constraint de- velopment is time-consuming and error-prone if done manually. In this paper, we present both a methodology and a tool for developing constraints in a systematic way that can be integrated into a CASE tool. Thus, we provide a semi-automated means for integrating constraints into the MDE process. Our approach is based on an extensible library of generic constraint patterns. Con- straint patterns can be combined to create complex constraints and easily parame- terized in a CASE tool. Moreover, we show how these parameterized patterns are transformed into platform-independent or platform-specific constraints by a model transformation.