Model-based Software Engineering Research Articles

An Agile Model-Based Software Engineering Approach Illustrated through the Development of a Health Technology System

Model-Based Software Engineering (MBSE) is an architecture-based software development approach. Agile, on the other hand, is a light system development approach that originated in software development. To bring together the benefits of both approaches, this article proposes an integrated Agile MBSE approach that adopts a specific instance of the Agile approach (i.e., Scrum) in combination with a specific instance of an MBSE approach (i.e., Model-Based System Architecture Process—“MBSAP”) to create an Agile MBSE approach called the integrated Scrum Model-Based System Architecture Process (sMBSAP). The proposed approach was validated through a pilot study that developed a health technology system over one year, successfully producing the desired software product. This work focuses on determining whether the proposed sMBSAP approach can deliver the desired Product Increments with the support of an MBSE process. The interaction of the Product Development Team with the MBSE tool, the generation of the system model, and the delivery of the Product Increments were observed. The preliminary results showed that the proposed approach contributed to achieving the desired system development outcomes and, at the same time, generated complete system architecture artifacts that would not have been developed if Agile had been used alone. Therefore, the main contribution of this research lies in introducing a practical and operational method for merging Agile and MBSE. In parallel, the results suggest that sMBSAP is a middle ground that is more aligned with federal and state regulations, as it addresses the technical debt concerns. Future work will analyze the results of a quasi-experiment on this approach focused on measuring system development performance through common metrics.

Classification for the Concrete Syntax of Graph-Like Modeling Languages

A classification scheme for Graph-Like Modeling Languages (GLML) is presented in this paper. The novelty of this classifier lies in its application to a meta-model for GLML that deviates from the simple graph model and underlies a large number of GLML. The main goal of using this classification scheme is to support the reuse of layout algorithms for GLML. GLML are used directly or indirectly for the development of software by model-based software engineering techniques. In other domains, graph-like models are artifacts (e.g., circuit diagrams, energy flow diagrams) that serve as input for downstream specialized applications (simulators, optimizers). The concrete syntax of a language for creating, editing, and understanding models is highly important for the development of modeling tools. Layout methods for the used languages have to be implemented to achieve software tools with good usability. Developing layout algorithms is a complex topic that is covered by the specialized field of Graph Drawing. However, there is no existing procedure to determine which layout algorithm can be used for a GLML. Matching layout algorithms to GLML can be achieved by applying the presented classification scheme.

A Tool-Assisted Approach for User-Friendly Definition of FB Constraints

Model-based software engineering is a promising approach for controlling complex automation systems. Automation engineers, unfortunately, do not routinely model the expected behavior, especially if they are not trained in software engineering. They rather focus only on the implementation. In this paper, we analyze potential causes for the low adoption of service sequences within IEC 61499, which define behavioral constraints for building blocks of control applications. We propose a methodology for mining constraints of software components, which are then classified by an engineer. Furthermore, we suggest extending the language to allow for forbidden and mandatory scenarios. Our approach facilitates the constraint definition for legacy software, where the effort of manual specification is extremely high. Tool support for all described extensions and modeling techniques is provided as part of the open source IDE Eclipse 4diac to facilitate applying the approach in practice.

PERSONAL THOUGHTS ON AUTOMATION, PROGRAMMING CULTURE, AND MODELBASED SOFTWARE ENGINEERING

When compared to more conventional development techniques, model-based software engineering (MBSE), a methodology for developing software, is characterized in part by much higher levels of automation. Many important components of development involve the use of computer-based tools, such as authoring support (many MBSE languages are primarily visual), automatic or semi-automatic verification, the automated conversion of requirements into corresponding programmers, and many more. There is little question that automation, when correctly designed and achieved, may significantly boost the productivity of software developers and improve the quality of their programme, given the historical examples, such as the advent of compilation technology. Therefore, it becomes sense to predict that MBSE will swiftly overtake other software development methods, much to how computer-aided design methods for hardware were quickly adopted. However, this hasn't happened. This is an opinion piece that draws from the author's extensive knowledge of MBSE and its use in business. In it, we look at the factors that led to this paradoxical situation.

Characterizing UX Evaluation in Software Modeling Tools: A Literature Review

Model-Based Software Engineering (MBSE) has a high potential to play a critical role in the whole process of software engineering, bringing many benefits to all stakeholders, yet it is not used by most software developers today, due to both lack of tool capabilities and poor user experience (UX) of tools. This study aims to understand the evaluation types and methods applied by researchers when studying UX in modeling tools (modeling experience or MX) and the types of issues uncovered in these studies. We conducted a literature review using a snowballing approach to gather all studies of this topic. A total of 41 research papers were reviewed. Data extraction was performed based on research questions and a categorization of discussed issues was presented. Several gaps and future opportunities were identified and discussed, which include 1) utilizing interview method in research design; 2) distributing testing tasks based on user profiles; 3) involving UX experts in analysis; 4) scalability testing using large models; 5) assessing MX in areas other than just usability and utility; 6) considering collaborative modeling as an important factor contributing to MX; 7) considering both language issues and tool issues in UX evaluation of software modeling tools. 8) improving the taxonomy of MX challenges; 9) triangulating using multiple methods; and 10) developing and validating MX tool design heuristics.

A Quantitative SWOT-TOWS Analysis for the Adoption of Model-Based Software Engineering.

A Quantitative SWOT-TOWS Analysis for the Adoption of Model-Based Software Engineering.

Formally-based Model-Driven Development of Collaborative Robotic Applications

The development of Human Robot Collaborative (HRC) systems faces many challenges. First, HRC systems should be adaptable and re-configurable to support fast production changes. However, in the development of HRC applications safety considerations are of paramount importance, as much as classical activities such as task programming and deployment. Hence, the reconfiguration and reprogramming of executing tasks might be necessary also to fulfill the desired safety requirements. Model-based software engineering is a suitable means for agile task programming and reconfiguration. We propose a model-based design-to-deployment toolchain that simplifies the routine of updating or modifying tasks. This toolchain relies on (i) UML profiles for quick model design, (ii) formal verification for exhaustive search for unsafe situations (caused by intended or unintended human behavior) within the model, and (iii) trans-coding tools for automating the development process. The toolchain has been evaluated on a few realistic case studies. In this paper, we show a couple of them to illustrate the applicability of the approach.

Augmenting metamodels with seamless support for planning, tracking, and slicing model evolution timelines

In model-based software engineering, models are central artifacts for management, design and implementation. To meet new requirements, engineers need to plan and perform model evolution. So far, model evolution histories are captured using version control systems, e.g., Git. However, these systems are unsuitable for planning model evolution as they do not have a notion of future changes. Furthermore, formally assigning responsibilities to engineers for performing evolution of model parts is achieved by using additional tools for access control. To remedy these shortcomings, we provide a method to generate evolution-aware modeling notations by augmenting existing metamodels with concepts for capturing previous performed and planned evolution as first-class entity. To provide a clear overview, we automatically generate a Gantt-style viewer for augmented models and capabilities to slice models for certain time periods. Our method enables engineers to seamlessly plan future model evolution while actively developing the current model state using a centralized access point for evolution. With the generated Gantt-style viewers and the slicing functionality, we enable engineers to inspect relevant model evolution while reducing model size and hiding unnecessary complexity. In our evaluation, we provide an implementation of our method in the tool TemporalRegulator3000 . We show applicability for real-world metamodels and capture the entire evolution timeline of corresponding models.

Modeling-framework for model-based software engineering of complex Internet of things systems.

Internet of things (IoT) systems are composed of variety of units from different domains. While developing a complete IoT system, different professionals from different domains may have to work in collaboration. In this paper we provide a framework which allows using discrete and continuous time modeling and simulation approaches in combination for IoT systems. The proposed framework demonstrates on how to model Ad-hoc and general IoT systems for software engineering purpose. We demonstrate that model-based software engineering on one hand can provide a common platform to overcome communication gaps among collaborating stakeholders whereas, on the other hand can model and integrate heterogeneous components of IoT systems. While modeling heterogeneous IoT systems, one of the major challenges is to apply continuous and discrete time modeling on intrinsically varying components of the system. Another difficulty may be how to compose these heterogeneous components into one whole system. The proposed framework provides a road-map to model discrete, continuous, Ad-hoc, general systems along with composition mechanism of heterogeneous subsystems. The framework uses a combination of Agent-based modeling, Aspect-oriented modeling, contract-based modeling and services-oriented modeling concepts. We used this framework to model a scenario example of a service-oriented IoT system as proof of concept. We analyzed our framework with existing systems and discussed it in details. Our framework provides a mechanism to model different viewpoints. The framework also enhances the completeness and consistency of the IoT software models.

A Systematic Comparison of Roundtrip Software Engineering Approaches applied to UML Class Diagram

Model-based software engineering contemplates several software developments approaches in which models play an important role. One such approach is round-trip engineering. The objective of this paper is to benchmark the comparative analysis of the round-trip engineering capability of three modelling tools: Papyrus, Modelio and Visual Paradigm. The conclusions drawn throughout the paper will answer the question: How effective are current code generation tools for documenting application evolution? Throughout the discussion, we have pointed out several improvements that these UML modelling tools have recently brought to the discussion. We have also proposed some improvements that we consider desirable to improve Roundtrip Engineering approaches pointing out possible directions and solutions.

A to Z of Model based Software Engineering

A to Z of Model based Software Engineering

Imperative versus declarative constraint specification languages: a controlled experiment

Model-based software engineering gains further attention these days. To better support it, the use of constraint languages is important in order to bridge expressiveness gaps and eliminate ambiguity. Nevertheless, the use of model-based constraint languages, like the Object Constraint Language (OCL), is quite limited and the specification of constraints is left to the implementation stage. One option for these practices might be the misconception that model-based constraint languages are difficult to work with. In this paper, we examine the usages of representative constraint languages, namely OCL, for model-based constraint languages, and Java, for implementation-based constraint languages. In particular, we examine their usage in understanding and developing constraints. We evaluate these usages via a controlled experiment with 110 Information Systems Engineering undergraduate students. We found out that using OCL outperforms using Java for both understanding and developing constraints. Yet, the students had more confidence with Java. The results indicate that the aforementioned misconception is wrong and there is a need for further education regarding model-based constraints languages, so to get more practice and confidence.

Contents for a Model-Based Software Engineering Body of Knowledge

Although Model-Based Software Engineering (MBE) is a widely accepted Software Engineering (SE) discipline, no agreed-upon core set of concepts and practices (i.e., a Body of Knowledge) has been defined for it yet. With the goals of characterizing the contents of the MBE discipline, promoting a global consistent view of it, clarifying its scope with regard to other SE disciplines, and defining a foundation for the development of educational curricula on MBE, this paper proposes the contents for a Body of Knowledge for MBE. We also describe the methodology that we have used to come up with the proposed list of contents, as well as the results of a survey study that we conducted to sound out the opinion of the community on the importance of the proposed topics and their level of coverage in the existing SE curricula.

Bridging proprietary modelling and open-source model management tools: the case of PTC Integrity Modeller and Epsilon

While the majority of research on Model-Based Software Engineering revolves around open-source modelling frameworks such as the Eclipse Modelling Framework, the use of commercial and closed-source modelling tools such as RSA, Rhapsody, MagicDraw and Enterprise Architect appears to be the norm in industry at present. This technical gap can prohibit industrial users from reaping the benefits of state-of-the-art research-based tools in their practice. In this paper, we discuss an attempt to bridge a proprietary UML modelling tool (PTC Integrity Modeller), which is used for model-based development of safety-critical systems at Rolls-Royce, with an open-source family of languages for automated model management (Epsilon). We present the architecture of our solution, the challenges we encountered in developing it, and a performance comparison against the tool’s built-in scripting interface. In addition, we use the bridge in a real-world industrial case study that involves the coordination with other bridges between proprietary tools and Epsilon.

A formal approach to AADL model-based software engineering

Formal methods have become a recommended practice in safety-critical software engineering. To be formally verified, a system should be specified with a specific formalism such as Petri nets, automata and process algebras, which requires a formal expertise and may become complex especially with large systems. In this paper, we report our experience in the formal verification of safety-critical real-time systems. We propose a formal mapping for a real-time task model using the LNT language, and we describe how it is used for the integration of a formal verification phase in an AADL model-based development process. We focus on real-time systems with event-driven tasks, asynchronous communication and preemptive fixed-priority scheduling. We provide a complete tool-chain for the automatic model transformation and formal verification of AADL models. Experimentation illustrates our results with the Flight control system and Line follower robot case studies.

Innovations in Model-based Software And Systems Engineering.

Innovations in Model-based Software And Systems Engineering.

INDIeAuthor: A Metamodel-Based Textual Language for Authoring Educational Courses

This paper presents the INDIeAuthor authoring tool, which has been developed at the Digital Content Production Center, Polytechnic University of Cartagena (UPCT). INDIeAuthor has been developed in order for the university to have its own tool that supports all the desired features, in addition to a platform with which to investigate innovative features. When building INDIeAuthor, we have overcome some limitations identified for existing authoring tools: 1) Lack of two essential content reuse mechanisms: defined-user templates and course-independent units; 2) No support to sequence the units on a course; 3) Gamification feature is either very limited or does not exist. Two new aspects of the proposal are: providing a family of four textual domain-specific languages rather than a graphical user interface and applying model-based software engineering techniques during the implementation of the languages. Four essential aspects in the course definition can be specified to the language family: content, assessment, gamification, and sequencing. We discuss the benefits of representing courses as models and present two utilities developed as a proof of concept. This paper also contributes with the definition of a feature model that establishes a conceptual framework in which to compare authoring tools. An evaluation of INDIeAuthor is also presented: a case study was carried to evaluate the language characteristics, and the tool is contrasted with eight widely-used authoring tools. This paper presented here is the baseline of INDIe Erasmus+ European project that is currently ongoing.

Template-based model generation

Given their vital roles in model-based software engineering, the performance of model-related operations (MOs, such as model transformations) must be systematically tested. However, how to produce a set of large input models that conform to structure-related constraints presents a major challenge to such test. This paper proposes a template-based approach to efficient model generation. Firstly, a DSL is provided to describe templates that specify how to generate a valid model that conforms to structure-related constraints. Secondly, a folding semantic is defined to convert templates into a wrapper metamodel. Thirdly, a wrapper model is generated using the existing model generators (e.g., a random model generator) according to the wrapper metamodel. Fourthly, an unfolding semantics is specified to translate the wrapper model into the desired test input. This paper also presents five case studies to evaluate the proposed approach, and the results demonstrate that such approach can generate large models based on structure-related constraints and facilitate the performance testing of MOs.

Model-based software engineering for an optical navigation system for spacecraft

The project Autonomous Terrain-based Optical Navigation (ATON) at the German Aerospace Center (DLR) is developing an optical navigation system for future landing missions on celestial bodies such as the moon or asteroids. Image data obtained by optical sensors can be used for autonomous determination of the spacecraft’s position and attitude. Camera-in-the-loop experiments in the Testbed for Robotic Optical Navigation (TRON) laboratory and flight campaigns with unmanned aerial vehicle (UAV) are performed to gather flight data for further development and to test the system in a closed-loop scenario. The software modules are executed in the C++ Tasking Framework that provides the means to concurrently run the modules in separated tasks, send messages between tasks, and schedule task execution based on events. Since the project is developed in collaboration with several institutes in different domains at DLR, clearly defined and well-documented interfaces are necessary. Preventing misconceptions caused by differences between various development philosophies and standards turned out to be challenging. After the first development cycles with manual Interface Control Documents (ICD) and manual implementation of the complex interactions between modules, we switched to a model-based approach. The ATON model covers a graphical description of the modules, their parameters and communication patterns. Type and consistency checks on this formal level help to reduce errors in the system. The model enables the generation of interfaces and unified data types as well as their documentation. Furthermore, the C++ code for the exchange of data between the modules and the scheduling of the software tasks is created automatically. With this approach, changing the data flow in the system or adding additional components (e.g., a second camera) have become trivial.

A feature-based survey of model view approaches

When dealing with complex systems, information is very often fragmented across many different models expressed within a variety of (modeling) languages. To provide the relevant information in an appropriate way to different kinds of stakeholders, (parts of) such models have to be combined and potentially revamped by focusing on concerns of particular interest for them. Thus, mechanisms to define and compute views over models are highly needed. Several approaches have already been proposed to provide (semi)automated support for dealing with such model views. This paper provides a detailed overview of the current state of the art in this area. To achieve this, we relied on our own experiences of designing and applying such solutions in order to conduct a literature review on this topic. As a result, we discuss the main capabilities of existing approaches and propose a corresponding research agenda. We notably contribute a feature model describing what we believe to be the most important characteristics of the support for views on models. We expect this work to be helpful to both current and potential future users and developers of model view techniques, as well as to any person generally interested in model-based software and systems engineering.