Search

Although model transformations are considered to be the heart and soul of Model Driven Engineering (MDE), there are still several challenges that need to be addressed to unleash their full potential in industrial settings. Among other shortcomings, their performance and scalability remain unsatisfactory for dealing with large models, making their wide adoption difficult in practice. This paper presents A2L, a compiler for the parallel execution of ATL model transformations, which produces efficient code that can use existing multicore computer architectures, and applies effective optimizations at the transformation level using static analysis. We have evaluated its performance in both sequential and multi-threaded modes obtaining significant speedups with respect to current ATL implementations. In particular, we obtain speedups between 2.32x and 38.28x for the A2L sequential version, and between 2.40x and 245.83x when A2L is executed in parallel, with expected average speedups of 8.59x and 22.42x, respectively. Spanish Research Projects PGC2018-094905-B-I00, TIN2015-73968-JIN (AEI/FEDER/UE), Ramón y Cajal 2017 research grant, TIN2016-75944-R. Austrian Federal Ministry for Digital and Economic Affairs, the National Foundation for Research, Technology and Development, and by the FWF under the Grant Numbers P28519-N31 and P30525-N31.

This paper discusses the progress made so far and future challenges in integrating the analysis of multiple Non-Functional Properties (NFP) (such as performance, schedulability, reliability, availability, scalability, security, safety, and maintainability) into the Model-Driven Engineering (MDE) process. The goal is to guide the design choices from an early stage and to ensure that the system under construction will meet its non-functional requirements. The evaluation of the NFPs considered in this paper uses various kinds of NFP analysis models (also known as quality models) based on existent formalisms and tools developed over the years. Examples are queueing networks, stochastic Petri nets, stochastic process algebras, Markov chains, fault trees, probabilistic time automata, etc. In the MDE context, these models are automatically derived by model transformations from the software models built for development. Developing software systems that exhibit a good trade-off between multiple NFPs is difficult because the design of the software under construction and its underlying platforms have a large number of degrees of freedom spanning a very large discontinuous design space, which cannot be exhaustively explored. Another challenge in balancing the NFPs of a system under construction is due to the fact that some NFPs are conflicting—when one gets better the other gets worse—so an appropriate software process is needed to evaluate and balance all the non-functional requirements. The integration approach discussed in this paper is based on an ecosystem of inter-related heterogeneous modeling artifacts intended to support the following features: feedback of analysis results, consistent co-evolution of the software and analysis models, cross-model traceability, incremental propagation of changes across models, (semi)automated software process steps, and metaheuristics for reducing the design space size to be explored.

In this article, we address how the production of model transformations (MT) can be accelerated by automation of transformation synthesis from requirements, examples, and metamodels. We introduce a synthesis process based on metamodel matching, correspondence patterns between metamodels, and completeness and consistency analysis of matches. We describe how the limitations of metamodel matching can be addressed by combining matching with automated requirements analysis and model transformation by example (MTBE) techniques. We show that in practical examples a large percentage of required transformation functionality can usually be constructed automatically, thus potentially reducing development effort. We also evaluate the efficiency of synthesised transformations. Our novel contributions are: The concept of correspondence patterns between metamodels of a transformation. Requirements analysis of transformations using natural language processing (NLP) and machine learning (ML). Symbolic MTBE using “predictive specification” to infer transformations from examples. Transformation generation in multiple MT languages and in Java, from an abstract intermediate language.

The companies that have adopted the Model-Driven Engineering (MDE) paradigm have the advantage of working at a high level of abstraction. Nevertheless, they have the disadvantage of the lack of tools available to perform bug localization at the model level. In addition, in an MDE context, a bug can be related to different MDE artefacts, such as design-time models, model transformations, or run-time models. Starting the bug localization in the wrong place or with the wrong tool can lead to a result that is unsatisfactory. We evaluate how to apply the existing model-based approaches in order to mitigate the effect of starting the localization in the wrong place. We also take into account that software engineers can refine the results at different stages. In our evaluation, we compare different combinations of the application of bug localization approaches and human refinement. The combination of our approaches plus manual refinement obtains the best results. We performed a statistical analysis to provide evidence of the significance of the results. The conclusions obtained from this evaluation are: humans have to be involved at the right time in the process (or results can even get worse), and artefact-independence can be achieved without worsening the results.

The application of machine learning (ML) algorithms to address problems related to model-driven engineering (MDE) is currently hindered by the lack of curated datasets of software models. There are several reasons for this, including the lack of large collections of good quality models, the difficulty to label models due to the required domain expertise, and the relative immaturity of the application of ML to MDE. In this work, we presentModelSet, a labelled dataset of software models intended to enable the application of ML to address software modelling problems. To create it we have devised a method designed to facilitate the exploration and labelling of model datasets by interactively grouping similar models using off-the-shelf technologies like a search engine. We have built an Eclipse plug-in to support the labelling process, which we have used to label 5,466 Ecore meta-models and 5,120 UML models with its category as the main label plus additional secondary labels of interest. We have evaluated the ability of our labelling method to create meaningful groups of models in order to speed up the process, improving the effectiveness of classical clustering methods. We showcase the usefulness of the dataset by applying it in a real scenario: enhancing the MAR search engine. We useModelSetto train models able to infer useful metadata to navigate search results. The dataset and the tooling are available athttps://figshare.com/s/5a6c02fa8ed20782935cand a live version athttp://modelset.github.io.

In model-driven engineering (MDE), the unified modeling language (UML) 2.0 metamodel solution includes a metamodel that defines the language concepts and a user model that defines how the language concepts are represented. In UML 2.0, an important usage of metamodel is to ensure model consistency between different diagrams in the user model. However, most existing UML metamodels lack an integrated semantic framework to project each diagram in the user model as a view of the metamodel. To overcome the shortcomings of the current UML 2.0 metamodel approaches, we developed structure-behavior coalescence abstract state machine (SBC-ASM) for metamodel-based language (MBL), which provides an integrated semantic framework that is able to integrate structural constructs with behavioral constructs. Using SBC-ASM MBL as the metamodel solution of UML 2.0, each diagram in the user model can be projected as a view of the SBC-ASM.

Several difficulties commonly arise during the software development process. Among them are the lengthy technical process of developing a system, the limited number and technical capabilities of human resources, the possibility of bugs and errors during the testing and implementation phase, dynamic and frequently changing user requirements, and the need for a system that supports multi-platforms. Rapid application development (RAD) is the software development life cycle (SDLC) that emphasizes the production of a prototype in a short amount of time (30-90 days). This study discovered that implementing a model-driven architecture (MDA) approach into the RAD method can accelerate the model design and prototyping stages. The goal is to accelerate the SDLC process. It took roughly five weeks to construct the system by applying all of the RAD stages. This time frame does not include iteration and the cutover procedure. During the prototype test, there were no errors with the create, read, update, and delete (CRUD) procedure. It was demonstrated that automatic transformation in MDA can shorten the RAD phases for designing the model and developing an early prototype, reduce code errors in standard processes like CRUD, and construct a system that supports multi-platform.

Recommender systems are information filtering systems used in many online applications like music and video broadcasting and e-commerce platforms. They are also increasingly being applied to facilitate software engineering activities. Following this trend, we are witnessing a growing research interest on recommendation approaches that assist with modelling tasks and model-based development processes. In this paper, we report on a systematic mapping review (based on the analysis of 66 papers) that classifies the existing research work on recommender systems for model-driven engineering (MDE). This study aims to serve as a guide for tool builders and researchers in understanding the MDE tasks that might be subject to recommendations, the applicable recommendation techniques and evaluation methods, and the open challenges and opportunities in this field of research, This work has been funded by the European Union’s Horizon 2020 research and innovation programme under the Marie Skłodowska-Curie Grant Agreement No. 813884 (Lowcomote [134]), by the Spanish Ministry of Science (projects MASSIVE, RTI2018-095255-B-I00, and FIT, PID2019-108965GB-I00) and by the R&D programme of Madrid (Project FORTE, P2018/TCS-4314

Systems and applications aligned with new paradigms such as cloud computing and internet of the things are becoming more complex and interconnected, expanding the areas in which they are susceptible to attacks. Their security can be addressed by using model-driven engineering (MDE). In this context, specific IoT or cloud computing metamodels emerged to support the systematic development of software. In general, they are specified through semiformal metamodels in MOF style. This article shows the theoretical foundations of a method for automatically constructing secure metamodels in the context of realizations of MDE such as MDA. The formal metamodeling language Nereus and systems of transformation rules to bridge the gap between formal specifications and MOF are described. The main contribution of this article is the definition of a system of transformation rules called NEREUStoMOF for transforming automatically formal metamodeling specifications in Nereus to semiformal-MOF metamodels annotated in OCL.

We introduce a logic-based incremental approach to graph repair, generating a sound and complete (upon termination) overview of least-changing graph repairs from which a user may select a graph repair based on non-formalized further requirements. This incremental approach features delta preservation as it allows to restrict the generation of graph repairs to delta-preserving graph repairs, which do not revert the additions and deletions of the most recent consistency-violating graph update. We specify consistency of graphs using the logic of nested graph conditions, which is equivalent to first-order logic on graphs. Technically, the incremental approach encodes if and how the graph under repair satisfies a graph condition using the novel data structure of satisfaction trees, which are adapted incrementally according to the graph updates applied. In addition to the incremental approach, we also present two state-based graph repair algorithms, which restore consistency of a graph independent of the most recent graph update and which generate additional graph repairs using a global perspective on the graph under repair. We evaluate the developed algorithms using our prototypical implementation in the tool AutoGraph and illustrate our incremental approach using a case study from the graph database domain.

Presents papers from the 2020 IEEE Conference on Requirements Engineering and the ACM/ IEEE 23rd International Conference on Model Driven Engineering Languages and Systems (MODELS 2020).

Lately, the model-driven engineering community has been paying more attention to the techniques offered by the search-based software engineering community. However, even though the conformance of models and metamodels is a topic of great interest for the modeling community, the works that address model-related problems through the use of search metaheuristics are not taking full advantage of the strategies for handling nonconforming individuals. The search space can be huge when searching in model artifacts (magnitudes of around $$10^{150}$$ for models of 500 elements). By handling the nonconforming individuals, the search space can be drastically reduced. In this work, we present a set of nine generic strategies for handling nonconforming individuals that are ready to be applied to model artifacts. The strategies are independent from the application domain and only include constraints derived from the meta-object facility. In addition, we evaluate the strategies with two industrial case studies using an evolutionary algorithm to locate features in models. The results show that the use of the strategies presented can reduce the number of generations needed to reach the solution by 90% of the original value. Generic strategies such as the ones presented in this work could lead to the emergence of more complex fitness functions for searches in models or even new applications for the search metaheuristics in model-related problems.

International audience; Modelling languages and frameworks have been the key technology for advancing Model-Driven Engineering (MDE) methods and tools. Many industrial and research tools have been realised and are used across many domains. Hence, we think it is the right time to define what should be the future of modelling technologies, especially the requirements for the next generation of modelling frameworks and languages. In January 2020, the Second Winter Modelling Meeting (WMM2020) was held in San Vigilio di Marebbe (Italy), focusing on the analysis of the state of research, state of practice, and state of the art in MDE. The event brought together experts from industry, academia, and the open-source community to assess (i) what had changed in research on modelling in the last ten years, (ii) which problems are still unsolved, and (iii) which new challenges have arisen. This article presents a set of success stories and driving success factors of modelling and MDE, as well as a set of challenges and corresponding research directions that emerged from the synthesis of the results of our analysis.

The world of web is constantly evolving. Today, we no longer speak of a website but of a web application. The growing difficulty of designing web applications has given rise to solutions and tools. The framework is one of them. Providing a serious framework for development by offering strict development rules, as well as generic and out-of-the-box components, PHP laravel framework is one of them. This paper aims to present the different stages of modeling and development of an enterprise resource planning (ERP) system that will be implemented by PHP laravel by defining the main concepts involved in this information system modeling and development process. To lead and implement the end-to-end development of the said system, we apply the model-driven architecture (MDA) approach. This approach is based on atlas transformation language (ATL). The result of this paper is an Ecore file, a reliable MVC2 web model of e-commerce ERP, which will be the input file to generate the aforementioned system code. To validate this approach, we implemented a case study. The result of this work is very satisfying. Thus, we arrived to generate all necessary elements for this ERP code generation by respecting the MVC2 model and the PHP coding.

Engineering cyber-physical systems inhabiting contemporary urban spatial environments demands software engineering facilities to support design and operation. Tools and approaches in civil engineering and architectural informatics produce artifacts that are geometrical or geographical representations describing physical spaces. The models we consider conform to the CityGML standard; although relying on international standards and accessible in machine-readable formats, such physical space descriptions often lack semantic information that can be used to support analyses. In our context, analysis as commonly understood in software engineering refers to reasoning on properties of an abstracted model—in this case a city design. We support model-based development, firstly by providing a way to derive analyzable models from CityGML descriptions, and secondly, we ensure that changes performed are propagated correctly. Essentially, a digital twin of a city is kept synchronized, in both directions, with the information from the actual city. Specifically, our formal programming technique and accompanying technical framework assure that relevant information added, or changes applied to the domain (resp. analyzable) model are reflected back in the analyzable (resp. domain) model automatically and coherently. The technique developed is rooted in the theory of bidirectional transformations, which guarantees that synchronization between models is consistent and well behaved. Produced models can bootstrap graph-theoretic, spatial or dynamic analyses. We demonstrate that bidirectional transformations can be achieved in practice on real city models.

As the next step in the development of intelligent computing systems is the addition of human expertise and knowledge, it is a priority to build strong computable and well-documented knowledge bases. Ontologies partially respond to this challenge by providing formalisms for knowledge representation. However, one major remaining task is the population of these ontologies with concrete application. Based on Model-Driven Engineering principles, a generic metamodel for the extraction of heterogeneous data is presented in this article. The metamodel has been designed with two objectives, namely (1) the need of genericity regarding the source of collected pieces of knowledge and (2) the intent to stick to a structure close to an ontological structure. As well, an example of instantiation of the metamodel for textual data in chemistry domain and an insight of how this metamodel could be integrated in a larger automated domain independent ontology population framework are given.

Our research focuses on creating a meta-model for generating a web mapping application. It was difficult for non-geomatics developers to implement a webmapping application. Indeed, this type of application uses geospatial data that require geomatics skills. For this reason, in order to help non-geomatics developers to set up a webmapping application, we have designed a meta-model that automatically generates a webmapping application using model-driven engineering. The created meta-model is used by non-geomatics developers to explicitly write the concrete syntax specific to the webmapping application using the xtext tool. This concrete syntax is automatically converted into source code using the xtend tool without the intervention of the non-geomatics developers.

Interface and interaction design take up most of the times in software creation. Human Computer Interaction (HCI) is mainly the best way to interact with a computer. During software development, class diagram is the only required step and process to design an information system according to UML notation. In addition, creating class diagram is a mandatory activity during the software creation process. The aim of this paper is to automatically generate the HCI mockup from class diagram to make easy and extremely fast software design. For example, the SEF (Schema d’Enchainement de Fenetre), is an interface model allowing to create a new interface mockup. It offers more widgets to design the HCI. And MACAO (Methode d’Analyse et de Conception d’Applications Orientees-objets) is one of the methods which helps computer scientist to easily create software. The model transformation is based on Model Driven Engineering (MDE). We use UML notation to design the class diagrams. We also adopt MDA architecture to create the model-based transformation process. Transformation rules are created using Atlas Transformation Language (ATL) to automatically generate a specific interface from the class diagram.

In the Blockchain context, Smart Contracts are computer programs that run on the Ethereum platform. Benefiting from the properties of Blockchain, SCs development represents a major challenge to developers, as the code is deployed to an immutable system, besides the Ethereum platform is still evolving. This paper highlights how we can exploit model-driven engineering for generating long terms and high productivity smart contracts. It reviews researches on Smart Contracts generation in the Ethereum blockchain from a model-driven perspective. Based on the studied approaches, we defined a comparative framework to outline the advantages and disadvantages of each approach. The result can be used as a basis of tool selection for specific development aspects of SCs.

This paper describes a model-driven environment for configuration control and deployment of on-board satellite software. The solution enables platform-aware software development through the use of modelling artefacts provided by a framework called MICOBS. The paper describes the proposed platform model, as well as the supporting models needed to control the configuration of on-board software. The solution allows managing the models of on-board software projects in such a way that several alternatives for deploying and configuring the packages can be defined. The configuration control during validation and deployment of the on-board software of the control unit of the Energetic Particle Detector instrument on-board Solar Orbiter is presented as a use case. The example shows the versatility of the proposed approach in managing the deployment of software on the different boards resulting from the model philosophy of the space projects, as well as on any possible simulation environments used for software validation. Finally, it is noteworthy to highlight that this approach can also be used in software projects that were not initially following a model-driven paradigm, and that its adoption facilitates the configuration control of reusable software on new platforms adopted in new space missions.

Enes Yigitbas is a Senior Researcher at Paderborn University. In 2019, he got his doctoral degree in Computer Science under the advisory of Prof. Dr. Gregor Engels. During his doctorate, his research work was linked to various industrial projects in the Software Innovation Campus Paderborn (SICP). In this context, he was significantly involved in the implementation and management of various projects related to model-driven and human-centered software engineering, self-adaptive software systems, and human-computer interaction. His work on engineering adaptive user interfaces received a late-breaking results award at the ACM SIGCHI Symposium on Engineering Interactive Computing Systems. In addition to project and teaching activities, he is actively involved in various committee activities as well as serves as a reviewer for various international conferences and journals in the areas of Software Engineering and HCI. In his thesis, supervised by Prof. Dr. Gregor Engels (Paderborn University), he focused on the engineering and usability evaluation of self-adaptive user interfaces. Self-adaptive user interfaces (SAUIs) have been promoted as a solution for context variability due to their ability to automatically detect context changes and adapt to the current context-of-use at runtime. In the course of his thesis work, he developed a model-driven engineering approach which supports modeling, transformation, and execution of self-adaptive user interfaces. Furthermore, a novel on-the-fly usability testing solution for SAUIs has been introduced which allows to evaluate the end-user satisfaction of SAUIs by combining context monitoring together with collection of instant user feedback.

Emergent paradigms of Industry 4.0 and Industrial Internet of Things expect cyber-physical systems to reliably provide services overcoming disruptions in operative conditions and adapting to changes in architectural and functional requirements. In this paper, we describe a hardware/software framework supporting operation and maintenance of software-controlled systems enhancing resilience by promoting a Model-Driven Engineering (MDE) process to automatically derive structural configurations and failure models from reliability artifacts. Specifically, a reflective architecture developed around digital twins enables representation and control of system Configuration Items properly derived from SysML Block Definition Diagrams, providing support for variation. Besides, a plurality of distributed analytic agents for qualitative evaluation over executable failure models empowers the system with runtime self-assessment and dynamic adaptation capabilities. We describe the framework architecture outlining roles and responsibilities in a System of Systems perspective, providing salient design traits about digital twins and data analytic agents for failure propagation modeling and analysis. We discuss a prototype implementation following the MDE approach, highlighting self-recovery and self-adaptation properties on a real cyber-physical system for vehicle access control to Limited Traffic Zones.

International audience; Identifying, designing, deploying and maintaining accurate collaborative networks of organizations (e.g. responders in a crisis situation) are key activities in nowadays ecosystems. However, there is a lack regarding formal approaches dedicated to characterize collaborative networks of organizations. Formal descriptions of collaborative situations, that could be used, transformed, computed and exploited would be of great benefit for the quality of such collaborative networks. This article presents a model‐based AI framework for describing collaborative situations and the associated formal metamodel dedicated to be instantiated to characterize collaborative situations in a very wide range of application domains. This metamodel (describing collaborative situation between organizations) is structured according to four complementary dimensions: the context (social, physical and geographical environment), the partners (the involved organizations, their capabilities resources and relations), the objectives (the aims of the network, the goals to be the achieved and the risks to avoid, etc.) and the behaviour (the collaborative processes to be implemented by the partners to achieve the objectives in the considered context). Besides, this metamodel can be extended for some precise application domains. This article focuses on this mechanism in the specific context of crisis management.

International audience; The area of Engineering Interactive Computing Systems (EICS) is defined as the intersection between Software Engineering (SE) and Human-Computer Interaction (HCI). In this paper, we provide an overview of what EICS is and how it is positioned with respect to other venues in HCI, such as CHI, UIST, and IUI, highlighting its legacy and paying homage to past scientific events from which EICS emerged. We also take this opportunity to deliver a comparative analysis of the past, present, and perhaps future research and development questions raised in EICS by analyzing the EICS papers published from its first edition to this one, based on global and chronological word clouds, phrase nets, and topic modelling.

The degree of pollution has expanded with times by parcel of variables like the expansion in populace, expanded vehicle use, industrialization and urbanization, which brings about hurtful impacts on human prosperity by legitimately affecting soundness of populace presented to it. Poor environmental conditions can prompt serious medical issues. Destructive gases in hazardous environment influence these days individuals. The significant of this paper is watching unsafe environmental conditions for wellbeing applications. Right now itemized a study on toxic environment monitoring dependent on various innovations utilizing sensors.

Gap analysis is a common approach in industry to evaluate the gaps between the implemented software processes and the requirements of process quality frameworks or standard norms. Gap analysis processes are usually executed by means of questionnaires that need to be crafted ad hoc according to specific appraisal goals. The approaches used for developing, compiling and evaluating the answers given to these questionnaires usually do not follow well-defined methodologies or processes, and lack adequate tool support. This paper aims at investigating novel approaches for the execution of questionnaire-based gap analysis (QBGA) processes in industrial practices. We propose the adoption of state-of-the-art software engineering technologies and methodologies like application lifecycle management (ALM) and model-driven engineering (MDE) to support these processes. We perform an industrial survey for understanding the main issues affecting questionnaire-based gap analysis processes in industrial practices. We exploit model-driven engineering for building an ALM-based tool that supports the QBGA process execution and allows us to overcome the emerged process issues. We implement the GADGET tool to apply the MDE approach we use for developing the ALM-based tool. The feasibility of the proposed approach has been evaluated by a case study conducted in the automotive industrial domain. Two different QBGA processes have been configured and implemented in an ALM system with the support of the GADGET tool. The resulting ALM tool was used to perform the gap analysis processes. Semi-structured interviews with the involved industrial personnel were conducted to carry out a qualitative evaluation. The case study results show that the introduction of ALM improves the quality of the questionnaire-based gap analysis processes. Moreover, the adoption of model-driven engineering approach implemented by the GADGET tool provides a viable solution for configuring application lifecycle management systems and supporting the process execution.

Model Driven Engineering (MDE) has shown its results in the software development, particularly with the Model Driven Architecture approach (MDA). While the learner group specification phase, to perform collaborative activities in an integrated Technology Enhanced Learning (TEL) embedded system, is in-depth. Our proposal is based on the model driven engineering in the context of learner profile. Our hypothesis is the clustering analysis and then the use of models extracted from the group profile during collaborative mobile learning (m-Learning). These extracted models are at the heart of the approach we propose and which is the subject of this paper.

With the advent of software technologies, over a period of time, the Industrial Control Systems (ICSs) have grown exponentially. Whereas, almost all ICSs comprise Human Machine Interfaces (HMIs), which are the key component for monitoring and controlling complex industrial systems. For decades, traditional HMIs with simple User Interfaces (UIs) remained operational to minimize the complexities and resulting operational costs. However, due to the emergence of smartphone technologies, the perception about user interfaces has been transformed significantly and users now demand same sort of experience with industrial HMIs, as well. There are few industrial solutions, like, ICONICS GraphWorX to support the development of mobile HMI screens. However, such proprietary solutions are quite expensive. Furthermore, the underlying development approaches and source codes are not accessible in public domain. On the other hand, the state-of-the-art approaches for the development of native mobile HMI screens are hard to find in the literature. Consequently, there is dire need of a cost-effective, easy to use, open source framework for the development of native mobile HMI screens. In order to achieve this goal, here we propose, a M odel-driven M obile H MI F ramework ( MMHF ). MMHF comprises, a Unified Modeling Language (UML) Profile for Mobile HMI (UMLPMH) for modeling of HMI screens. MMHF also includes, an open source transformation engine and a M odel D riven M obile-based H MI C ode G enerator (MDMHCG) to automatically transform UMLPMH models into target native mobile HMI implementations. Consequently, MMHF enables simpler way to design the HMI screens using UMLPMH and generates native Mobile HMI Screen implementations automatically using MDMHCG. The empirical evidence of MMHF is demonstrated through three (3) benchmark case studies, which prove that the MMHF is a feasible, cost effective and scalable solution to develop native HMI screens for wide-ranging ICSs.

In 2017 and 2018, two events were held—in Marburg, Germany, and San Vigilio di Marebbe, Italy, respectively—focusing on an analysis of the state of research, state of practice, and state of the art in model-driven engineering (MDE). The events brought together experts from industry, academia, and the open-source community to assess what has changed in research in MDE over the last 10 years, what challenges remain, and what new challenges have arisen. This article reports on the results of those meetings, and presents a set of grand challenges that emerged from discussions and synthesis. These challenges could lead to research initiatives for the community going forward.

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.

Cotton cultivation in the Cote d’Ivoire is subject to enormous pressure from pests. This situation has important consequences on the yield of this crop. To improve yield, a strategy based on phytosanitary surveillance has been elaborated by the National Agronomic Research Center (CNRA). In this paper, we propose a digital solution for the implementation of this strategy. This solution is founded on an ontology (ontoSySParCotCI). It includes two main modules. The first module is a data collection and an alert system. It has a mobile interface for data collection and a web interface for access to data by researchers. The second module is a semantic wiki which is an interface for sharing and co-constructing knowledge on cotton cultivation. A prototype of the first module was presented as well as a satisfaction survey for its use.

Two crucial aspects for the trustworthy utilization of domain-specific languages (DSLs) are their semantic correctness, and proper testing support for their users. Testing is frequently used to verify correctness, but is often done informally -- which may yield unreliable results -- and requires substantial effort for creating suitable test cases and oracles. To alleviate this situation, we propose an automated technique for building metamorphic testing environments for DSLs. Metamorphic testing identifies expected relationships between the outputs of two consecutive tests, reducing the effort in specifying oracles and creating test cases manually. This new ideas paper presents the overarching concepts, the architecture and a prototype implementation. We illustrate our proposal using a DSL to model and simulate data centres.

Model-Driven Engineering (MDE) reduces complexity, improves Separation of Concerns and promotes reuse by structuring software development as a process of model production and refinement. Domain-Specific Modelling Languages and Aspect-Oriented Modelling techniques can reduce complexity and improve modularization of crosscutting concerns in situations where the features of general purpose modelling languages are not well aligned with the subject of study. In this article we present FIDDLR, a novel framework that integrates the ideas of Domain-Specific Modelling Languages, Concern-Oriented Reuse and MDE to modularize concerns that cross-cut multiple levels of abstraction of the software development process and streamline the reuse process. It also prescribes the integration of the different tooling along this process. We demonstrate the effectiveness of our framework and the potential for reduced complexity and leveraged reuse by building a reusable concern that exposes the services a system offers through a REST interface.

Industrial systems like power plants need a significant domain and engineering expertise for their efficient operations. Experts make decisions for multiple operational objectives such as minimizing cost, maximizing productivity, ensuring compliance to environmental conditions, etc. However, deciding strategies to achieve an objective can be highly non-trivial as it may lead to conflicting outcomes concerning other objectives. Modern digital twin(DT) technologies make it possible to build systems to support such decision-making to validate critical decisions. DTs are developed as one-off solutions for individual plants in the current practice, requiring high efforts and domain knowledge. Our work demonstrates the use of a knowledge-driven approach to reduce DT development efforts significantly. The main contribution of our work is an end-to-end architecture that allows us to explicate, structure, and reuse domain knowledge to semi-automate DT development for industrial plants. We integrate technologies like semantic web, model-driven engineering, and formal methods to realize the architecture. Our approach to developing a DT supporting a fault management scenario in a power plant reduced 70% development time and 50% manual efforts.

The growth of application architectures in all areas (e.g., astrology, meteorology, E-commerce, social network, etc.) has resulted in an exponential increase in data volumes, now measured in Petabytes. Managing these volumes of data has become a problem that relational databases are no longer able to handle because of the acidity properties. In response to this scaling up, new concepts have emerged such as NoSQL. In this paper, we show how to design and apply transformation rules to migrate from an SQL relational database to a big data solution within NoSQL. For this, we use the model driven architecture (MDA) and the transformation languages like as MOF 2.0 QVT (Meta-Object Facility 2.0 Query-View-Transformation) and Acceleo which define the meta-models for the development of transformation model. The transformation rules defined in this work can generate, from the class diagram, a CQL code for creation column-oriented NoSQL database.

Rolls-Royce Control Systems supplies engine control and monitoring systems for aviation applications, and is required to design, certify, and deliver these to the highest level of safety assurance. To allow Rolls-Royce to develop safe and robust systems, which continue to increase in complexity, model-based techniques are now a critical part of the software development process. In this paper, we discuss the experiences, challenges and lessons learnt when developing a bespoke domain-specific modelling workbench based on open-source modelling technologies including the Eclipse Modelling Framework (EMF), Xtext, Sirius and Epsilon. This modelling workbench will be used to architect and integrate the software for all future Rolls-Royce engine control and monitoring systems.

The automatic generation of software models is an important element in many software and systems engineering scenarios such as software tool certification, validation of cyber-physical systems, or benchmarking graph databases. Several model generators are nowadays available, but the topic of whether they generate realistic models has been little studied. The state-of-the-art approach to check the realistic property in software models is to rely on simple comparisons using graph metrics and statistics. This generates a bottleneck due to the compression of all the information contained in the model into a small set of metrics. Furthermore, there is a lack of interpretation in these approaches since there are no hints of why the generated models are not realistic. Therefore, in this paper, we tackle the problem of assessing how realistic a generator is by mapping it to a classification problem in which a Graph Neural Network (GnN) will be trained to distinguish between the two sets of models (real and synthetic ones). Then, to assess how realistic a generator is we perform the Classifier Two-Sample Test (C2ST). Our approach allows for interpretation of the results by inspecting the attention layer of the GNN. We use our approach to assess four state-of-the-art model generators applied to three different domains. The results show that none of the generators can be considered realistic.

Model-Based Development (MBD) is widely used for embedded controls development, with MATLAB/Simulink being one of the most used environments in the automotive industry. Simulink models are the primary design artifact and as with all software, must be constantly maintained and evolved over their lifetime. It is necessary to develop models that support likely changes in order to assist with evolution/maintenance processes. In order to do so, the types of frequently performed changes must be understood and appropriate language mechanisms must be available to support these changes. However, Simulink model changes are currently not well understood. We analyze a real industrial software repository of our industrial partner and its version control system to provide insights into the likely changes for Simulink. The intent with this analysis includes providing guidance on how Simulink is used in industrial practice and how particular model changes can impact system evolution.

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.

In recent decades, cyber-physical systems developed using Model-Driven Engineering (MDE) techniques have become ubiquitous in safety-critical domains. Safety assurance cases (ACs) are structured arguments designed to comprehensively show that such systems are safe; however, the reasoning steps, or strategies, used in AC arguments are often informal and difficult to rigorously evaluate. Consequently, AC arguments are prone to fallacies, and unsafe systems have been deployed as a result of fallacious ACs. To mitigate this problem, prior work [32] created a set of provably valid AC strategy templates to guide developers in building rigorous ACs. Yet instantiations of these templates remain error-prone and still need to be reviewed manually. In this paper, we report on using the interactive theorem prover Lean to bridge the gap between safety arguments and rigorous model-based reasoning. We generate formal, modelbased machine-checked AC arguments, taking advantage of the traceability between model and safety artifacts, and mitigating errors that could arise from manual argument assessment. The approach is implemented in an extended version of the MMINT-A model management tool [10]. Implementation includes a conversion of informal claims into formal Lean properties, decomposition into formal sub-properties and generation of correctness proofs. We demonstrate the applicability of the approach on two safety case studies from the literature.

With the aim to reduce car accidents, autonomous driving attracted a lot of attentions these years. However, recently reported crashes indicate that this goal is far from being achieved. Hence, cost-effective testing of autonomous driving systems (ADSs) has become a prominent research topic. The classical model-based testing (MBT), i.e., generating test cases from test models followed by executing the test cases, is ineffective for testing ADSs, mainly because of the constant exposure to ever-changing operating environments, and uncertain internal behaviors due to employed AI techniques. Thus, MBT must be adaptive to guide test case generation based on test execution results in a step-wise manner. To this end, we propose a natural language and model-based approach, named LiveTCM, to automatically execute and generate test case specifications (TCSs) by interacting with an ADS under test and its environment. LiveTCM is evaluated with an open-source ADS and two test generation strategies: Deep Q-Network (DQN)-based and Random. Results show that LiveTCM with DQN can generate TCSs with 56 steps on average in 60 seconds, leading to 6.4 test oracle violations and covering 14 APIs per TCS on average.

Although numerous methods have been formalized for handling the technical aspects of developing domain-specific modeling languages (DSMLs), user needs and usability aspects are often addressed in ad hoc manners and late in the development process. Working in this context, this paper presents the development of the customer journey modeling language (CJML), a DSML for modeling service processes from the end-user's perspective. CJML targets a wide and heterogeneous group of users, making it especially challenging regarding usability. This paper describes how an industry-relevant DSML was systematically improved by using a variety of user-centered design techniques in close collaboration with the target group and how their feedback was used to refine and evolve the syntax and semantics of CJML. We also suggest how a service-providing organization may benefit from adopting CJML as a unifying language for documentation purposes, compliance analysis, and service innovation. Finally, we generalize the experience gained into lessons learned and methodological guidelines.

Low-code platforms aim at allowing non-experts to develop complex systems and knowledgeable developers to improve their productivity in orders of magnitude. The greater gain comes from (re)using components developed by experts capturing common patterns across all layers of the application, from the user interface to the data layer and integration with external systems. Often, cloning sample code fragments is the only alternative in such scenarios, requiring extensive adaptation to reach the intended use. Such customization activities require deep knowledge outside of the comfort zone of low-code. To effectively speed up the reuse, composition, and adaptation of pre-defined components, low-code platforms need to provide safe and easy-to-use language mechanisms. This paper introduces OSTRICH, a strongly-typed rich templating language for a low-code platform (OutSystems) that builds on metamodel annotations and allows the correct instantiation of templates. We conservatively extend the existing metamodel and ensure that the resulting code is always well-formed. The results we present include a novel type safety verification of template definitions, and template arguments, providing model consistency across application layers. We implemented this template language in a prototype of the OutSystems platform and ported nine of the top ten most used sample code fragments, thus improving the reuse of professionally designed components.

Nowadays, while modeling environments provide users with facilities to specify different kinds of artifacts, e.g., metamodels, models, and transformations, the possibility of learning from previous modeling experiences and being assisted during modeling tasks remains largely unexplored. In this paper, we propose MORGAN, a recommender system based on a graph neural network (GNN) to assist modelers in performing the specification of metamodels and models. The (meta)model being specified, and the training data are encoded in a graph-based format by exploiting natural language processing (NLP) techniques. Afterward, a graph kernel function uses the extracted graphs to provide modelers with relevant recommendations to complete the partially specified (meta)models. We evaluated MORGAN on real-world datasets using various quality metrics, i.e., precision, recall, and F-measure. The experimental results are encouraging and demonstrate the feasibility of our tool to support modelers while specifying metamodels and models.

As software evolves, regression testing techniques are typically used to ensure the new changes are not adversely affecting the existing features. Despite recent advances, regression testing for distributed systems remains challenging and extremely costly. Existing techniques often require running a failing system several time before detecting a regression. As a result, conventional approaches that use re-execution without considering the inherent non-determinism of distributed systems, and providing no (or low) control over execution are inadequate in many ways. In this paper, we present MRegTest, a replay-based regression testing framework in the context of model-driven development to facilitate deterministic replay of traces for detecting regressions while offering sufficient control for the purpose of testing over the execution of the changed system. The experimental results show that compared to the traditional approaches that annotate traces with timestamps and variable values MRegTest detects almost all regressions while reducing the size of the trace significantly and incurring similar runtime overhead.