Model-driven Software Development Research Articles

CSIMQ Anniversary Editor-in-Chief Thoughts and Editorial Introduction to Issue 38: Model-based and Decision Support Methods for Next-generation Information Systems

CSIMQ enters its second decade of existence, therefore the preface for the current issue starts with a message from the Editor-in-Chief, highlighting the journal’s mission of dealing with complexity management and systems modeling as meta-fields that have emerged from Information Science but remain relevant across diverse domains. Afterwards, the 38th issue is introduced by summarizing the four articles selected by guest issue editors on topics related to novel decision support methods or model-based frameworks for evolving or evaluating information systems. Design-oriented research is the dominant approach in these works, balancing technical design decisions insights with empirical evaluation cases. Three of the selected articles contribute with decision-support methods or frameworks – for ESG (Environment-Social-Governance) accounting, for democratized decision services and for information security management. Another article revisits UML-based model-driven software development from a new perspective.

From enterprise models to low-code applications: mapping DEMO to Mendix; illustrated in the social housing domain

AbstractDue to hyper-competition, technological advancements, regulatory changes, etc, the conditions under which enterprises need to thrive become increasingly turbulent. Consequently, enterprise agility increasingly determines an enterprise’s chances for success. As software development often is a limiting factor in achieving enterprise agility, enterprise agility and software adaptability become increasingly intertwined. As a consequence, decisions that regard flexibility should not be left to software developers alone. By taking a Model-driven Software Development (MDSD) approach, starting from DEMO ontological enterprise models and explicit (enterprise) implementation design decisions, the aim of this research is to bridge the gap from enterprise agility to software adaptability, in such a way that software development is no longer a limiting factor in achieving enterprise agility. Low-code technology is a growing market trend that builds on MDSD concepts and claims to offer a high degree of software adaptability. Therefore, as a first step to show the potential benefits to use DEMO ontological enterprise models as a base for MDSD, this research shows the design of a mapping from DEMO models to Mendix for the (automated) creation of a low-code application that also intrinsically accommodates run-time implementation design decisions.

Mining domain-specific edit operations from model repositories with applications to semantic lifting of model differences and change profiling

Model transformations are central to model-driven software development. Applications of model transformations include creating models, handling model co-evolution, model merging, and understanding model evolution. In the past, various (semi-)automatic approaches to derive model transformations from meta-models or from examples have been proposed. These approaches require time-consuming handcrafting or the recording of concrete examples, or they are unable to derive complex transformations. We propose a novel unsupervised approach, called Ockham, which is able to learn edit operations from model histories in model repositories. Ockham is based on the idea that meaningful domain-specific edit operations are the ones that compress the model differences. It employs frequent subgraph mining to discover frequent structures in model difference graphs. We evaluate our approach in two controlled experiments and one real-world case study of a large-scale industrial model-driven architecture project in the railway domain. We found that our approach is able to discover frequent edit operations that have actually been applied before. Furthermore, Ockham is able to extract edit operations that are meaningful—in the sense of explaining model differences through the edit operations they comprise—to practitioners in an industrial setting. We also discuss use cases (i.e., semantic lifting of model differences and change profiles) for the discovered edit operations in this industrial setting. We find that the edit operations discovered by Ockham can be used to better understand and simulate the evolution of models.

A Formal Approach for Consistency Management in UML Models

Consistency is a significant indicator to measure the correctness of a software system in its lifecycle. It is inevitable to introduce inconsistencies between different software artifacts in the software development process. In practice, developers perform consistency checking to detect inconsistencies, and apply their corresponding repairs to restore consistencies. Even if all inconsistencies can be repaired, how to preserve consistencies in the subsequent evolution should be considered. Consistency management (consistency checking and consistency preservation) is a challenging task, especially in the multi-view model-driven software development process. Although there are some efforts to discuss consistency management, most of them lack the support of formal methods. Our work aims to provide a framework for formal consistency management, which may be used in the practical software development process. A formal model, called a Structure model, is first presented for specifying the overall model-based structure of the software system. Next, the definition of consistency is given based on consistency rules. We then investigate consistency preservation under the following two situations. One is that if the initial system is inconsistent, then the consistency can be restored through repairs. The other is that if the initial system is consistent, then the consistency can be maintained through update propagation. To demonstrate the effectiveness of our approach, we finally present a case study with a prototype tool.

Enhancing Monte Carlo Workflows for Nuclear Reactor Analysis with Metamodel-Driven Modeling

Monte Carlo codes are essential components of many reactor physics simulation workflows as high-fidelity continuous-energy neutron transport solvers. Among Monte Carlo radiation transport codes, MCNP is particularly notable due to its diverse simulation capabilities, large user base, and long validation history. Despite being a powerful simulation tool, MCNP provides limited capabilities to allow automated execution, model transformation, or support for user-defined logic and abstractions that limit its compatibility with modern workflows. To better integrate MCNP into a modern scientific workflow, we have developed an intuitive yet full-featured MCNP Application Program Interface (API) in Python, named MCNPy, which provides a specialized set of classes for MCNP input development. Moreover, to guarantee that our reading, writing, and modeling capabilities remain self-consistent (and to render the huge scope of the MCNP API manageable), we have adopted a strategy of model-driven software development in which a generalized model of the MCNP input format has been created. From this generalized model, or “metamodel,” problem-specific implementations such as an engine for input validation or a codebase for programmatic operations may be automatically generated. Since MCNPy primarily acts as a Python front-end to the underlying Java API that directly interfaces with the metamodel, it is intrinsically linked to the metamodel and thus remains maintainable. With MCNPy, users can programmatically read, write, and modify any syntactically valid MCNP input file regardless of its origin. These capabilities allow users to automate complicated tasks like design optimization and model translation for nuclear systems. As examples, this work demonstrates the use of MCNPy to find the critical radius of a plutonium sphere and to translate a 9000+ line MCNP input file into a corresponding OpenMC model.

A New Method for Measuring the Behavioral Consistency Degree of WF-Net Systems

How to guarantee the consistency between different systems has become a bone of contention in model-driven software development. Behavioral relations are a prominent technique/method to analyze the consistency degree of two workflow systems. There are four kinds of behavioral relations, i.e., strict order relation, exclusiveness relation, interleaving order relation, and inverse order relation. An activity in a module may be in different behavioral relations with activities in another module. We call the latter module a <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">special module</i> in this article. However, the existing measuring methods for behavioral consistency do not consider special modules at all. Thus, if we conduct a consistency analysis of different systems by these methods, we may get an inaccurate consistency degree, or obtain no results. In order to solve this problem, we use workflow nets (WF-nets) to model workflow systems and re-explore their behavioral relations. Then, their behavioral relation matrices (BRMs) are constructed. Based on BRMs, some new measurement methods are proposed to calculate the behavioral consistency degree of two WF-net systems. Finally, a group of experiments is done to show the effectiveness of our methods.

BXtendDSL: A layered framework for bidirectional model transformations combining a declarative and an imperative language

Model-driven software development (MDSD) heavily relies on model transformations. While in a strict forward engineering process unidirectional transformations are used, bidirectional transformations are crucial as soon as roundtrip engineering comes into play. In this paper, we present a hybrid language specifically designed to describe bidirectional model transformations. From a declarative transformation specification code is generated which uses our framework for bidirectional and incremental model transformations. A sophisticated code generation mechanism allows for hooking into the generated transformation code at the imperative level to supply behavior that cannot be expressed declaratively. A thorough evaluation demonstrates conciseness, expressiveness, and scalability of our approach.

A model-driven approach to machine learning and software modeling for the IoT

Models are used in both Software Engineering (SE) and Artificial Intelligence (AI). SE models may specify the architecture at different levels of abstraction and for addressing different concerns at various stages of the software development life-cycle, from early conceptualization and design, to verification, implementation, testing and evolution. However, AI models may provide smart capabilities, such as prediction and decision-making support. For instance, in Machine Learning (ML), which is currently the most popular sub-discipline of AI, mathematical models may learn useful patterns in the observed data and can become capable of making predictions. The goal of this work is to create synergy by bringing models in the said communities together and proposing a holistic approach to model-driven software development for intelligent systems that require ML. We illustrate how software models can become capable of creating and dealing with ML models in a seamless manner. The main focus is on the domain of the Internet of Things (IoT), where both ML and model-driven SE play a key role. In the context of the need to take a Cyber-Physical System-of-Systems perspective of the targeted architecture, an integrated design environment for both SE and ML sub-systems would best support the optimization and overall efficiency of the implementation of the resulting system. In particular, we implement the proposed approach, called ML-Quadrat, based on ThingML, and validate it using a case study from the IoT domain, as well as through an empirical user evaluation. It transpires that the proposed approach is not only feasible, but may also contribute to the performance leap of software development for smart Cyber-Physical Systems (CPS) which are connected to the IoT, as well as an enhanced user experience of the practitioners who use the proposed modeling solution.

Topic modeling for feature location in software models: Studying both code generation and interpreted models

In the last 20 years, the research community has increased its attention to the use of topic modeling for software maintenance and evolution tasks in code. Topic modeling is a popular and promising information retrieval technique that represents topics by word probabilities. Latent Dirichlet Allocation (LDA) is one of the most popular topic modeling methods. However, the use of topic modeling in model-driven software development has been largely neglected. Since software models have less noise (implementation details) than software code, software models might be well-suited for topic modeling. This paper presents our LDA-guided evolutionary approach for feature location in software models. Specifically, we consider two types of software models: models for code generation and interpreted model. We evaluate our approach considering two real-world industrial case studies: code-generation models for train control software, and interpreted models for a commercial video game. To study the impact on the results, we compare our approach for feature location in models against random search and a baseline based on Latent Semantic Indexing, which is a popular information retrieval technique. In addition, we perform a statistical analysis of the results to show that this impact is significant. We also discuss the results in terms of the following aspects: data sparsity , implementation complexity, calibration, and stability. Our approach significantly outperforms the baseline in terms of recall, precision and F-measure when it comes to interpreted models. This is not the case for code-generation models. Our analysis of the results uncovers a recommendation towards results improvement. We also show that calibration approaches can be transferred from code to models. The findings of our work with regards to the compensation of instability have the potential to help not only feature location in models, but also in code.

Deriving and validating fault metric for object oriented systems using use case diagram

A significant quality factor reliability is an important requirement for all software systems. Reliability analysis and evaluation for a system is necessary for the success of these systems. This paper proposes a fault metric called use case fault metric (UCFM) for object-oriented systems using use case diagram and is built on the theory of Fault Tree Analysis (FTA). The goal is to address an important issue of measuring reliability of object-oriented systems during initial stages of software development. This goal is achieved by extending the model-driven software development process with the concept of Fault Tree Analysis (FTA). The Fault Tree analysis is performed in bottom-up way to compute quantitatively the proposed metric called UCFM. The proposed approach transforms the use case in an equivalent Fault Tree. This FTA is used to compute a metric that quantifies the probability of occurrence of faults in different use cases. The UCFM value is computed at use case, use case diagram and system level. The proposed metric is validated theoretically using measurement theory and practically using Kaner’s framework.

CODEGER-UWE - Model Driven Web Application Development Tool

In this paper, we present a CODEGER-UWE tool tool to support model-driven web application development. The CODEGER-UWE tool has integrated rule for transformation Model and code generation rules to create web applications for the JSF platform automatically. CODEGER-UWE implemented as a plugin for the MagicDraw tool which allows the generation of source code from UWE models that correspond to the components of the MVC model. This is a tool with a clear, handy development process, applying tools to develop web applications will greatly reduce the time for developing Web applications. Keywords: CODEGER-UWE, Model driven web applications development, Model driven software development, Web application development tools, automated code generation.

Towards a Formal Specification of Production Processes Suitable for Automatic Execution

Abstract Technological advances and increasing customer need for highly customized products have triggered a fourth industrial revolution. A digital revolution in the manufacturing industry is enforced by introducing smart devices and knowledge bases to form intelligent manufacturing information systems. One of the goals of the digital revolution is to allow flexibility of smart factories by automating shop floor changes based on the changes in input production processes and ordered products. In order to make this possible, a formal language to describe production processes is needed, together with a code generator for its models and an engine to execute the code on smart devices. Existing process modeling languages are not usually tailored to model production processes, especially if models are needed for automatic code generation. In this paper we propose a research on Industry 4.0 manufacturing using a Domain-Specific Modeling Language (DSML) within a Model-Driven Software Development (MDSD) approach to model production processes. The models would be used to generate instructions to smart devices and human workers, and gather a feedback from them during the process execution. A pilot comparative analysis of three modeling languages that are commonly used for process modeling is given with the goal of identifying supported modeling concepts, good practices and usage patterns.

Some model driven software development approaches

A model is a simplification of a reality, an abstraction, which neglects all of the irrelevant aspects of a software and focuses on the ones which define the software. Through modeling, we can visualize the software in a way which is understandable from both computers and people. Unified Modeling Language (UML) is a language, which stands in a higher level of abstraction than any programming language and through it, we can build software models from the simplest to the most complicated ones. However, even though through UML we are able to design software’s and to generate a considerable amount of code, still we need to write tons of lines of code in a certain object – oriented language. In order to be totally independent from the execution environment and to focus entirely in business logic as what really defines a software we need to go further. To achieve this goal, the executable UML and state machines concept is introduced. “An executable UML model is one with a behavioral specification detailed enough that it can effectively be run as a program” (Seidewitz, 2011). Through executable model a higher programmer productivity could be achieved and the system is not affected by the year after year change in development technologies, which require that the system to be upgraded each time there are changes in run-time environments. On the other hand, through state machines we are able to simulate the execution of a program through the model. Thus we can develop information systems using techniques which stand in a higher level of abstraction and platform independence that can be translated in whichever specific platform of implementation.

A navigational logic for reasoning about graph properties

Graphs play an important role in many areas of Computer Science. In particular, our work is motivated by model-driven software development and by graph databases. For this reason, it is very important to have the means to express and to reason about the properties that a given graph may satisfy. With this aim, in this paper we present a visual logic that allows us to describe graph properties, including navigational properties, i.e., properties about the paths in a graph. The logic is equipped with a deductive tableau method that we have proved to be sound and complete.

Model-driven development of accessible software: a systematic literature review

The lack of accessibility in software products is a problem, which is difficult to solve, due to the absence of accessible support tools and the scarce training of software professionals in accessibility issues that exist today, which has influenced the development of inaccessible programs, causing a large number of people, including those with some type of disability difficulties to interact with applications easily and quickly. Given this problem, model-driven development has attracted the attention of the accessible software development community, due to its ability to generate code from models. Thus, in the present work, a systematic review was carried out to investigate and analyze the studies related to model-driven development of accessible software, including the revision of standards directly related to software accessibility and the qualitative evaluation of the different existing proposals.

A Process Model for Component-Based Model-Driven Software Development

Developing high quality, reliable and on time software systems is challenging due to the increasing size and complexity of these systems. Traditional software development approaches are not suitable for dealing with such challenges, so several approaches have been introduced to increase the productivity and reusability during the software development process. Two of these approaches are Component-Based Software Engineering (CBSE) and Model-Driven Software Development (MDD) which focus on reusing pre-developed code and using models throughout the development process respectively. There are many research studies that show the benefits of using software components and model-driven approaches. However, in many cases the development process is either ad-hoc or not well-defined. This paper proposes a new software development process model that merges CBSE and MDD principles to facilitate software development. The model is successfully tested by applying it to the development of an e-learning system as an exemplar case study.

Conceptual Design, Implementation, and Evaluation of Generic and Standard-Compliant Data Transfer into Electronic Health Records

Objectives The objective of this study is the conceptual design, implementation and evaluation of a system for generic, standard-compliant data transfer into electronic health records (EHRs). This includes patient data from clinical research and medical care that has been semantically annotated and enhanced with metadata. The implementation is based on the single-source approach. Technical and clinical feasibilities, as well as cost-benefit efficiency, were investigated in everyday clinical practice. Methods Münster University Hospital is a tertiary care hospital with 1,457 beds and 10,823 staff who treated 548,110 patients in 2018. Single-source metadata architecture transformation (SMA:T) was implemented as an extension to the EHR system. This architecture uses Model Driven Software Development (MDSD) to generate documentation forms according to the Clinical Data Interchange Standards Consortium (CDISC) operational data model (ODM). Clinical data are stored in ODM format in the EHR system database. Documentation forms are based on Google's Material Design Standard. SMA:T was used at a total of five clinics and one administrative department in the period from March 1, 2018 until March 31, 2019 in everyday clinical practice. Results The technical and clinical feasibility of SMA:T was demonstrated in the course of the study. Seventeen documentation forms including 373 data items were created with SMA:T. Those were created for 2,484 patients by 283 users in everyday clinical practice. A total of 121 documentation forms were examined retrospectively. The Constructive cost model (COCOMO II) was used to calculate cost and time savings. The form development mean time was reduced by 83.4% from 3,357 to 557 hours. Average costs per form went down from EUR 953 to 158. Conclusion Automated generic transfer of standard-compliant data and metadata into EHRs is technically and clinically feasible, cost efficient, and a useful method to establish comprehensive and semantically annotated clinical documentation. Savings of time and personnel resources are possible.

EARL—Embodied Agent-Based Robot Control Systems Modelling Language

The paper presents the Embodied Agent-based Robot control system modelling Language (EARL). EARL follows a Model-Driven Software Development approach (MDSD), which facilitates robot control system development. It is based on a mathematical method of robot controller specification, employing the concept of an Embodied Agent, and a graphical modelling language: System Modelling Language (SysML). It combines the ease of use of SysML with the precision of mathematical specification of certain aspects of the designed system. It makes the whole system specification effective, from the point of view of the time needed to create it, conciseness of the specification and the possibility of its analysis. By using EARL it is possible to specify systems both with fixed and variable structure. This was achieved by introducing a generalised system model and presenting particular structures of the system in terms of modelling block configurations adapted by using instances. FABRIC framework was created to support the implementation of EARL-based controllers. EARL is compatible with component based robotic middlewares (e.g., ROS and Orocos).

A New Modeling Approach for Power Grid Online Analysis

Abstract A new modeling approach for power grid online analysis is proposed to support the realization of a new online analysis system architecture. The model-driven software development, automatic code generation, and in-memory computing techniques are employed in the modeling approach. Data source adapters are developed for the integration of the model with the existing EMS system. A large-scale power grid online network data model (~40K-bus) is used for the model performance testing in a Lab environment. The proposed modeling approach was used to develop a new online analysis application, which was deployed and running in a provincial grid dispatching control center. The Lab and field performance measurement shows that the modeling approach-based application can achieve second-order end-to-end responsiveness.

Model Transformation as Conservative Theory-Transformation.

Model transformations play a central role in model-driven software development. Hence, logical unsafe model transformation can result in erroneous systems. Still, most model transformations are written in languages that do not provide built-in safeness guarantees.We present a new technique to construct tool support for domain-specific languages (DSLs) inside the interactive theorem prover environment Isabelle. Our approach is based on modeling the DSL formally in higher-order logic (HOL), modeling the API of Isabelle inside it, and defining the transformation between these two. Reflection via the powerful code generators yields code that can be integrated as extension into Isabelle and its user interface. Moreover, we use code generation to produce tactic code which is bound to appropriate command-level syntax.Our approach ensures the logical safeness (conservativity) of the theorem prover extension and, thus, provides a certified tool for the DSL in all aspects: the deductive capacities of theorem prover, code generation, and IDE support. We demonstrate our approach by extending Isabelle/HOL with support for UML/OCL and, more generally, providing support for a formal object-oriented modeling method.