Search

This article provides a summary of the current state of the Software & Systems Modeling (SoSyM) journal in 2023. It highlights the publication of new papers and the addition of new editors to the journal. The retirement of two esteemed editors is also mentioned, with gratitude expressed for their contributions. The article includes statistics on the number of papers published, the impact factor of the journal, and the number of submissions and downloads. It announces the recipients of the journal's ten-year most influential paper awards and lists the papers presented at the MODELS conference. The article concludes by expressing appreciation to the reviewers for their contributions. Additionally, a separate document is a message of gratitude and recognition from the software and systems modeling community. The community expresses their appreciation to all the reviewers who have assisted the modeling community and announces the recipients of the Best Reviewers of 2023 award. The document also provides a list of all the reviewers who contributed their expertise to the journal over the past year. The content of the current issue is briefly mentioned, and the community wishes everyone a joyful New Year and encourages readers to explore the journal's archive. [Extracted from the article]

Business process modeling is a crucial aspect of domains such as Business Process Management and Software Engineering. The availability of various BPM languages in the market makes it challenging for process modelers to select the best-fit BPM language for a specific process modeling task. A decision model is necessary to systematically capture and make scattered knowledge on BPM languages available for reuse by process modelers and academics. This paper presents a decision model for the BPM language selection problem in research projects. The model contains mappings of 72 BPM features to 23 BPM languages. We validated and refined the decision model through 10 expert interviews with domain experts from various organizations. We evaluated the efficiency, validity, and generality of the decision model by conducting four case studies of academic research projects with their original researchers. The results confirmed that the decision model supports process modelers in the selection process by providing more insights into the decision process. Based on the empirical evidence from the case studies and domain expert feedback, we conclude that having the knowledge readily available in the decision model supports academics in making more informed decisions that align with their preferences and prioritized requirements. Furthermore, the captured knowledge provides a comprehensive overview of BPM languages, features, and quality characteristics that other researchers can employ to tackle future research challenges. Our observations indicate that BPMN is a commonly used modeling language for process modeling. Therefore, it is more sensible for academics to explain why they did not select BPMN than to discuss why they chose it for their research project(s). [ABSTRACT FROM AUTHOR]

Despite potential benefits in Software Engineering, adoption of software modelling in industry is low. Technical issues such as tool support have gained significant research before, but individual guidance and training have received little attention. As a first step towards providing the necessary guidance in modelling, we conduct a systematic literature review to explore the current state of the art. We searched academic literature for guidance on model creation and selected 35 papers for full-text screening through three rounds of selection. We find research on model creation guidance to be fragmented, with inconsistent usage of terminology, and a lack of empirical validation or supporting evidence. We outline the different dimensions commonly used to provide guidance on software and system model creation. Additionally, we provide definitions of the three terms modelling method, style, and guideline as current literature lacks a well-defined distinction between them. These definitions can help distinguishing between important concepts and provide precise modelling guidance. [ABSTRACT FROM AUTHOR]

Models are the key tools humans use to manage complexity in description, development, and analysis. This applies to all scientific and engineering disciplines and in particular to the development of software and data-intensive systems. However, different methods and terminologies have become established in the individual disciplines, even in the sub-fields of Informatics, which raises the need for a comprehensive and cross-sectional analysis of the past, present, and future of modeling research. This paper aims to shed some light on how different modeling disciplines emerged and what characterizes them with a discussion of the potential toward a common modeling future. It focuses on the areas of software, data, and process modeling and reports on an analysis of the research approaches, goals, and visions pursued in each, as well as the methods used. This analysis is based on the results of a survey conducted in the communities concerned, on a bibliometric study, and on interviews with a prominent representative of each of these communities. The paper discusses the different viewpoints of the communities, their commonalities and differences, and identifies possible starting points for further collaboration. It further discusses current challenges for the communities in general and modeling as a research topic in particular and highlights visions for the future. [ABSTRACT FROM AUTHOR]

Recently, formal methods have been used in large industrial organisations (including AWS, Facebook/Meta, and Microsoft) and have proved to be an effective part of a software engineering process finding important bugs. Perhaps because of that, practitioners are interested in using them more often. Nevertheless, formal methods are far less applied than expected, particularly for safety-critical systems where they are strongly recommended and have the most significant potential. We hypothesise that formal methods still seem not applicable enough or ready for their intended use in such areas. In critical software engineering, what do we mean when we speak of a formal method? And what does it mean for such a method to be applicable both from a scientific and practical viewpoint? Based on what the literature tells about the first question, with this manifesto, we identify key challenges and lay out a set of guiding principles that, when followed by a formal method, give rise to its mature applicability in a given scope. Rather than exercising criticism of past developments, this manifesto strives to foster increased use of formal methods in any appropriate context to the maximum benefit. [ABSTRACT FROM AUTHOR]

In a world where Artificial Intelligence (AI) is pervasive, humans may feel threatened or at risk by giving up control to machines. In this context, ethicality becomes a major concern to prevent AI systems from being biased, making mistakes, or going rogue. Requirements Engineering (RE) is the research area that can exert a great impact in the development of ethical systems by design. However, proposing concepts, tools and techniques that support the incorporation of ethicality into the software development processes as explicit requirements remains a great challenge in the RE field. In this paper, we rely on Ontology-based Requirements Engineering (ObRE) as a method to elicit and analyze ethicality requirements ('Ethicality requirements' is adopted as a name for the class of requirements studied in this paper by analogy to other quality requirements studied in software engineering, such as usability, reliability, and portability, etc. The use of this term (as opposed to 'ethical requirements') highlights that they represent requirements for ethical systems, analogous to how 'trustworthiness requirements' represent requirements for trustworthy systems. To put simply: the predicates 'ethical' or 'trustworthy' are not meant to be predicated over the requirements themselves). ObRE applies ontological analysis to ontologically unpack terms and notions that are referred to in requirements elicitation. Moreover, this method instantiates the adopted ontology and uses it to guide the requirements analysis activity. In a previous paper, we presented a solution concerning two ethical principles, namely Beneficence and Non-maleficence. The present paper extends the previous work by targeting two other important ethicality principles, those of Explicability and Autonomy. For each of these new principles, we do ontological unpacking of the relevant concepts, and we present requirements elicitation and analysis guidelines, as well as examples in the context of a driverless car case. Furthermore, we validate our approach by analysing the requirements elicitation made for the driverless car case in contrast with a similar case, and by assessing our method's coverage w.r.t European Union guidelines for Trustworthy AI. [ABSTRACT FROM AUTHOR]

This document is a guest editorial for the special section on SEFM 2020 and 2021 in the journal Software & Systems Modeling. The International Conference on Software Engineering and Formal Methods (SEFM) aims to bring together practitioners and researchers to advance the state of the art in formal methods and their application in the software industry. This special section includes selected papers from SEFM 2020 and 2021, which were held virtually during the COVID pandemic. Each article in this section has undergone rigorous peer review and has been revised and extended compared to its conference version. The selected papers cover topics such as embedded software portability and verification, nontermination inference, quantitative modeling and analysis of BDI agents, lazy model checking for recursive state machines, P-stable abstractions of hybrid systems, fairness and guarantees for extended bounded response LTL+P synthesis, counterexample classification, analyzing the impact of human errors on interactive service robotic scenarios, and active model learning of stochastic reactive systems. [Extracted from the article]

Model matching algorithms are used to identify common elements in input models, which is a fundamental precondition for many software engineering tasks, such as merging software variants or views. If there are multiple input models, an n-way matching algorithm that simultaneously processes all models typically produces better results than the sequential application of two-way matching algorithms. However, existing algorithms for n-way matching do not scale well, as the computational effort grows fast in the number of models and their size. We propose a scalable n-way model matching algorithm, which uses multi-dimensional search trees for efficiently finding suitable match candidates through range queries. We implemented our generic algorithm named RaQuN (Range Queries on N input models) in Java and empirically evaluate the matching quality and runtime performance on several datasets of different origins and model types. Compared to the state of the art, our experimental results show a performance improvement by an order of magnitude, while delivering matching results of better quality. [ABSTRACT FROM AUTHOR]

The authors discuss common control software maintenance tasks and tool capabilities based on existing research, and demonstrate the implementation of these capabilities in the 4diac IDE. However, there is limited empirical research on the usability and utility of model-based development environments for visual programming languages. The MODELS conference series is the premier venue for model-based software and systems engineering covering all aspects of modeling, from languages and methods to tools and applications. [Extracted from the article]

Industrial control applications are usually designed by domain experts instead of software engineers. These experts frequently use visual programming languages based on standards such as IEC 61131-3 and IEC 61499. The standards apply model-based engineering concepts to abstract from hardware and low-level communication. Developing industrial control software is challenging due to the fact that control systems are usually unique and need to be maintained for many years. The arising challenges, together with the growing complexity of control software, require very usable model-based development environments for visual programming languages. However, so far only little empirical research exists on the practical usefulness of such environments, i.e., their usability and utility. In this paper, we discuss common control software maintenance tasks and tool capabilities based on existing research and show the realization of these capabilities in the 4diac IDE. We performed a walkthrough of the demonstrated capabilities using the cognitive dimensions of notations framework from the field of human–computer interaction. We then improved the tool and conducted a user study involving ten industrial automation engineers, who used the 4diac IDE in a realistic control software maintenance scenario. Based on lessons learnt from this study, we adapted the 4diac IDE to better handle large graphical models. We evaluated these changes in a reassessment study with automation engineers from seven industrial enterprises. We derive general implications with respect to large-scale applications for developers of IDEs that we deem applicable in the context of (visual) model-based engineering tools. [ABSTRACT FROM AUTHOR]

Modeling is a key activity in conceptual design and system design. Through collaborative modeling, end-users, stakeholders, experts, and entrepreneurs are able to create a shared understanding of a system representation. While the Unified Modeling Language (UML) is one of the major conceptual modeling languages in object-oriented software engineering, more and more concerns arise from the modeling quality of UML and its tool-support. Among them, the limitation of the two-dimensional presentation of its notations and lack of natural collaborative modeling tools are reported to be significant. In this paper, we explore the potential of using virtual reality (VR) technology for collaborative UML software design by comparing it with classical collaborative software design using conventional devices (desktop PC/laptop). For this purpose, we have developed a VR modeling environment that offers a natural collaborative modeling experience for UML Class Diagrams. Based on a user study with 24 participants, we have compared collaborative VR modeling with conventional modeling with regard to efficiency, effectiveness, and user satisfaction. Results show that the use of VR has some disadvantages concerning efficiency and effectiveness, but the user's fun, the feeling of being in the same room with a remote collaborator, and the naturalness of collaboration were increased. [ABSTRACT FROM AUTHOR]

Optimization problems in software engineering typically deal with structures as they occur in the design and maintenance of software systems. In model-driven optimization (MDO), domain-specific models are used to represent these structures while evolutionary algorithms are often used to solve optimization problems. However, designing appropriate models and evolutionary algorithms to represent and evolve structures is not always straightforward. Domain experts often need deep knowledge of how to configure an evolutionary algorithm. This makes the use of model-driven meta-heuristic search difficult and expensive. We present a graph-based framework for MDO that identifies and clarifies core concepts and relies on mutation operators to specify evolutionary change. This framework is intended to help domain experts develop and study evolutionary algorithms based on domain-specific models and operators. In addition, it can help in clarifying the critical factors for conducting reproducible experiments in MDO. Based on the framework, we are able to take a first step toward identifying and studying important properties of evolutionary operators in the context of MDO. As a showcase, we investigate the impact of soundness and completeness at the level of mutation operator sets on the effectiveness and efficiency of evolutionary algorithms. [ABSTRACT FROM AUTHOR]

Structured query language (SQL) is a widely used language for accessing both relational and non-relational databases. SQL is the standard form of access in relational databases, while in non-relational databases, SQL is becoming increasingly available and consolidating itself as an access interface for querying data in cluster environments. Despite its declarative syntax, the specification of SQL queries is not a trivial task, even for experts, because some queries demand complex constructs (i.e., subqueries, joins, set operations, conditional expressions, grouping restrictions, and recursion). Visual query languages (VQLs) are an alternative to reduce this complexity. However, although several VQLs have been proposed, they are not widely used in practice. By identifying and analyzing the support provided by VQLs that make it possible to design complex SQL queries, this study collected evidence that helps discover the strengths and weaknesses of each VQL, providing useful feedback for other research initiatives that seek to propose improved VQLs. For this purpose, a systematic literature review was carried out. After analyzing 22 relevant studies and performing 462 inspections, this review points to the need for more expressive VQLs, computer-aided software engineering (CASE) tools available to end users, and more rigorous evaluations to investigate the VQL syntax and semantics. [ABSTRACT FROM AUTHOR]

Model-driven software engineering and specifically domain-specific languages have contributed to improve the quality of software and the efficiency in the development of software. However, the design and implementation of domain-specific languages requires still an enormous investment. Language workbenches are the most important tools in the field of software language engineering. The introduction of language workbenches has alleviated partly the development effort, but there are still a few major challenges that need to be tackled. This paper presents a personal perspective on the development of tools for language engineering and language workbenches in particular and future challenges to be tackled. [ABSTRACT FROM AUTHOR]

Conceptual modeling is a learning task essential to students of computer science, software engineering and related programs. Construed as a complex task, surprisingly little is known about the actual act of conceptual modeling, and about modeling difficulties learners experience. Combining complementary modes of observation of learners' modeling processes, we study modeling difficulties encountered while performing a data modeling task. Using the concept of cognitive breakdown, we analyze audiovisual protocols of the individual modelers' modeling processes, recordings of their interactions with the employed modeling software tool and survey data of modelers about their perception of encountered modeling difficulties. In an exploratory study and a follow-up study, we identify eight types of modeling difficulties related to modeling entity types, generalization hierarchies, relationship types, attributes and cardinalities. The identified types of modeling difficulties contribute to a better and more complete understanding of data modeling processes intended to inform design science research on modeling assistance for data modelers at different stages of their learning and mastering of conceptual data modeling. [ABSTRACT FROM AUTHOR]

Model merging conflicts occur when different stakeholders aim to integrate their contradicting changes that are applied concurrently to update software models. We conduct an extensive systematic mapping study on conflict management techniques and relevant collaboration attributes to the versioning and merging models from 2001 to the middle of 2021. This study follows the standard guidelines within the software engineering domain. We analyzed a total of 105 articles extracted from an initial pool of more than 1800 articles to infer a taxonomy for conflict management techniques. We use this taxonomy to classify existing approaches to understand characteristics, shortcomings, and challenges on conflict management techniques in merging models. It also provides a solid foundation for future work in this area. We show that syntactic conflicts are the most studied type and that the top three popular conflict detection techniques are constraint violation, change overlapping, and pattern matching. We observe the lack of a comprehensive state-of-the-art comparison between academic or industrial tools, as well as the need for real-world case studies. Finally, we show that recent trends have focused on online collaboration, where teams of stakeholders work on large-scale models. [ABSTRACT FROM AUTHOR]

Simulation is a key tool for researching complex system behaviour. Agent-based simulation has been applied across domains, such as biology, health, economics and urban sciences. However, engineering robust, efficient, maintainable, and reliable agent-based simulations is challenging. We present a vision for engineering agent simulations comprising a family of domain-specific modelling languages (DSMLs) that integrates core software engineering, validation and simulation experimentation. We relate the vision to examples of principled simulation, to show how the DSMLs would improve robustness, efficiency, and maintainability of simulations. Focusing on how to demonstrate the fitness for purpose of a simulator, the envisaged approach supports bi-directional transparency and traceability between the original domain understanding to the implementation, interpretation of results and evaluation of hypotheses. [ABSTRACT FROM AUTHOR]

Research Software Engineering is the use of Software Engineering practices to support the software needs when conducting research [Wikipedia, July 2023]. Software Engineering was made prominent when F. L. Bauer hosted the first conference on Software Engineering in 1968 to address the general software crisis that was identified in the 1960s. Similar to the original term "software engineering", the creation of the subfield "Research Software Engineering" (RSE) was necessary because there is an ongoing crisis in the development of software that supports research activities. [Extracted from the article]

Designing secure and reliable systems is a difficult task. Threat modeling is a process that supports the secure design of systems by easing the understanding of the system's complexity, as well as identifying and modeling potential threats. These threat models can serve as input for attack simulations, which are used to analyze the behavior of attackers within the system. To ensure the correct functionality of these attack simulations, automated tests are designed that check if an attacker can reach a certain point in the threat model. Currently, there is no way for developers to estimate the degree to which their tests cover the attack simulations and, thus, they cannot determine the quality of their tests. To resolve this shortcoming, we analyze structural testing methods from the software engineering domain and transfer them to the threat modeling domain by following an action design research approach. Further, we develop a first prototype, which is able to assess the test coverage in an automated way and provide a first approach to achieve full coverage. This will enable threat modeler to determine the quality of their tests and, simultaneously, increase the quality of the threat models. [ABSTRACT FROM AUTHOR]

The Object Management Group introduced the Model-Driven Architecture in 2001. Since then, the research community has embraced model-driven engineering (MDE), but to a lesser extent than practitioners had hoped. A good awareness of practitioners' challenges, particularly with modeling, is required to ensure the relevance of a research agenda. Therefore, this study conducts a meta-review on the state of practice in using modeling languages for software engineering over the last five years using Kitchenham's guidelines. This study serves as an orientation within the research field and a basis for further research. It contributes to the literature by focusing on publications discussing the practical use of modeling languages and the benefits and problems perceived by practitioners. The main finding of this review is that practitioners benefit from MDE in the following ways: it is beneficial for several stakeholders; it saves cost; it is easy to use; it improves productivity, quality, and understanding of the system; and it provides support for software development activities. However, practitioners continue to face several serious challenges. The most frequently reported issues are the missing tool functionalities. Many studies have found that adhering to the Physics of Notation principles would improve modeling languages. Other findings include that modeling is mostly used for documentation and requirements elicitation, and UML is the most often used. [ABSTRACT FROM AUTHOR]

Blended modeling aims to improve the user experience of modeling activities by prioritizing the seamless interaction with models through multiple notations over the consistency of the models. Inconsistency tolerance, thus, becomes an important aspect in such settings. To understand the potential of current commercial and open-source modeling tools to support blended modeling, we have designed and carried out a systematic study. We identify challenges and opportunities in the tooling aspect of blended modeling. Specifically, we investigate the user-facing and implementation-related characteristics of existing modeling tools that already support multiple types of notations and map their support for other blended aspects, such as inconsistency tolerance, and elevated user experience. For the sake of completeness, we have conducted a multivocal study, encompassing an academic review, and grey literature review. We have reviewed nearly 5000 academic papers and nearly 1500 entries of grey literature. We have identified 133 candidate tools, and eventually selected 26 of them to represent the current spectrum of modeling tools. [ABSTRACT FROM AUTHOR]

The development process of on-board software applications can benefit from model-driven engineering techniques. Model validation and model transformations can be applied to drive the activities of specification, requirements definition, and system-level validation and verification according to the space software engineering standards ECSS-E-ST-40 and ECSS-Q-ST-80. This paper presents a model-driven approach to completing these activities by avoiding inconsistencies between the documents that support them and providing the ability to automatically generate the system-level validation tests that are run on the Ground Support Equipment and the matrices required to complete the software verification. A demonstrator of the approach has been built using as a proof of concept a subset of the functionality of the software of the control unit of the Energetic Particle Detector instrument on-board Solar Orbiter. [ABSTRACT FROM AUTHOR]

Goal-oriented models are gaining significant attention from researchers and practitioners in various domains, especially in software requirements engineering. Similar to other software engineering models, goal models are subject to bad practices (i.e., bad smells). Detecting and rectifying these bad smells would improve the quality of these models. In this paper, we formally define the circular dependency bad smell and then develop an approach based on the simulated annealing (SA) search-based algorithm to detect its instances. Furthermore, we propose two mechanisms (namely, pruning and pairing) to improve the effectiveness of the proposed approach. We empirically evaluate three algorithm combinations, i.e., (1) the base SA search algorithm, (2) the base SA search algorithm augmented with pruning mechanism, and (3) the base SA search algorithm augmented with pruning and pairing mechanisms, using several case studies. Results show that simulated annealing augmented with pruning and pairing is the most effective approach, while the simulated annealing augmented with pruning mechanism is more effective than the base SA search algorithm. We also found that the proposed pruning and pairing mechanisms provide a significant improvement in the detection of circular dependency bad smell, in terms of computation time and accuracy. [ABSTRACT FROM AUTHOR]

With the increasing computing and networking capabilities, IoT devices and edge gateways have become part of a larger IoT–edge–cloud computing continuum, where processing and storage tasks are distributed across the whole network hierarchy, not concentrated only in the cloud. At the same time, this also introduced continuous delivery practices to the development of software components for network-connected gateways and sensing/actuating nodes. These devices are placed on end users' premises and are characterized by continuously changing cyber-physical contexts, forcing software developers to maintain multiple application versions and frequently redeploy them on a distributed fleet of devices with respect to their current contexts. Doing this correctly and efficiently goes beyond manual capabilities and requires an intelligent and reliable automated solution. This paper describes a model-based approach to automatically assigning multiple software deployment plans to hundreds of edge gateways and connected IoT devices implemented in collaboration with a smart healthcare application provider. From a platform-specific model of an existing edge computing platform, we extract a platform-independent model that describes a list of target devices and a pool of available deployment plans. Next, we use constraint solving to automatically assign deployment plans to devices at once with respect to their specific contexts. The result is transformed back into the platform-specific model and includes a suitable deployment plan for each device, which is then consumed by our engine to deploy software components not only on edge gateways but also on their downstream IoT devices with constrained resources and connectivity. We validate the approach with a fleet deployment prototype integrated into a DevOps toolchain used by the partner application provider. Initial experiments demonstrate the viability of the approach and its usefulness in supporting DevOps for edge and IoT software development. [ABSTRACT FROM AUTHOR]

In model-driven software engineering, models are used in all phases of the development process. These models must hold a high quality since the implementation of the systems they represent relies on them. Several existing tools reduce the burden of manually dealing with issues that affect models' quality, such as syntax errors, model smells, and inadequate structures. However, these tools are often inflexible for customization and hard to extend. This paper presents a customizable and extensible model repair framework, PARMOREL, that enables users to deal with different issues in different types of models. The framework uses reinforcement learning to automatically find the best sequence of actions for repairing a broken model according to user preferences. As proof of concept, we repair syntactic errors in class diagrams taking into account a model distance metric and quality characteristics. In addition, we restore inter-model consistency between UML class and sequence diagrams while improving the coupling qualities of the sequence diagrams. Furthermore, we evaluate the approach on a large publicly available dataset and a set of real-world inspired models to show that PARMOREL can decide and pick the best solution to solve the issues present in the models to satisfy user preferences. [ABSTRACT FROM AUTHOR]

The problem of mitigating uncertainty in self-adaptation has driven much of the research proposed in the area of software engineering for self-adaptive systems in the last decade. Although many solutions have already been proposed, most of them tend to tackle specific types, sources, and dimensions of uncertainty (e.g., in goals, resources, adaptation functions) in isolation. A special concern are the aspects associated with uncertainty modeling in an integrated fashion. Different uncertainties are rarely independent and often compound, affecting the satisfaction of goals and other system properties in subtle and often unpredictable ways. Hence, there is still limited understanding about the specific ways in which uncertainties from various sources interact and ultimately affect the properties of self-adaptive, software-intensive systems. In this SoSym expert voice, we introduce the Uncertainty Interaction Problem as a way to better qualify the scope of the challenges with respect to representing different types of uncertainty while capturing their interaction in models employed to reason about self-adaptation. We contribute a characterization of the problem and discuss its relevance in the context of case studies taken from two representative application domains. We posit that the Uncertainty Interaction Problem should drive future research in software engineering for autonomous and self-adaptive systems, and therefore, contribute to evolving uncertainty modeling towards holistic approaches that would enable the construction of more resilient self-adaptive systems. [ABSTRACT FROM AUTHOR]

Agile is often associated with a lack of architectural thinking causing technical debt but has the advantage of user centricity and a strong focus on value. Model-driven software engineering (MDSE) strongly performs for building a quality architecture and code, but lacks focus on user requirements and tends to consider development as a monolithic whole. The combination of Agile and MDSE has been explored, but a convincing integrated method has not been proposed yet. This paper addresses this gap by exploring the specific combination of MERODE—as an example of a proven MDSE method—with Scrum, a reference agile method offering a concrete (sprint-based) life cycle management on the basis of user stories. The method resulting of this integration is called Agile MERODE; it is driven by user stories, themselves associated with behavior-driven development scenarios. It allows for domain-driven design and permits fast development from domain models by means of code generation. An illustrative example further clarifies the practical application of Agile MERODE, while a case study shows the planning game application in the case's context. While the approach, in its entirety, allows reducing technical debt by building the architecture in a logical, consistent and complete manner, introducing MDSE involves a trade-off with pure value-driven development. Agile MERODE contributes to the state of the art by showing how to increase user centricity in MDSE, how to align model-driven engineering with the Scrum cycle, and how to reduce the technical debt of agile developments yet remaining value-focused. [ABSTRACT FROM AUTHOR]

The engineering of mechatronic production systems is complex and requires various disciplines (e.g., systems, mechanical, electrical and software engineers). Model-driven engineering (MDE) supports systems development and the exchange of information based on models and transformations. However, the integration and adoption of different modeling approaches are becoming challenges when it comes to cross-disciplinary work. VIATRA is a long-living enduring and mature modeling framework that offers rich model transformation features to develop MDE applications. This study investigates the extent to which VIATRA can be applied in the engineering of mechatronic production systems. For this purpose, two model transformation case studies are presented: "SysML – AutomationML" and "SysML4Mechatronics – AutomationML." Both case studies are representative of structural modeling and interdisciplinary data exchange during the development of mechatronic production systems. These case studies are derived from other researchers in the community. A VIATRA software prototype implements these case studies as a batch-oriented transformation and serves as one basis for evaluating VIATRA. To report on our observations and findings, we built on an evaluation framework from the MDE community. This framework considers 14 different characteristics (e.g., maturity, size, execution time, modularity, learnability), according to the Goal-Question-Metric paradigm. To be able to evaluate our findings, we compared VIATRA to ATL. We applied all cases to a lab-size mechatronic production system. We found that, with VIATRA, the same functions for model transformation applications can be achieved as with ATL, which is popular for model transformations in both the MDE and the mechatronic production systems community. VIATRA combines the relational, imperative, and graph-based paradigms and enables the development and execution of model-to-model (M2M) and model-to-text (M2T) transformations. Furthermore, the VIATRA internal DSL is based on Xtend and Java, making VIATRA attractive and intuitive for users with less experience in modeling than in object-oriented programming. Thus, VIATRA leads to an interesting alternative for the model-driven engineering of mechatronic production systems. It has the potential to reduce the complexity during the development of model transformations. To conclude, this paper evaluates the applicability of VIATRA, its strengths and limitations. It provides lessons learned and insights that can stimulate further research in the MDE for mechatronic production systems. [ABSTRACT FROM AUTHOR]

Software architecture models are considered first-class artifacts in current software engineering best practices. Thus, usable and well-understood modeling methods are required for software architects. For this aim, several specific software architecture modeling methods as well as generic design methods included in software development methodologies are available. However, we believe, there is the lack of more specific guidance in current software architecture methods. One of the principal causes of such a lack of specific guidance is the general-purpose nature of these methods. Therefore, further efforts are required to define domain-specific software architecture methods. In this paper, we present SOCAM, a software architecture modeling method for Web Service-Oriented Systems. We illustrate the use of SOCAM with a customization of the well-known SOA test application case: the Sun Adventure Builder system. A comparative analysis of SOCAM with other methods reveals a number of benefits of our method over the other approaches. Also, a survey research method evaluation confirms some of these benefits such as the fact that SOCAM is perceived as more useful than certain general-purpose methods. [ABSTRACT FROM AUTHOR]

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

Model-Based Software Engineering provides various modelling formalisms for capturing the structural, behavioral, configuration, and intentional aspects of software systems. One of the most widely used kinds of models—domain models—are used during requirements analysis or the early stages of design to capture the domain concepts and relationships in the form of class diagrams. Modellers perform domain modelling to transform the problem descriptions that express informal requirements in natural language to domain models, which are more concise and analyzable. However, this manual practice of domain modelling is laborious and time-consuming. Existing approaches, which aim to assist modellers by automating or semi-automating the construction of domain models from problem descriptions, fail to address three non-trivial aspects of automated domain modelling. First, automatically extracted domain models from existing approaches are not accurate enough to be used directly or with minor modifications for software development or teaching purposes. Second, existing approaches do not support modeller-system interactions beyond providing recommendations. Finally, existing approaches do not facilitate the modellers to learn the rationale behind the modelling decisions taken by an extractor system. Therefore, in this paper, we extend our previous work to facilitate bot-modeller interactions. We propose an algorithm to discover alternative configurations during bot-modeller interactions. Our bot uses this algorithm to find alternative configurations and then present these configurations in the form of suggestions to modellers. Our bot then updates the domain model in response to the acceptance of these suggestions by a modeller. Furthermore, we evaluate the bot for its effectiveness and performance for the test problem descriptions. Our bot achieves median F1 scores of 86%, 91%, and 90% in the Found Configurations, Offered Suggestions, and Updated Domain Models categories, respectively. We also show that the median time taken by our bot to find alternative configurations is 55.5ms for the problem descriptions which are similar to the test problem descriptions in terms of model size and complexity. Finally, we conduct a pilot user study to assess the benefits and limitations of our bot and present the lessons learned from our study in preparation for a large-scale user study. [ABSTRACT FROM AUTHOR]

The Discrete Event System Specification (DEVS) is a modular and hierarchical Modeling and Simulation (M&S) formalism based on systems theory that provides a general methodology for the construction of reusable models. Well-defined M&S structures have a positive impact when building simulation models because they can be applied systematically. However, even when DEVS can be used to model routing situations, the structures that emerge from this kind of problem are significant due to the handling of the flow of events. Often, the modeler ends with a lot of simulation models that refer to variants of the same component. The goal of this paper is to analyze the routing process domain from a conceptual modeling perspective through the use of a new DEVS extension called Routed DEVS (RDEVS). The RDEVS formalism is conceptually defined as a subclass of DEVS that manages a set of identified events inside a model network where each node combines a behavioral description with a routing policy. In particular, we study the modeling effort required to solve the M&S of routing problems scenarios employing a comparison between RDEVS modeling solutions and DEVS modeling strategies. Such a comparison is based on measures that promote the capture of the behavioral complexity of the final models. The results obtained highlight the modeling benefits of the RDEVS formalism as a constructor of routing processes. The proposed solution reduces the modeling effort involved in DEVS by specifying the event routing process directly in the RDEVS models using design patterns. The novel contribution is an advance in the understanding of how DEVS as a system modeling formalism supports best practices of software engineering in general and conceptual modeling in particular. The reusability and flexibility of the final simulation models, along with designs with low coupling and high cohesion, are the main benefits of the proposal that improve the M&S task applying a conceptual modeling perspective. [ABSTRACT FROM AUTHOR]

Mobile robots operate in various environments (e.g. aquatic, aerial, or terrestrial), they come in many diverse shapes and they are increasingly becoming parts of our lives. The successful engineering of mobile robotics systems demands the interdisciplinary collaboration of experts from different domains, such as mechanical and electrical engineering, artificial intelligence, and systems engineering. Research and industry have tried to tackle this heterogeneity by proposing a multitude of model-driven solutions to engineer the software of mobile robotics systems. However, there is no systematic study of the state of the art in model-driven engineering (MDE) for mobile robotics systems that could guide research or practitioners in finding model-driven solutions and tools to efficiently engineer mobile robotics systems. The paper is contributing to this direction by providing a map of software engineering research in MDE that investigates (1) which types of robots are supported by existing MDE approaches, (2) the types and characteristics of MRSs that are engineered using MDE approaches, (3) a description of how MDE approaches support the engineering of MRSs, (4) how existing MDE approaches are validated, and (5) how tools support existing MDE approaches. We also provide a replication package to assess, extend, and/or replicate the study. The results of this work and the highlighted challenges can guide researchers and practitioners from robotics and software engineering through the research landscape. [ABSTRACT FROM AUTHOR]

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. [ABSTRACT FROM AUTHOR]

Recently, there has been increased interest in combining model-driven engineering and search-based software engineering. Such approaches use meta-heuristic search guided by search operators (model mutators and sometimes breeders) implemented as model transformations. The design of these operators can substantially impact the effectiveness and efficiency of the meta-heuristic search. Currently, designing search operators is left to the person specifying the optimisation problem. However, developing consistent and efficient search-operator rules requires not only domain expertise but also in-depth knowledge about optimisation, which makes the use of model-based meta-heuristic search challenging and expensive. In this paper, we propose a generalised approach to automatically generate atomic multiplicity-preserving search operators for a given optimisation problem. This reduces the effort required to specify an optimisation problem and shields optimisation users from the complexity of implementing efficient meta-heuristic search mutation operators. We evaluate our approach with a set of case studies and show that the automatically generated rules are comparable to, and in some cases better than, manually created rules at guiding evolutionary search towards near-optimal solutions. [ABSTRACT FROM AUTHOR]

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. [ABSTRACT FROM AUTHOR]

We introduce Spectra, a new specification language for reactive systems, specifically tailored for the context of reactive synthesis. The meaning of Spectra is defined by a translation to a kernel language. Spectra comes with the Spectra Tools, a set of analyses, including a synthesizer to obtain a correct-by-construction implementation, several means for executing the resulting controller, and additional analyses aimed at helping engineers write higher-quality specifications. We present the language in detail and give an overview of its tool set. Together with the language and its tool set, we present four collections of many, non-trivial, large specifications, written by undergraduate computer science students for the development of autonomous Lego robots and additional example reactive systems. The collected specifications can serve as benchmarks for future studies on reactive synthesis. We present the specifications, with observations and lessons learned about the potential use of reactive synthesis by software engineers. [ABSTRACT FROM AUTHOR]

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. [ABSTRACT FROM AUTHOR]

In this paper, we present a novel technique to automatically synthesize consistent, diverse and structurally realistic domain-specific graph models. A graph model is (1) consistent if it is metamodel-compliant and it satisfies the well-formedness constraints of the domain; (2) it is diverse if local neighborhoods of nodes are highly different; and (1) it is structurally realistic if a synthetic graph is at a close distance to a representative real model according to various graph metrics used in network science, databases or software engineering. Our approach grows models by model extension operators using a hill-climbing strategy in a way that (A) ensures that there are no constraint violation in the models (for consistency reasons), while (B) more realistic candidates are selected to minimize a target metric value (wrt. the representative real model). We evaluate the effectiveness of the approach for generating realistic models using multiple metrics for guidance heuristics and compared to other model generators in the context of three case studies with a large set of real human models. We also highlight that our technique is able to generate a diverse set of models, which is a requirement in many testing scenarios. [ABSTRACT FROM AUTHOR]

This theme section aims to disseminate the latest research results in the area of open environmental software systems modeling. Software-intensive systems, such as cyber-physical systems and self-adaptive systems, need to be able to constantly operate in open and dynamic environments, which requires them to continuously evolve, handle internal and external uncertainties, and so on. Traditional software engineering methodologies need to be extended for tackling these new challenges, and modeling is a promising technique to do that. This theme section contains two papers that tackle these issues, that were accepted after a thorough peer-reviewing process. Moreover, it contains an "Expert's Voice" contribution on the uncertainty interaction problem, which is a relevant issue in the systems considered in this theme section. [ABSTRACT FROM AUTHOR]

They identify problems with current MDE tooling support for DevOps and give an industrial experience report describing how they enabled CI/CD pipelines using DevOps and MDE. From the perspective of MDE researchers, incorporating Agile practices into MDE appeared to be a way to widen the uptake of MDE to more general software application areas. Agile methods have become a widely used software development approach across many industry sectors [[14]], with established benefits in terms of increased responsiveness to change and decreased time to market. [Extracted from the article]

This theme section brings together the latest research at the intersection of artificial intelligence (AI) and model-driven engineering (MDE). Over the past years, we have witnessed a substantial rise of AI successfully applied to different domains, including software development and MDE. Dedicated events at the intersection of AI and MDE have been created, too, such as the MDE Intelligence workshop series co-located with the MODELS conference. This theme section covers research contributions integrating AI components into MDE approaches—increasing the current benefits of MDE processes and tools and pushing the limits of "classic" MDE with the goal to provide software and systems engineers with the right techniques to develop the next generation of highly complex model-based systems—and applications of MDE to the development of AI components. In total, nine submissions were accepted in the theme section after a thorough peer-reviewing process. [ABSTRACT FROM AUTHOR]

General ontology is a prominent theoretical foundation for information technology analysis, design, and development. Ontology is a branch of philosophy which studies what exists in reality. A widely used ontology in information systems, especially for conceptual modeling, is the BWW (Bunge–Wand–Weber), which is based on ideas of the philosopher and physicist Mario Bunge, as synthesized by Wand and Weber. The ontology was founded on an early subset of Bunge's philosophy; however, many of Bunge's ideas have evolved since then. An important question, therefore, is: do the more recent ideas expressed by Bunge call for a new ontology? In this paper, we conduct an analysis of Bunge's earlier and more recent works to address this question. We present a new ontology based on Bunge's later and broader works, which we refer to as Bunge's Systemist Ontology (BSO). We then compare BSO to the constructs of BWW. The comparison reveals both considerable overlap between BSO and BWW, as well as substantial differences. From this comparison and the initial exposition of BSO, we provide suggestions for further ontology studies and identify research questions that could provide a fruitful agenda for future scholarship in conceptual modeling and other areas of information technology. [ABSTRACT FROM AUTHOR]

Dealing with variability, during Software Product Line Engineering (SPLE), means trying to allow software engineers to develop a set of similar applications based on a manageable range of variable functionalities according to expert users' needs. Particularly, variability management (VM) is an activity that allows flexibility and a high level of reuse during software development. In the last years, we have witnessed a proliferation of methods, techniques and supporting tools for VM in general, and for its analysis in particular. More precisely, a specific field has emerged, named (automated) variability analysis, focusing on verifying variability models across the SPLE's phases. In this paper, we introduce a systematic literature review of existing proposals (as primary studies) focused on analyzing variability models. We define a classification framework, which is composed of 20 sub-characteristics addressing general aspects, such as scope and validation, as well as model-specific aspects, such as variability primitives, reasoner type. The framework allows to look at the analysis of variability models during its whole life cycle—from design to derivation—according to the activities involved during an SPL development. Also, the framework helps us answer three research questions defined for showing the state of the art and drawing challenges for the near future. Among the more interesting challenges, we can highlight the needs of more applications in industry, the existence of more mature tools, and the needs of providing more semantics in the way of variability primitives for identifying inconsistencies in the models. [ABSTRACT FROM AUTHOR]

The rise of domain-specific (Visual) languages and the inherent complexity of developing graphical editors for these languages have led to the emergence of proposals that provide support for this task. Most of these proposals are principally based on EMF and GMF, which effectively help to simplify and increase the level of automation of the development process of the editors, but it is important to recall that these proposals have some important disadvantages, mainly related to the learning curve of these technologies, poor documentation or the complexity of providing all the customisation possibilities to the user. In addition, in the process of developing a domain-specific language, issues related to graphical conventions have historically been undervalued, while most of the effort has been focused on semantic aspects. In fact, definitions of the concrete (visual) syntax of modelling languages in Software Engineering are usually based on common sense, intuition, the reuse of existing notations or emulation of common practices. In order to alleviate the inherent complexity of the EMF/GMF approach for the development of graphical editors and to support the evaluation of the quality of visual notations of modelling languages, this article presents CEViNEdit, an intuitive tool that simultaneously supports the semi-automatic generation of graphical editors and the assessment of the cognitive effectiveness of the visual notation implemented by the editor. [ABSTRACT FROM AUTHOR]

Low-code software development is heavily reliant on software reuse. The paper I Safe reuse in modeling language engineering using model subtyping with OCL constraints i by Artur Boronat focuses on low-code software development using Domain-Specific Languages (DSL) and Model-Driven Engineering (MDE). Software-intensive systems are becoming more complex, driven by the need to integrate across multiple aspects. [Extracted from the article]

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

High-tech companies are struggling today with the maintenance of legacy software. Legacy software is vital to many organizations as it contains the important business logic. To facilitate maintenance of legacy software, a comprehensive understanding of the software's behavior is essential. In terms of component-based software engineering, it is necessary to completely understand the behavior of components in relation to their interfaces, i.e., their interface protocols, and to preserve this behavior during the maintenance activities of the components. For this purpose, we present an approach to infer the interface protocols of software components from the behavioral models of those components, learned by a blackbox technique called active (automata) learning. To validate the learned results, we applied our approach to the software components developed with model-based engineering so that equivalence can be checked between the learned models and the reference models, ensuring the behavioral relations are preserved. Experimenting with components having reference models and performing equivalence checking builds confidence that applying active learning technique to reverse engineer legacy software components, for which no reference models are available, will also yield correct results. To apply our approach in practice, we present an automated framework for conducting active learning on a large set of components and deriving their interface protocols. Using the framework, we validated our methodology by applying active learning on 202 industrial software components, out of which, interface protocols could be successfully derived for 156 components within our given time bound of 1 h for each component. [ABSTRACT FROM AUTHOR]

Modeling is requiring increasingly larger efforts while becoming indispensable given the complexity of the problems we are solving. Modelers face high cognitive load to understand a multitude of complex abstractions and their relationships. There is an urgent need to better support tool builders to ultimately provide modelers with intelligent modeling assistance that learns from previous modeling experiences, automatically derives modeling knowledge, and provides context-aware assistance. However, current intelligent modeling assistants (IMAs) lack adaptability and flexibility for tool builders, and do not facilitate understanding the differences and commonalities of IMAs for modelers. Such a patchwork of limited IMAs is a lost opportunity to provide modelers with better support for the creative and rigorous aspects of software engineering. In this expert voice, we present a conceptual reference framework (RF-IMA) and its properties to identify the foundations for intelligent modeling assistance. For tool builders, RF-IMA aims to help build IMAs more systematically. For modelers, RF-IMA aims to facilitate comprehension, comparison, and integration of IMAs, and ultimately to provide more intelligent support. We envision a momentum in the modeling community that leads to the implementation of RF-IMA and consequently future IMAs. We identify open challenges that need to be addressed to realize the opportunities provided by intelligent modeling assistance. [ABSTRACT FROM AUTHOR]