Context: Digital twins serve as virtual representations of systems, enabling capabilities such as intelligent monitoring, real-time control, decision-making, and predictive analytics. The Asset Administration Shell (AAS) is the pivotal Industry 4.0 standard for digital twin engineering. In parallel, the Systems Modeling Language (SysML) has emerged as a modeling standard for systems engineering, providing a formalized and semantically rich approach to system modeling. SysML v2 is its recent evolution. With its growing adoption, multiple models are expected to be widely available, each capturing different facets of the modeled system by leveraging diverse engineering capabilities offered by various tool ecosystems. Problem: Instead of manually re-creating models for digital twinning, existing system models should be leveraged to relieve repetitive modeling tasks. While SysML v2 and AAS are prominent standards in DT engineering, they lack direct integration, necessitating a dedicated approach for their seamless interoperability. Purpose: This paper presents a practical investigation into the conceptual alignment between the SysML v2 and AAS specifications, with a focus on their structural and behavioral modeling aspects. It proposes an implementable approach for mapping SysML v2 to AAS, enabling the automated generation of AAS models from SysML v2 models. Method: To realize this approach, we employ model-driven engineering techniques leveraging the Eclipse Modeling Framework (EMF) and model transformations based on the Query View Transformation (QVT) language. The proposed model transformation incorporates query mechanisms for extracting structured elements, preserving information and structural integrity, and ensuring static semantic consistency at design-time and seamless integration between the two investigated standards. We develop and validate the model transformation following an iterative test-driven development approach using an existing set of 24 SysML v2 examples, sourced from the official SysML v2 repository. Result: We deliver a QVT-based, EMF-compliant transformation that automatically generates AAS submodel templates from SysML v2 models, preserving structural hierarchies and behavioral semantics via dedicated AAS concepts and their extension. Through an iterative, test-driven development process, we validate metamodel conformance, information preservation, and structural integrity. The current mapping addresses design-time concepts, and the implementation supports forward transformation. All conceptual mappings, QVT scripts, and example artifacts are publicly available in a dedicated repository.

Digital twins are virtual representations of real-world entities or systems. Their primary goal is to help organizations understand and predict the behaviour and properties of these entities or systems. Additionally, digital twins enhance activities such as monitoring, verification, validation, and testing. However, the inherent complexity of digital twins implies challenges throughout the systems engineering process. This notably includes design, development, and analysis phases, as well as deployment, execution, and maintenance. Moreover, existing approaches, methods, techniques, and tools for modelling, simulating, validating, and monitoring single digital twins must now address the increased complexity in federation scenarios. These scenarios introduce new challenges, such as digital twin identification, shared metadata, cross-digital twin communication and synchronization, and federation governance. The KDT Joint Undertaking MATISSE project tackles these challenges by aiming to provide a model-driven framework for the continuous engineering of federated digital twins. It leverages model-driven engineering techniques and practices as the core enabling technology, with traceability serving as an essential infrastructural service for the digital twins federation. In this paper, we introduce the MATISSE conceptual framework for digital twins, highlighting both the novelty of the project's concept and its technical objectives. As the project is still in its initial phase, we identify key research challenges relevant to the DATE community and propose a preliminary research roadmap. This roadmap addresses traceability and federation mechanisms, the required continuous engineering strategy, and the development of digital twin-based services for verification, validation, prediction, and monitoring. To illustrate our approach, we present two concrete scenarios that demonstrate practical applications of the MATISSE conceptual framework.

Context: Due to the proliferation of generative AI models in different software engineering tasks, the research community has started to exploit those models, spanning from requirement specification to code development. Model-Driven Engineering (MDE) is a paradigm that leverages software models as primary artifacts to automate tasks. In this respect, modelers have started to investigate the interplay between traditional MDE practices and Large Language Models (LLMs) to push automation. Although powerful, LLMs exhibit limitations that undermine the quality of generated modeling artifacts, e.g., hallucination or incorrect formatting. Recording modeling operations relies on human-based activities to train modeling assistants, helping modelers in their daily tasks. Nevertheless, those techniques require a huge amount of training data that cannot be available due to several factors, e.g., security or privacy issues. Objective: In this paper, we propose an extension of a conceptual MDE framework, called MASTER-LLM, that combines different MDE tools and paradigms to support industrial and academic practitioners. Method: MASTER-LLM comprises a modeling environment that acts as the active context in which a dedicated component records modeling operations. Then, model completion is enabled by the modeling assistant trained on past operations. Different LLMs are used to generate a new dataset of modeling events to speed up recording and data collection. Results: To evaluate the feasibility of MASTER-LLM in practice, we experiment with two modeling environments, i.e., CAEX and HEPSYCODE, employed in industrial use cases within European projects. We investigate how the examined LLMs can generate realistic modeling operations in different domains. Conclusion: We show that synthetic traces can be effectively used when the application domain is less complex, while complex scenarios require human-based operations or a mixed approach according to data availability. However, generative AI models must be assessed using proper methodologies to avoid security issues in industrial domains.

Abstract Technical systems are becoming increasingly complex due to the increasing number of components, functions, and involvement of different disciplines. In this regard, model-driven engineering techniques and practices tame complexity during the development process by using models as primary artifacts. Modeling can be carried out through domain-specific languages whose implementation is supported by model-driven techniques. Today, the amount of data generated during product development is rapidly growing, leading to an increased need to leverage artificial intelligence algorithms. However, using these algorithms in practice can be difficult and time-consuming. Therefore, leveraging domain-specific languages and model-driven techniques for formulating AI algorithms or parts of them can reduce these complexities and be advantageous. This study aims to investigate the existing model-driven approaches relying on domain-specific languages in support of the engineering of AI software systems to sharpen future research further and define the current state of the art. We conducted a Systemic Literature Review (SLR), collecting papers from five major databases resulting in 1335 candidate studies, eventually retaining 18 primary studies. Each primary study will be evaluated and discussed with respect to the adoption of (1) MDE principles and practices and (2) the phases of AI development support aligned with the stages of the CRISP-DM methodology. The study’s findings show that language workbenches are of paramount importance in dealing with all aspects of modeling language development (metamodel, concrete syntax, and model transformation) and are leveraged to define domain-specific languages (DSL) explicitly addressing AI concerns. The most prominent AI-related concerns are training and modeling of the AI algorithm, while minor emphasis is given to the time-consuming preparation of the data sets. Early project phases that support interdisciplinary communication of requirements, such as the CRISP-DM Business Understanding phase, are rarely reflected. The study found that the use of MDE for AI is still in its early stages, and there is no single tool or method that is widely used. Additionally, current approaches tend to focus on specific stages of development rather than providing support for the entire development process. As a result, the study suggests several research directions to further improve the use of MDE for AI and to guide future research in this area.

Producing accurate software models is crucial in model-driven software engineering (MDE). However, modeling complex systems is an error-prone task that requires deep application domain knowledge. In the past decade, several automated techniques have been proposed to support academic and industrial practitioners by providing relevant modeling operations. Nevertheless, those techniques require a huge amount of training data that cannot be available due to several factors, e.g., privacy issues. The advent of large language models (LLMs) can support the generation of synthetic data although state-of-the-art approaches are not yet supporting the generation of modeling operations. To fill the gap, we propose a conceptual framework that combines modeling event logs, intelligent modeling assistants, and the generation of modeling operations using LLMs. In particular, the architecture comprises modeling components that help the designer specify the system, record its operation within a graphical modeling environment, and automatically recommend relevant operations. In addition, we generate a completely new dataset of modeling events by telling on the most prominent LLMs currently available. As a proof of concept, we instantiate the proposed framework using a set of existing modeling tools employed in industrial use cases within different European projects. To assess the proposed methodology, we first evaluate the capability of the examined LLMs to generate realistic modeling operations by relying on well-founded distance metrics. Then, we evaluate the recommended operations by considering real-world industrial modeling artifacts. Our findings demonstrate that LLMs can generate modeling events even though the overall accuracy is higher when considering human-based operations. In this respect, we see generative AI tools as an alternative when the modeling operations are not available to train traditional IMAs specifically conceived to support industrial practitioners.

With the emergence of Cyber-Physical Systems (CPS), the increasing complexity in development and operation demands for an efficient engineering process. In the recent years DevOps promotes closer continuous integration of system development and its operational deployment perspectives. In this context, the use of Artificial Intelligence (AI) is beneficial to improve the system design and integration activities, however, it is still limited despite its high potential. AIDOaRT is a 3 years long H2020-ECSEL European project involving 32 organizations, grouped in clusters from 7 different countries, focusing on AI-augmented automation supporting modelling, coding, testing, monitoring and continuous development of Cyber-Physical Systems (CPS). The project proposes to apply Model-Driven Engineering (MDE) principles and techniques to provide a framework offering proper AI-enhanced methods and related tooling for building trustable CPSs. The framework is intended to work within the DevOps practices combining software development and information technology (IT) operations. In this regard, the project points at enabling AI for IT operations (AIOps) to auto-mate decision making process and complete system development tasks. This paper presents an overview of the project with the aim to discuss context, objectives and the proposed approach.

With JSON's increasing adoption, the need for structural constraints and validation capabilities led to JSON Schema, a dedicated meta-language to specify languages which are in turn used to validate JSON documents. Currently, the standardisation process of JSON Schema and the implementation of adequate tool support (e.g., validators and editors) are work in progress. However, the periodic issuing of newer JSON Schema drafts makes tool development challenging. Nevertheless, many JSON Schemas as language definitions exist, but JSON documents are still mostly edited in basic text-based editors. To tackle this challenge, we investigate in this paper how Model-Driven Engineering (MDE) methods for language engineering can help in this area. Instead of re-inventing the wheel of building up particular technologies directly for JSON, we study how the existing MDE infrastructures may be utilized for JSON. In particular, we present a bridge between the JSONware and Modelware technical spaces to exchange languages and documents. Based on this bridge, our approach supports language engineers, domain experts, and tool providers in editing, validating, and generating tool support with enhanced capabilities for JSON schemas and their documents. We evaluate our approach with Shipyard, a JSON Schema-based language for the workflow specification for Keptn, an open-source tool for DevOps automation of cloud-native applications. The results of the case study show that proper editors and language evolution support from MDE can be reused and, at the same time, the surface syntax of JSON is maintained.

Context: Managing Non-Functional Requirements (NFRs) in software projects is challenging, and projects that adopt Model-Driven Development (MDD) are no exception. Although several methods and techniques have been proposed to face this challenge, there is still little evidence on how NFRs are handled in MDD by practitioners. Knowing more about the state of the practice may help researchers to steer their research and practitioners to improve their daily work. Objective: In this paper, we present our findings from an interview-based survey conducted with practitioners working in 18 different companies from 6 European countries. From a practitioner's point of view, the paper shows what barriers and benefits the management of NFRs as part of the MDD process can bring to companies, how NFRs are supported by MDD approaches, and which strategies are followed when (some) types of NFRs are not supported by MDD approaches. Results: Our study shows that practitioners perceive MDD adoption as a complex process with little to no tool support for NFRs, reporting productivity and maintainability as the types of NFRs expected to be supported when MDD is adopted. But in general, companies adapt MDD to deal with NFRs. When NFRs are not supported, the generated code is sometimes changed manually, thus compromising the maintainability of the software developed. However, the interviewed practitioners claim that the benefits of using MDD outweight the extra effort required by these manual adaptations. Conclusion: Overall, the results indicate that it is important for practitioners to handle `NFRs in MDD, but further research is necessary in order to lower the barrier for supporting a broad spectrum of NFRs with MDD. Still, much conceptual and tool implementation work seems to be necessary to lower the barrier of integrating the broad spectrum of NFRs in practice.

Domain-specific languages (DSLs) are popular for many reasons, such as increasing productivity for developers and improving communication with domain experts. Both textual and graphical DSLs are viable solutions with complementary pros and cons: while graphical DSLs shorten the learning curve and facilitate documentation and communication, textual DSLs aim at higher productivity thanks to more efficient editor functionalities. This paper presents the industrial experience on the adoption of a hybrid approach combining an existing textual DSL with a read-only graphical state machine representation (visualization), equipped with a selective abstraction functionality that offers user-specific, highly configurable views on states and transitions. Our approach is the result of an evolutionary process to improve the modelling experience, relying on frequent user feedback. We argue that a well-tailored visualization is a suitable way to shorten the learning curve and ease the adoption of model-driven approaches in industrial settings.

Context awareness is a first-class attribute of today software systems. Indeed, many applications need to be aware of their context in order to adapt their structure and behavior for offering the best quality of service even in case the software and hardware resources are limited. Modeling the context, its evolution, and its influence on the services provided by (possibly resource constrained) applications are becoming primary activities throughout the whole software life cycle, although it is still difficult to capture the multidimensional nature of context. We propose a framework for modeling and reasoning on the context and its evolution along multiple dimensions. Our approach enables (1) the representation of dependencies among heterogeneous context attributes through a formally defined semantics for attribute composition and (2) the stochastic analysis of context evolution. As a result, context can be part of a model-based software development process, and multidimensional context analysis can be used for different purposes, such as non-functional analysis. We demonstrate how certain types of analysis, not feasible with context-agnostic approaches, are enabled in our framework by explicitly representing the interplay between context evolution and non-functional attributes. Such analyses allow the identification of critical aspects or design errors that may not emerge without jointly taking into account multiple context attributes. The framework is shown at work on a case study in the eHealth domain.

Computer Aided Engineering Exchange (CAEX) is one of the most promising standards when it comes to data exchange between engineering tools in the production system automation domain. This is also reflected by the current emergence of AutomationML (AML), which uses CAEX as its core representation language. However, with the increasing use of CAEX, important language engineering challenges arise. One of these challenges is the customization of CAEX for its usage in superior standards, such as AML, which requires the precise specification of the language including the formalization and validation of additional usage rules. Another highly topical challenge is the ongoing evolution of CAEX as has recently happened with the transition from version 2.15 to version 3.0. Further challenges include the provisioning of editing facilities and visualizations of CAEX documents such that they can be inspected and modified by engineers, and the development of transformations from and to CAEX such that different engineering artifacts can be exchanged via CAEX. In this paper, we take a language engineering point of view and present a model-driven engineering (MDE) workbench for CAEX that allows to address these and other challenges. In particular, we present how CAEX can be formulated in a model-based framework, which allows the application of MDE techniques, such as model validation, migration, editing, visualization, and transformation techniques, to solve a diverse set of language engineering challenges experienced for CAEX. We give an overview of the developed workbench and illustrate its benefits with a focus on customizing CAEX for AML and evolving CAEX documents from version 2.15 to 3.0.

Variability modeling is an emerging topic in the general field of systems engineering and, with current trends such as Industrie 4.0, it gains more and more interest in the domain of production systems. Therefore, it is not sufficient to describe systems in several specific cases, but instead families of systems have to be used. In this paper we introduce a role class library for AutomationML to explicitly represent variability. This allows to exchange not only system descriptions but also system family descriptions. We argue for a light-weight extension of AutomationML. The variability-based modeling approach is based on cardinalities, which is a well-known concept from conceptual modeling and feature modeling. Furthermore, we also show how instantiations of variability models can be validated by our EMF-based AutomationML workbench.

Modern Cyber-Physical Systems (CPS) and Internet of Things (IoT) systems consist of both loosely and tightly interactions among various resources in IoT networks, edge servers and cloud data centers. These elements are being built atop virtualization layers and deployed in both edge and cloud infrastructures. They also deal with a lot of data through the interconnection of different types of networks and services. Therefore, several new types of uncertainties are emerging, such as data, actuation, and elasticity uncertainties. This triggers several challenges for testing uncertainty in such systems. However, there is a lack of novel ways to model and prepare the right infrastructural elements covering requirements for testing emerging uncertainties. In this paper, first we present techniques for modeling CPS/IoT Systems and their uncertainties to be tested. Second, we introduce techniques for determining and generating deployment configuration for testing in different IoT and cloud infrastructures. We illustrate our work with a real-world use case for monitoring and analysis of Base Transceiver Stations.

CAEX is one of the most promising standards when it comes to data exchange between engineering tools in the production system automation domain. This is also reflected by the current emergence of AutomationML, which uses CAEX as its core representation data format. Having such standards at hand, the question arises how to deal with the evolution of such standards as is currently happening with the transition from CAEX 2.15 to CAEX 3.0. In this paper, we take a language engineering point of view to the evolution of engineering data formats. In particular, we present how CAEX can be formulated in a model-based framework, which allows to reason about evolution of the data format as well as its impact on the data stored in such evolving formats. By this, not only the migration process of existing data to the new format version is possible, but also a more theoretical investigation on information preservation is possible. We demonstrate the approach by the concrete case of the upcoming CAEX evolution.

Data exchange is a critical issue within the multi-disciplinary engineering process of cyber physical production systems (CPPS). AutomationML (AML) is an emerging standard in the this field to represent and exchange artifacts between heterogeneous engineering tools used in mechanical, electrical, and software engineering domains. However, the interoperability of different exchange standards may be needed in order to integrate even further tools in tool chains. For instance, the Performance Model Interchange Format (PMIF) is a common representation devised in the performance engineering domain for model-based system performance analysis and simulation based on Queueing Network Models (QNM). Of course, such aspects are also of particular interest when designing a CPPS. This paper investigates, with the help of a case study, the combination of AML and PMIF as an enabling step towards an early performance validation of CPPS. By this, we close the current gap between CPPS engineering and performance engineering standards.

System models are essential in planning, designing, realizing, and maintaining production systems. AutomationML (AML) is an emerging standard to represent and exchange heterogeneous artifacts throughout the complete system life cycle and is more and more used as a modeling language. AML is designed as a flexible, prototype-based language able to represent the full spectrum of different artifacts. It may be utilized to build reusable libraries containing prototypical elements to build up production systems by using clones. However, libraries have to evolve over time, e.g., to reflect bug fixes, new features or refactorings, and so system models have to co-evolve to reflect the changes in the libraries. To tackle this co-evolution challenge, we specify in this paper the relationship between library elements, i.e., prototypes, and system elements, i.e., clones, by establishing a formal model for prototype-based modeling languages. Based on this formalization, we introduce several levels of consistency rigor one may want to achieve when modeling with prototype-based languages. These levels are also the main input to reason about the impact of library changes on the concrete system models for which we provide semi-automated co-evolution propagation strategies. We apply the established theory to the concrete AML case and present concrete tool support for evolving AML models based on Eclipse which demonstrates that consistency between system models and libraries may be maintained semi-automatically.

In this paper, we report on our experience with the application of validated models to assess performance, reliability, and adaptability of a complex mission critical system that is being developed to dynamically monitor and control the position of an oil-drilling platform. We present real-time modeling results that show that all tasks are schedulable. We performed stochastic analysis of the distribution of tasks execution time as a function of the number of system interfaces. We report on the variability of task execution times for the expected system configurations. In addition, we have executed a system library for an important task inside the performance model simulator. We report on the measured algorithm convergence as a function of the number of vessel thrusters. We have also studied the system architecture adaptability by comparing the documented system architecture and the implemented source code. We report on the adaptability findings and the recommendations we were able to provide to the system's architect. Finally, we have developed models of hardware and software reliability. We report on hardware reliability results based on the evaluation of the system architecture. As a topic for future work, we report on an approach that we recommend be applied to evaluate the system under study software reliability.