Model-Driven Engineering promotes the migration from code-centric to model-based software development. Systems consist of model collections integrating different concerns and perspectives, while semi-automated model transformations analyse quality attributes and generate executable code combining the information from these. Raising the abstraction level to models requires appropriate management technologies supporting the various software development activities. Among these, model comparison represents one of the most challenging tasks and plays an essential role in various modelling activities. Its hardness led researchers to propose a multitude of approaches adopting different approximation strategies and exploiting specific knowledge of the involved models. In this respect, almost no support is provided for the systematic evaluation of comparison approaches against specific scenarios and modelling practices, namely benchmarks. In this article we propose Benji, a framework for the automated generation of model comparison benchmarks. In particular, by giving a set of difference patterns and an initial model, users can generate model manipulation scenarios resulting from the application of the patterns on the model. The generation support provided by the framework obeys specific design principles that are considered as essential properties for the systematic evaluation of model comparison solutions, and are inherited from the general principles coming from evidence-based software engineering. The framework is validated through representative scenarios of model comparison benchmark generations.
Model-Driven Engineering has been widely recognised as a powerful paradigm for shifting the focus of software development from codingto modelling in order to cope with the rising complexity of modern systems. Models become the main artefacts in the development process and therefore undergo evolutions performed in different ways until the final implementation is produced. Moreover, modelling languages are expectedto evolve too and such evolutions have to be taken into account when dealing with model versioning. Since consistency between models and related metamodels is one of the pillars on which model-driven engineering relies, evolution of models and metamodels cannot be considered as independentevents in a model versioning system.This article exploits model comparison and merging mechanisms toprovide a solution to the issues related to model versioning when considering metamodel and model manipulations as concurrent and even misaligned. A scenario-based description of the challenges arising from versioning of models is given and a running example is exploited to demonstrate the proposed solutions.
In recent years, software product line development has been adopted by a growing number of companies. Within software product line development, one way of creating specific products is by using configuration files to control a given set of parameters of the product at run time. Often, configuration files are created manually and this may lead to a sub-optimal process with respect to development effort and error proneness. In this experience report, we describe our work in enabling the automatic generation of configuration files in the railway domain. We discuss a four-step approach whose generation mechanism uses concepts of generative programming. The approach is the outcome of a bottom-up effort leveraging the experiences and the results from our technology transfer activities with our industrial partner, Bombardier Transportation. We evaluate the applicability and the correctness of the proposed approach using the Aventra train family from Bombardier Transportation. Besides, we evaluate the ability of the proposed approach in mitigating the development effort and error proneness typical of traditional manual approaches. We performed expert interviews to assess the industrial relevance of the proposed approach and collect qualitative feedback on the perceived benefits and drawbacks. Eventually, for each of the four steps composing the proposed approach, we identify factors that might affect the adoption of the approach and use these factors for discussing the lessons we have learned.
Canonical software and systems modelling regards only models that conform to modelling languages and that are created in modelling tools. In practice, these models are often supplemented with free-form activities such as sketching and informal diagramming. Flexible modelling has been proposed to benefit from the combination of free-form activities, from relaxed to no conformance to modelling languages, and canonical modelling with more or less strict conformance of diagrammatic elements to modelling languages. Various tools and approaches have proposed mechanisms to support flexible modelling. In this paper, we report on a systematic literature review of these tools and approaches. We present an analysis of the existing body of knowledge in this area and discuss open research challenges that can help the modelling community identify promising next steps in this area.
In model-based development projects, models at different abstraction levels capture different aspects of a software system, e.g., specification or design. Inconsistencies between these models can cause inefficient and incorrect development. A tool-based framework to assist developers creating and maintaining models conforming to different languages (i.e. heterogeneous models) and consistency between them is not only important but also much needed in practice. In this work, we focus on assisting developers bringing about multi-view consistency in the context of agile model-based development, through frequent, lightweight consistency checks across views and between heterogeneous models. The checks are lightweight in the sense that they are easy to create, edit, use and maintain, and since they find inconsistencies but do not attempt to automatically resolve them. With respect to ease of use, we explicitly separate the two main concerns in defining consistency checks, being (i) which modelling elements across heterogeneous models should be consistent with each other and (ii) what constitutes consistency between them. We assess the feasibility and illustrate the potential usefulness of our consistency checking approach, from an industrial agile model-based development point-of-view, through a proof-of-concept implementation on a sample project leveraging models expressed in SysML and Simulink. A continuous integration pipeline hosts the initial definition and subsequent execution of consistency checks, it is also the place where the user can view results of consistency checks and reconfigure them.
During the development of complex systems, several different development artifacts are created and maintained. It is important to gain insight into the degree to which these artifacts are consistent, but this is challenging, especially in complex industrial settings. In this study, we aim to help engineers in their consistency management efforts by creating consistency checks between a system model and the corresponding code. To that end, we performed a design science study in which we develop a consistency checking tool and integrate it into an existing industrial system and software engineering setting. We evaluated the developed tool through a case study in which we measure the consistency before and after its introduction and evaluate the experiences of engineers using it. Our results show that the introduction of lightweight consistency checks into the continuous integration pipeline is beneficial for consistency management in the studied setting. Moreover, we discuss the practical challenges of introducing consistency checks in an industrial setting and find that the majority is of a nontechnical nature.
Complex software systems possess concurrent and reactive behaviors requiring precise specifications prior to development. Lamport's transition axiom method is a formal specification method which combines axiomatic and operational approaches. On the other hand Unified Modeling Language (UML), a de facto industry standard visual language, lacks suitable constructs and semantics regarding concurrency aspects. Though UML includes action semantics, its higher level constructs and object semantics are inconsistent. Motivated by Lamport's approach, this paper proposes a UML based specification framework 'cmUML' ('cm' for concurrent modules) for formal specification of concurrent, reactive systems without object level diagrams and OCL. The framework integrates higher level diagrams of UML and addresses various concurrency issues including exception handling. It combines UML-RT and UML/ SPT profile as the latter defines a core package for concurrency and causality. Further the framework includes the characteristic safety and liveness aspects of concurrent systems. The proposed framework is in contrast with existing approaches based on low level primitives (semaphore, monitors). The paper includes several specification examples validating the proposed framework.
In object oriented paradigm, a concurrent system can be regarded as a collection of autonomous active objects which synchronize and communicate through shared passive objects. In this paper, we propose a UML-based approach to specify secured, fine-grained concurrent access to shared resources ensuring data integrity and security. The goal of the approach is to develop the UML specification with precise executional semantics, yet independent of low-level synchronization primitives and implementation environment. The approach is largely inspired from the language constructs of CDL*. A light-weight extension of UML 2.0 meta-model is proposed for the required constructs and semantics. UML protocol statemachine is used to define the access protocol for shared resources and UML activity is used to specify the behavior of methods implementing plausibly concurrent operations. The UML activity construct is extended to support concurrency features; synchronization regions, mutual exclusion and conditional synchronization not supported in current UML2.0 semantic model. The approach can be easily extended to a programming framework of design and coding.