Model-driven Development Research Articles

Model-Driven Development Towards Distributed Intelligent Systems

A Distributed Intelligent System (DIS) encompasses a set of intelligent subsystems and components that collaborate to perform tasks and solve problems. Given the advancements of paradigms such as the Internet of Things, along with the advancements of technologies such as Machine Learning and Digital Twins, DISs are on the rise. These systems are increasingly integrating components that perform intelligent functions, and these intelligent functions are increasingly heterogeneous and varied. Moreover, there is no standardized framework to help researchers and practitioners adequately address DISs. As a result, the complexity, interoperability issues, and development time and costs of these systems are growing. However, Model-Driven Development (MDD) can help to address these challenges by providing a Domain-Specific Language (DSL) for developing DISs. In this work, a DSL for the design, validation, generation, and deployment of DISs is proposed. Firstly, the proposed DSL captures in a metamodel the key and high-level abstract concepts of the distinct DISs documented in the literature. Then, it allows modeling of DISs conforming to this metamodel. Subsequently, the DSL enables formal validation of the modeled systems. Lastly, it allows the generation and deployment of all DISs into production. Therefore, the work undertaken in this communication provides a methodological, formal, and standardized approach to defining and developing DISs from a high level of abstraction. This work allows users to address DISs by facilitating agility, minimizing manual tasks, and reducing the number of defects introduced in their development. To illustrate the applicability of the proposed DSL, a real case study of an agricultural digital twin is presented.

Model-driven development for functional correctness of avionics systems: a verification framework for SysML specifications

AbstractCurrently, the most widespread software quality assurance methods in the avionics domain are semi-automated reviews and testing. However, their effort grows disproportionately to the size of the system under development. Also, these methods cannot achieve exhaustive coverage due to the complexity of today’s avionics systems and their potentially infinite set of combinations of possible inputs and system states. Furthermore, the later software issues are detected in the development process, the more expensive it is to fix them. To overcome these issues, a model-driven verification approach for modeling and analyzing avionics systems in early phases of the development is presented. To this end, semantics is given to SysML v2 models by a mapping to a theorem prover encoding. The development of a dedicated SysML v2 profile supporting event-driven data flow specifications, the encoding of corresponding structures in the theorem prover Isabelle, and a generator creating theorems from SysML v2 models are presented. The approach is evaluated by formally proving a representative liveness property of a hierarchical system model from the avionics domain. Since liveness properties can be negated only by infinite data sequences and thus cannot be covered exhaustively by testing, this case study demonstrates the added value for meeting typical safety requirements in the avionics domain. The results can be transferred from avionics to other domains, as well.

A Model-Driven Approach to Developing Scalable Educational Software for Adaptive Learning Environments

This research presents a model-driven approach to the development of scalable educational software tailored to adaptive learning environments. With the increasing demand for personalized education, adaptive learning systems play a crucial role in meeting diverse student needs by adjusting instructional content dynamically. This paper proposes a software engineering framework that integrates model-driven development (MDD) techniques with scalability principles, allowing for the efficient design and implementation of educational applications that can handle varying workloads and user demands. The framework emphasizes modular architecture, reusability, and flexibility to ensure that software can evolve with emerging educational requirements. Key components include the design of a learning content management system (LCMS) and the application of adaptive algorithms to personalize learning pathways. Additionally, this study explores the integration of cloud technologies to enhance the scalability and performance of educational platforms. A prototype system was developed and tested in a controlled environment, showing significant improvements in scalability, system performance, and student engagement compared to traditional static e-learning platforms. The results indicate that the model-driven approach not only improves software development efficiency but also offers a robust solution for creating adaptive educational systems that can scale to meet the growing needs of learners and institutions. This research contributes to the field of educational software development by providing a systematic methodology for building scalable and adaptive learning environments using advanced software engineering techniques.

Understanding the Variety of Domain Models: Views, Programs, Animations, and Other Models

Humanity has long since used models, in different shapes and forms, to understand, redesign, communicate about, and shape, the world around us; including many different social, economic, biological, chemical, physical, and digital aspects. This has resulted in a wide range of modeling practices. When the models as used in such modeling practices have a key role to play in the activities in which these practices are ‘embedded’, the need emerges to consider the effectiveness and efficiency of such processes, and speak about modeling capabilities. In the latter situation, it also becomes relevant to develop a thorough understanding of the artifacts involved in modeling practices/capabilities. One context in which models play (an increasingly) important role is model-driven systems development, including software engineering, information systems engineering, business process engineering, enterprise engineering, and enterprise architecture management. In such a context, we come across a rich variety of modeling related artifacts, such as views, diagrams, programs, animations, specifications, etc. In this paper, which is actually part of an ongoing ‘journey’ in which we aim to gain deeper insights into the foundations of modeling, we take a fundamental look at the variety of modeling related artifacts as used in the context of model-driven (systems) development, while also presenting an associated framework for understanding, synthesizing the insights we obtained during the ‘journey’ so-far. In doing so, we will also argue that the aforementioned artifacts are actually specific kinds of models, albeit for fundamentally different purposes. The provided framework for understanding involves definitions of domain model, the Return on Modeling Effort (RoME), the conceptual fidelity of domain models, as well as views as a mechanism to manage the complexity of domain models.

BIT: A template-based approach to incremental and bidirectional model-to-text transformation

Model-driven development is a model-centric software development paradigm that automates the development process by converting high-level models into low-level code and documents. To maintain synchronization between models and code/documents — which can evolve independently — this paper introduces BIT, a bidirectional language that can serve as a conventional template language for model-to-text transformations. However, a BIT program can function as both a printer, generating text by filling template holes with values from the input model, and a parser, putting parsed values back into the model. BIT comprises a surface language for better usability and a core language for formal definition. We define the semantics of the core language based on the theory of bidirectional transformation, and provide the translation from the surface to the core. We present the proof sketch of the well behavedness of BIT as a formal evidence of soundness. We also conduct three case studies to empirically demonstrate the expressiveness and the effectiveness of BIT. Based on the proof and the case studies, BIT covers the major features of existing template languages, and offers sufficient expressiveness to define real-world model-to-text transformations that can be executed bidirectionally and incrementally.

Photonic device programmability in support of autonomous optical networks

The emergence and consolidation of increasingly programmable optical devices such as transceivers, amplifiers, multiplexers, or ROADMs—which allow their remote configuration and control by adopting software-defined networking principles such as model-driven development—is enabling the evolution toward gradually more autonomous networks. Such networks leverage device programmability and are able to adapt and react to traffic and network condition changes, e.g., changing modes of operation or reconfiguring the network state, paving the way for the increased adoption of AI/ML models in support of enhanced network operation. In this paper, after a short review of some key elements in the control and orchestration systems of optical networks in support of autonomous networking, we present in detail a proof-of-concept validation of autonomous, closed-loop dynamic adaptation of transceiver operational modes. This includes (i) the design and development of an SDN agent of a multi-band sliceable bandwidth variable transceiver, based on extended OpenConfig terminal device data models; (ii) an SDN controller that performs discovery and management of transceivers’ operational modes and maps to transport API (TAPI) profiles enabling efficient physical layer impairment-aware path computation; (iii) a dedicated externalized path computation element/digital twin that performs adaptation recommendations; and (iv) an MQTT-based telemetry platform for publisher/subscriber based state synchronization between the control plane functional entities to avoid systematic polling.

Using reactive links to propagate changes across engineering models

AbstractCollaborative model-driven development is a de facto practice to create software-intensive systems in several domains (e.g., aerospace, automotive, and robotics). However, when multiple engineers work concurrently, keeping all model artifacts synchronized and consistent is difficult. This is even harder when the engineering process relies on a myriad of tools and domains (e.g., mechanic, electronic, and software). Existing work tries to solve this issue from different perspectives, such as using trace links between different artifacts or computing change propagation paths. However, these solutions mainly provide additional information to engineers, still requiring manual work for propagating changes. Yet, most modeling tools are limited regarding the traceability between different domains, while also lacking the efficiency and granularity required during the development of software-intensive systems. Motivated by these limitations, in this work, we present a solution based on what we call “reactive links”, which are highly granular trace links that propagate change between property values across models in different domains, managed in different tools. Differently from traditional “passive links”, reactive links automatically propagate changes when engineers modify models, assuring the synchronization and consistency of the artifacts. The feasibility, performance, and flexibility of our solution were evaluated in three practical scenarios, from two partner organizations. Our solution is able to resolve all cases in which change propagation among models were required. We observed a great improvement of efficiency when compared to the same propagation if done manually. The contribution of this work is to enhance the engineering of software-intensive systems by reducing the burden of manually keeping models synchronized and avoiding inconsistencies that potentially can originate from collaborative engineering in a variety of tool from different domains.

Assistance in Model Driven Development: Toward an Automated Transformation Design Process

Model driven engineering aims to shorten the development cycle by focusing on abstractions and partially automating code generation. We long lived in the myth of automatic Model Driven Development (MDD) with promising approaches, techniques, and tools. Describing models should be a main concern in software development as well as model verification and model transformation to get running applications from high level models. We revisit the subject of MDD through the prism of experimentation and open mindness. In this article, we explore assistance for the stepwise transition from the model to the code to reduce the time between the analysis model and implementation. The current state of practice requires methods and tools. We provide a general process and detailed transformation specifications where reverse-engineering may play its part. We advocate a model transformation approach in which transformations remain simple, the complexity lies in the process of transformation that is adaptable and configurable. We demonstrate the usefulness, and scalability of our proposed MDD process by conducting experiments. We conduct experiments within a simple case study in software automation systems. It is both representative and scalable. The models are written in UML; the transformations are implemented mainly using ATL, and the programs are deployed on Android and Lego EV3. Last we report the lessons learned from experimentation for future community work.

Declarative Inversion of Control Configuration in Modern .NET8 Applications

As software systems continue to evolve in complexity and scale, the importance of adopting componentbased architectural paradigms becomes increasingly evident. Inversion of Control (IoC) and Dependency Injection (DI) patterns play important role in managing OO-components dependencies, reduce coupling and enable seamless integration of components. This article explores the theoretical foundations of IoC and DI, shedding light on their practical implementation in modern .NET applications.Standard .NET DI-container has a number of technical limitations: properties injection is not supported, dependencies definitions from keyed services partially breaks IoC principle, and finally lack of declarative way to define components and their dependencies. To address these limitations, it is proposed to implement a special extension for standard DI-container in the form of a component factory. This factory would register components within the container and define their dependencies based on declarative configuration. The configuration can be stored either in a standard (for .NET Core apps) appsettings.json file or loaded from a separate JSON file. In fact, this JSON could be even dynamically generated in specific usage scenarios.The capability to use a declarative configuration for standard DI-container opens up broad possibilities for generative programming. It becomes technically feasible to implement a model-driven development, particularly an approach that leverages the DI-container configuration as the final (execution) model in a chain of transformations of domain-specific models.Modern .NET8 platform assumes that software is assembled from libraries of pre-existing components that are hosted in a standard DI-container that provides suitable runtime environment for them. Practical aspects of applying the Inversion of Control pattern are examined, considering the use of a standard Dependency Injection (DI) container implementation. Existing technological limitations are defined, and a solution is proposed: implementation of declarative configuration of dependencies between components. This approach contributes to a reduced level of coupling between components and facilitates the decomposition of the program into more granular and abstract components – which increases their reusability in consequence.

Edge IoT Prototyping Using Model-Driven Representations: A Use Case for Smart Agriculture.

Industry 4.0 is positioned at the junction of different disciplines, aiming to re-engineer processes and improve effectiveness and efficiency. It is taking over many industries whose traditional practices are being disrupted by advances in technology and inter-connectivity. In this context, enhanced agriculture systems incorporate new components that are capable of generating better decision making (humidity/temperature/soil sensors, drones for plague detection, smart irrigation, etc.) and also include novel processes for crop control (reproducible environmental conditions, proven strategies for water stress, etc.). At the same time, advances in model-driven development (MDD) simplify software development by introducing domain-specific abstractions of the code that makes application development feasible for domain experts who cannot code. XMDD (eXtreme MDD) makes this way to assemble software even more user-friendly and enables application domain experts who are not programmers to create complex solutions in a more straightforward way. Key to this approach is the introduction of high-level representations of domain-specific functionalities (called SIBs, service-independent building blocks) that encapsulate the programming code and their organisation in reusable libraries, and they are made available in the application development environment. This way, new domain-specific abstractions of the code become easily comprehensible and composable by domain experts. In this paper, we apply these concepts to a smart agriculture solution, producing a proof of concept for the new methodology in this application domain to be used as a portable demonstrator for MDD in IoT and agriculture in the Confirm Research Centre for Smart Manufacturing. Together with model-driven development tools, we leverage here the capabilities of the Nordic Thingy:53 as a multi-protocol IoT prototyping platform. It is an advanced sensing device that handles the data collection and distribution for decision making in the context of the agricultural system and supports edge computing. We demonstrate the importance of high-level abstraction when adopting a complex software development cycle within a multilayered heterogeneous IT ecosystem.

Automatic generation of security protocols attacks specifications and implementations

Confidence in a communication protocol’s security is a key requirement for its deployment and long-term maintenance. Checking if a vulnerability exists and is exploitable requires extensive expertise. The research community has advocated for a systematic approach with formal methods to model and automatically test a protocol against a set of desired security properties. As verification tools reach conclusions, the applicability of their results still requires expert scrutiny. We propose a code generation approach to automatically build both an abstract specification and a concrete implementation of a Dolev-Yao intruder from an abstract attack trace, bridging the gap between theoretical attacks discovered by formal means and practical ones. Through our case studies, we focus on attack traces from the OFMC model checker, Alice&Bob specifications and Java implementations. We introduce a proof-of-concept workflow for concrete attack validation that allows to conveniently integrate, in a user-friendly way, formal methods results into a Model-Driven Development process and at the same time automatically generate a program that allows to demonstrate the attack in practice. In fact, in this contribution, we produce high-level and concrete attack narrations that are both human and machine readable.

A Web-based Methodology to Automate foundation of business process model in MDA by AI

MDA represents a fundamental standard established by the Object Management Group (OMG) that serves as a foundation for model-driven development. Within the MDA framework, the computation-independent model (CIM) holds the position of the initial abstraction level. As a business model, the CIM describes the requirements and environment of a business, playing a pivotal role in influencing all other levels of the MDA approach. Recognizing the significance of this stage in MDA, the primary objective of this paper is to propose a web-based approach for automating the construction of CIM. This approach utilizes web interfaces to gather relevant information from users about the business model. Furthermore, an illustrative example is presented to provide a clearer demonstration of the application of this approach.

Model-driven Privacy

Data protection regulations in many countries require IT systems to implement baseline privacy requirements like purpose limitation and consent as mandated by the GDPR. Such requirements are often specified in the system’s privacy policy and are challenging to implement as system developers must address them consistently and in a cross-cutting manner. Moreover, without a formal connection between a system’s privacy policy and its implementation, the system’s correctness and evolution are extremely difficult to attain. We propose a model-driven development methodology that incorporates privacy policies into the system design. Namely, we define a system’s privacy model, which has precise semantics and is used to specify privacy policies. We provide semantic-preserving model transformations that generate system implementations that enforce the given privacy policies by design. We implement two such model transformations, targeting C# and Python system implementations. We evaluate our methodology on three substantial case studies and show the enforcement of privacy policies related to purpose limitation and consent. Our evaluation also demonstrates our approach’s generality, effectiveness, and modest overhead.

Development of Bioactive Scaffolds for Orthopedic Applications by Designing Additively Manufactured Titanium Porous Structures: A Critical Review.

We overview recent findings achieved in the field of model-driven development of additively manufactured porous materials for the development of a new generation of bioactive implants for orthopedic applications. Porous structures produced from biocompatible titanium alloys using selective laser melting can present a promising material to design scaffolds with regulated mechanical properties and with the capacity to be loaded with pharmaceutical products. Adjusting pore geometry, one could control elastic modulus and strength/fatigue properties of the engineered structures to be compatible with bone tissues, thus preventing the stress shield effect when replacing a diseased bone fragment. Adsorption of medicals by internal spaces would make it possible to emit the antibiotic and anti-tumor agents into surrounding tissues. The developed internal porosity and surface roughness can provide the desired vascularization and osteointegration. We critically analyze the recent advances in the field featuring model design approaches, virtual testing of the designed structures, capabilities of additive printing of porous structures, biomedical issues of the engineered scaffolds, and so on. Special attention is paid to highlighting the actual problems in the field and the ways of their solutions.

MDSSED: A safety and security enhanced model-driven development approach for smart home apps

With the popularization of smart home devices, people rely more on automation functions provided by smart home apps. This increases the attack surface for safety and security threats. Many of these threats are at the interaction level, caused by unintended or malicious interactions between apps. Most of the current studies focus on identifying unsafe interactions between smart home apps by code analysis. To the best of our knowledge, none of the existing studies focuses on enhancing the safety and security of smart home apps under interaction threats in the design phase. To fill this gap, this paper presents MDSSED, a safety and security enhanced model-driven development approach for smart home apps. First, this paper identifies eleven types of interaction threats faced by smart home apps. Second, the MDSSED profile is proposed to support modeling smart home apps using UML. Third, the MDSSED prototype tool is developed to generate threat models and corresponding safety and security properties automatically. Then, the safety and security properties are automatically verified by model checking. Finally, the MDSSED tool automatically converts the UML models to the Samsung SmartThings apps. To evaluate the accuracy and effectiveness of MDSSED, this paper uses the benchmarks in existing state-of-the-art studies. The results show that MDSSED not only identified the safety and security problems in the existing benchmarks but also pointed out vulnerabilities of apps under other interaction threats identified in this paper. To the best of our knowledge, MDSSED is the first model-driven development approach that supports the automatic verification of the safety and security properties of smart home apps under interaction threats. The accuracy, practicality, and efficiency of MDSSED are corroborated by experiments. The source code of the MDSSED tool and the experimental data are available online.1

Verification of cryptocurrency consensus protocols: reenterable colored Petri net model design

The reliability of consensus protocols establishes the basis for cryptocurrency cybersecurity. Formal and simulation techniques are appreciated for the verification of proof-of-work agreement protocols, because the formal techniques development process frequently requires a series of assumptions, leading to somewhat unrealistic models. A conventional colored Petri net model, presented by the authors in a previous study, allowed us to refine the Keller and Böhme consensus protocol by applying the simulation technique. In this study, we developed a reenterable colored Petri net model representing a general construct for model-driven development and refinement of consensus protocols and the corresponding software. A considerable benefit of a reenterable model is the invariance of its structure with respect to the net topology, number of attached nodes, and parameters of their software and hardware, which are represented as the marking of dedicated places. Switching of topology tags associated with dynamic objects represents the basic principle of reenterable model functioning. It is shown that, having the same characteristics, in bounds of admissible error of some 2-3%, the reenterable model results in 6 times speed-up of the simulation process and a drastic decrease in time for model editing, especially when the number of nodes exceeds a hundred. Thus, a reenterable model is a valuable complement to possible formal models that allows us to obtain express-evaluations of characteristics in a rather short time and with an acceptable level of adequacy.

HIPPP: Health Information Portal for Patients and Public

Cancer misinformation is becoming an increasingly complex issue. When a person or a loved one receives a diagnosis of possible cancer, that person, family and friends will try to better inform themselves in this area of healthcare. Like most people, they will turn to their clinician for guidance and the internet to better verse themselves on the topic. But can they trust the information provided online? Are there ways to provide a quick evaluation of such information in order to prevent low-quality information and potentially dangerous consequences of trusting it? In the context of the UL Cancer Research Network (ULCan), this interdisciplinary project aims to develop the Health Information Portal for Patients and Public (HIPPP), a web-based application co-designed with healthcare domain experts that helps to improve people navigate the health information space online. HIPPP will be used by patients and the general public to evaluate user-provided web-based health information (WBHI) sources with respect to the QUEST framework and return a quality score for the information sources. As a web application, HIPPP is developed with modern extreme model-driven development (XMDD) technologies in order to make it easily adaptable and evolvable. To facilitate the automated evaluation of WBHI, HIPPP embeds an artificial intelligence (AI) pipeline developed following model-driven engineering principles. Through co-design with health domain experts and following model-driven engineering principles, we have extended the Domain Integrated Modelling Environment (DIME) to include a graphical domain-specific language (GDSL) for developing websites for evaluating WBHI. This GDSL allows for greater participation from stakeholders in the development process of both the user-facing website and the AI-driven evaluation pipeline through encoding concepts familiar to those stakeholders within the modelling language. The time efficiency study conducted as part of this research found that the HIPPP evaluation pipeline evaluates a sample of WBHI with respect to the QUEST framework up to 98.79% faster when compared to the time taken by a human expert evaluator.

Comparing software product lines and Clone and Own for game software engineering under two paradigms: Model-driven development and code-driven development

Game developers often face more challenges when reusing code compared to non-game developers, and Software Product Lines (SPLs) have been successful in addressing this issue. In this study, we compare different approaches to code reuse in Classic Software Engineering (CSE) and Game Software Engineering (GSE) through a commercial video game called Kromaia. We specifically focus on two development paradigms: Model-Driven Development (MDD) and Code-Driven Development (CDD). We conduct an empirical evaluation where subjects develop game elements using two approaches: Clone and Own (CaO) and SPLs. The results show that game elements developed using SPLs are more correct (over 23%) than those developed with CaO in both MDD and CDD paradigms. In CDD, there are significant improvements in efficiency (51%) and satisfaction (13%) when using SPLs compared to CaO. However, no improvements are observed when working under MDD. The impact of using SPLs or CaO is greater in CDD than in MDD for game developers. Our findings suggest that SPLs in GSE may have a different role compared to their traditional role in CSE. Specifically, SPLs can be valuable in balancing game difficulty or generating new video game content, such as the one present in the bosses of the game.

A survey on the model-centered approaches to conceptual modeling of IoT systems

Internet of Things (IoT) is a system of connected objects, entities, devices, and components which share and transfer data over a network. Many papers are published on the topic of conceptual models in the IoT context, but it is difficult to assess the current status of the conceptual modeling approaches and methods for IoT systems. This paper presents an overview of the state of the art as well as discusses fundamental concepts, challenges and current research gaps with potential future agenda for conceptual modeling of IoT. Search facilities in the selected online repositories were used to identify the most relevant papers. The primary results were scanned and papers were selected according to the inclusion/exclusion criteria. Selected papers were assessed to extract data for the defined attributes. This paper confirms that there is a large body of research related to modeling of IoT systems. However, the results show that there is a lack of commonly agreed approaches and supporting formal methods for conceptual modeling of IoT systems. On the other hand, recent studies that apply model-based or model-driven development principles that use ontology or metamodel based approaches are promising due to systematic use of models as the primary means of a development process enabling for the dissemination of the methods further to the emerging fields such as smart cities, factories, transportation, hospitals, healthcare, hospitality and tourism, etc.

Detecting deviations in the code using architecture view-based drift analysis

ContextOne of the key requirements for the code is conformance with the architecture. Architectural drift implies the diverging of the implemented code from the architecture design of the system. Manually checking the consistency between the implemented code and architecture can be intractable and cumbersome for large-scale systems. ObjectiveThis article proposes a holistic, automated architecture drift analysis approach that explicitly focuses on the adoption of architecture views. The approach builds on, complements, and enhances existing architecture conformance analysis methods that do not adopt a holistic approach or fail to address the architecture viewpoints. MethodA model-driven development approach is adopted in which architecture views are represented as specifications of domain-specific languages. The code in its turn, is analyzed, and the architectural view specifications are reconstructed, which are then automatically checked with the corresponding architecture models. ResultsTo illustrate the approach, we have applied a systematic case study research for an architecture drift analysis of the business-to-customer (B2C) system within a large-scale software company. ConclusionThe case study research showed that divergences and absences of architectural elements could be detected in a cost-effective manner with the proposed approach.