Model-Driven Engineering and Software Development

Companies have been struggling to manage and maintain their legacy information systems because upgrading said systems has been a complex challenge. Many times, requirements changes are difficult to be properly managed, leading to legacy information system requirements deterioration. To overcome or reduce such problems we propose the XIS-Reverse, a software reverse engineering approach. XIS-Reverse is a model-driven reverse engineering approach that takes database artefacts and user preferences as input, and generates high-level models and specifications of these legacy information systems. This paper presents the evaluation of XIS-Reverse using two real-world information systems, provides an assessment of its interoperability with an existent framework and discusses its main challenges and benefits.

With the growing complexity of embedded systems, a systematic design process and tool are vital to help designers assure that their design meets specifications. The design of an embedded system evolves through multiple modeling phases, with varying levels of abstraction. A modeling toolkit should also support the various evaluations needed at each stage, in the form of simulation, formal verification, and performance evaluation. This chapter introduces our model-based engineering process with the supporting toolkit TTool, with two main design stages occurring at a different level of abstraction. A system-level design space exploration selects the architecture and partitions functions into hardware and software. The subsequent software design phase then designs and assesses the detailed functionality of the system, and evaluates the partitioning choices. We illustrate the design phases and supported evaluations with a Smart Card case study.

Current state-of-the-practice and state-of-the-art of decision-making aids are inadequate for modern organisations that deal with significant uncertainty and business dynamism. This paper highlights the limitations of prevalent decision-making aids and proposes a model-based approach that advances the modelling abstraction and analysis machinery for complex dynamic decision-making. In particular, this paper proposes a meta-model to comprehensively represent organisation, establishes the relevance of model-based simulation technique as analysis means, introduces the advancements over actor technology to address analysis needs, and proposes a method to utilise proposed modelling abstraction, analysis technique, and analysis machinery in an effective and convenient manner. The proposed approach is illustrated using a near real-life case-study from a business process outsourcing organisation.

We present an architecture that enables run-time verification with executable models of behaviour. Our uniform modelling paradigm is logic-labelled finite-state machines (LLFSMs). Behaviours are constructed by parameterizable, loadable, and suspendable LLFSMs executed in predictable sequential schedules, but they are also verified at run-time by LLFSMs as well. Our architecture enables runtime verification (to monitor the quality of software during execution) as well as set up, tear down, and enforcement of quality behaviour during runtime. The LLFSMs models are executable and efficient because they are compiled (not interpreted). The LLFSMs can be derived from requirement engineering approaches such as behaviour trees, and also validated using test-driven development. However, in situations where software evolves incorporating elements of adaptive systems or machine learning, the software in execution may have never existed during development. We demonstrate the features of the architecture with illustrative case studies from robotics and embedded systems.

The high cognitive complexity of model-driven software product line engineering is due to the fact that developers have to manually create, edit, and maintain multi-variant artifacts. As a solution, the adaptation of filtered editing has been proposed recently. Filtered editing can be applied in a static or in a dynamic way; in the latter case, new co-evolution problems occur when considering the evolving relationships between the historical, the variant, and the product dimension. This paper investigates, formally defines, and demonstrates by examples nine consistency constraints connected to dynamic filtered editing. Furthermore, we suggest a consistency-preserving editing model comprising four operations that synchronize a transparent multi-version repository with a single-version workspace view being presented to the user: check-out, modify, commit, and a novel operation, migrate, which prepares the workspace for the subsequent edit session. Several advantages of dynamic over static filtered or unfiltered editing are confirmed both on a theoretical and on an experimental basis.

Original equipment manufacturers (OEMs) build mechatronic, variant-rich systems using components from several suppliers in industry sectors like automation. The OEMs have to integrate the different components to the overall system based on a virtual layout. For this purpose, the suppliers provide geometrical information via the standardized exchange format STEP. Beyond the geometrical information, the OEMs need additional logical and technical information for the integration task as well as the variant handling. For that reason, STEP provides an extension mechanism for extending and tailoring STEP to project-specific needs. However, extending STEP requires extending several capabilities of all involved tools, which prevents the project-specific utilization of the STEP extensions mechanism. In order to cope with this problem, we presented in previous work a model-driven approach enabling the flexible specification of STEP extensions and particularly the automatic derivation of the required capability extensions for two involved tools. Nevertheless, the OEMs still need to apply several engineering tools from different domains to consider logical as well as geometrical constraints between product variants. In this paper, we hence combine our previous approach with extended feature models that consider conventional logical and particularly geometrical information, thereby enabling a holistic product line engineering for mechatronic systems. By means of an automation production system example, we illustrate how OEMs can orchestrate their overall supply and development processes through the combination of both approaches.

Diagrammatic modeling plays an important role in model driven software engineering as it can be used to define domain-specific modeling languages. During the modeling phase, software designers encode domain knowledge into models. Complex models of software systems often consist of heterogeneous models representing various aspects of a system such as structure, behavior, security, and resources. In this paper, we present a formal modeling approach for the composition of heterogeneous models. We apply the technique for modeling the optimization of distributed resources using game theory.

Model-driven development practices are used to improve software quality and developer productivity. However, the design and implementation of an environment with which software can be produced from models is not an easy task. One part of such an environment is the model execution approach: how is the model processed and translated into running software? Experts state that code generation and model interpretation are functionally equivalent. However, a survey that we conducted among several organizations shows that there is a lack of knowledge and guidance in designing the execution approach. In this article we present the results of a literature study on the advantages of both interpretation and generation. We also show, using a case study, how these results can be utilized in the design decisions. Finally, a decision support framework is proposed that can provide the guidance and knowledge for the development of a model-driven engineering environment.

Current systems engineering efforts are increasingly driven by trade-offs and limitations imposed by multiple factors: Growing product complexity as well as stricter regulatory requirements in domains such as automotive or aviation necessitate advanced design and development methods. At the core of these influencing factors lies a consideration of competing non-functional concerns, such as safety and reliability, performance, and the fulfillment of quality requirements. In an attempt to cope with these aspects, incremental evolution of model-based engineering practice has produced heterogeneous tool environments without proper integration and exchange of design artifacts. In order to overcome these shortcomings of current engineering practice, we propose a holistic, model-based architecture and analysis framework for seamless design, analysis, and evolution of integrated system models. We describe how heterogeneous domain-specific modeling languages can be embedded into a common general-purpose model in order to facilitate the integration between previously disjoint design artifacts. A case study demonstrates the suitability of this methodology for the design of a safety-critical embedded system, a hypothetical gas heating, with respect to reliability engineering and further quality assurance activities.

Software integration testing is a critical step in the software development lifecycle, as modern software systems often need to interact with many other distributed and heterogeneous systems. However, conducting integration testing is a challenging task because application production environments are generally neither suitable nor available to enable testing services. Additionally, replicating such environments for integration testing is usually very costly. Testing environment emulation is an emerging technique for creating integration testing environments with executable models of server side production-like behaviors. Aiming to achieve high development productivity and ease of use for business users, we propose a novel domain-specific modeling approach for testing environment emulation. Our approach is based on model-driven engineering, and abstracts software service interfaces, or endpoints, into different request message processing layers. Each of these layers represents a modeling problem domain. To model endpoints, we develop a suite of domain-specific visual languages for modeling these interface layers. To build a testing environment, we have created a supporting toolset to transform endpoint models to executable forms automatically. We provide a set of example scenarios to demonstrate the capabilities of our approach. We have also conducted a user study that demonstrates the acceptance of our approach by IT professionals and business users.

One way to design complex systems is to use an event-driven architecture. Model Driven Engineering (MDE) promotes the use of different abstract concepts, among which are the UML state machine, composite structure elements and their associated visualizations, as a powerful means to design such an architecture. MDE seeks to increase software productivity by automatically generating executable code from state machines and composite structures. To this end, a code generation approach in MDE should support all model elements used at the design level. However, existing code generation approaches and tools are still limited, especially when considering concurrency, event types, and pseudo states such as history and junction. Furthermore, in the literature, the combination of component-based design and UML state machines is supported by only a few existing approaches. This paper explores this combination and provides code generation patterns and framework-based tooling support for the combination and complete and efficient code generation from UML state machines. We extend a well-known state machine code generation pattern with concurrency support. In order to verify the semantics of generated code, we execute code generated by the proposed framework with a set of state-machine examples that are part of a test-suite described in the recent OMG standard Precise Semantics Of State Machine. The traced execution results comply with the standard and are a good hint that the execution is semantically correct. Regarding code efficiency, the code generated by our approach supports multi-thread-based concurrency, and the size of the generated code is smaller compared to considered approaches. Moreover, we demonstrate the practicality, feasibility, and scalability of the proposed approach with two case studies.

Our claim is, that given a linked data service ecosystem, the UI for a business process can be modelled once and be automatically generated for the integration into different contexts. The models can be combined to automatically build complex UIs for combined linked data applications – thus, supporting the aggregation of applications on the user interface level. This paper presents an ontology-based, model-driven approach for modelling UIs for the automatic generation of dialog-based applications, providing output understood by associated linked data services. In addition, the paper shows that the approach is suited to combine UI models as components to build aggregated linked data service UIs.

Metamodels, defining the determinant concepts of a domain, constitute the core components in Model-Driven Engineering. Together with their depending artifacts, e.g., models and transformations, they form modeling ecosystems. To be operable, it is essential for a modeling ecosystem to be in a valid state with respect to the various interdependencies between the metamodel and its depending artifacts as well as among the depending artifacts. Consequently, in case of metamodel evolution, caused by, e.g., changing requirements, the depending artifacts have to be co-evolved accordingly to keep the system in a valid state. With respect to modeling ecosystems, special effort has to be laid to a consistent co-evolution across the different kinds of artifacts and their relationships. Although several approaches for the co-evolution of depending artifacts have been proposed, there was no special focus on an ecosystem-wide perspective of co-evolution, yet. Therefore, this paper focuses on co-evolution in modeling ecosystems by discussing the various components of a modeling ecosystem and their relationships, depicting the respective co-evolution process, proposing an evaluation framework for co-evolution, and applying this framework to current approaches. Based on this evaluation we derive lessons learned and present future research directions.

Software systems need to evolve continuously in order to avoid becoming less useful. However, repeated changes in the software may impede the inner quality of the system. Modularity is considered an important aspect of a good inner quality, and the functional decomposition is an approach that enables to achieve good modularity. Nevertheless, existing approaches for functional decomposition ignore implementation efforts, and this may cause a situation where the required changes are too costly to implement. In this paper we describe an approach to employ functional decomposition for software architecture evolution considering also the implementation efforts.

Data Warehouse (DW) evolution is becoming a critical research topic for several organizations mainly because their analytical data change permanently and rapidly due to changes in the data source and decision-makers’ requirements. This paper presents an MDA-compliant (Model Driven Architecture) approach and a software tool for propagating automatically the evolutions of the data source model and OLAP (On-Line Analytical Processing) requirements towards the multidimensional DW model. More accurately, we propose a DWE (Data Warehouse Evolution) framework. Being MDA compliant, we perform this DW evolution through Model-To-Model transformation rules we have defined as QVT (Query/View/Transformation) along with M2T (Model-To-Text) transformations realized using Acceleo templates. Thus, the evolution operations (Create table, Add column…) are firstly modeled, secondly transformed into multidimensional evolution operations (Create dimension, hierarchy…), and then are used with Acceleo templates for generating the DW alteration code.

The amount of available connectible devices and Internet of Things (IoT) solutions is increasing as such equipments are becoming popular and widely available on the market. This growth in popularity goes together with a keen interest for smart homes where individuals deploy ad hoc solutions in their houses. However, the task to translate the users’ needs into a concrete IoT infrastructure is not straightforward and often require to deal with proprietary APIs, complex interconnection protocols, and various technical details, so that the link to user requirements may be lost, hampering the validity of their interaction properties. In order to define and manipulate devices deployed in domestic environments, we propose IoTDSL, a Domain-Specific Language relying on a high-level rule-based language. Users in charge of the deployment of IoT infrastructures are able to describe and combine in a declarative manner structural configurations as well as event-based semantics for devices. Modellers are then freed from technical aspects, playing with high-level representations of devices. The events orchestration is transferred to a dedicated component where high-level rules are automatically translated into a Complex Event Processing (Cep) facility meant to evaluate and trigger runtime events. Additionally, simulation code can be generated to play with user-defined configurations.

In scenario-based programming (SBP), the semantics, which enables direct execution of these intuitive specifications, calls, among others, for synchronizing concurrent scenarios prior to every event-selection decision. Doing so even when the running scenarios are distributed across multiple physical system components, may degrade system performance or robustness. In this paper we describe a technique for automated distribution of an otherwise-centralized specification, such that much of the synchronization requirement may be relaxed. The technique calls for replicating the entire scenario-based executable specification in each of the components, locally transforming it in a component-specific manner, and reducing the synchronization requirements to very specific and well-defined points during execution. Our evaluation of the technique shows promising results. Given that relaxed synchronization can lead to what appears as different runs in different components we discuss various criteria for what would constitute acceptable differences, or divergence, in the parallel, distributed runs of almost-identical copies of a single specification.

This paper incorporates and substantially extends the material of the paper published in MODLESWARD’17 Distributing Scenario-Based Models: A Replicate-and-Project Approach by the same authors [37].

Robots come out of the cage. Soon, it will be possible to interact with free-standing robots along an assembly line or in a manufacturing workshop (robotic co-working). New sensitive robot arms have appeared on the market [1] that slow down or stop when humans enter their context, which creates rich opportunities for collaboration between human and robots. But how to program them? This paper contributes an architectural design pattern to engineer software for robotic co-working with world-oriented modelling (WOM). We argue that robotic co-working always has to take place in smart rooms tracking the movements of humans carefully, so that the robotic system can automatically adapt to their actions. Because robotic co-working should be safe for humans, robots, and their work items, the robots should enter safe states before harmful encounters happen. Based on the safety automata in the style of [1], we suggest to engineer software for the smart rooms of human-robotic co-working with an explicit world model, an automaton of the world’s states, and a software variant space, a software variant family, which are related by a total activation mapping. This construction has the advantage that the world model is split off the software system to make its construction simpler, avoiding if-bloated code. Also, proofs about the entire smart system can be split into a proof about the world model and a proof obligation for the software variant space. Therefore, we claim that world-oriented modelling (WOM) simplifies the development of robotic co-working applications, leveraging the principle of separation of concerns for improved maintainability and quality assurance.