Context: Technically sophisticated systems are the result of the joint work of several domain experts. However, the more people collaborate, the more important it becomes to make the model evolution and its single edit operations accessible and comprehensible for involved stakeholders. Objective: We developed the textual and semantic-aware query language EditQL. It enables domain experts to search for model versions, changes, and causing edit operations within a model’s edit history. Based on an operation-based versioning system, the query language covers both edit operations and all model states. Method: We systematically elaborate the requirements of a query language for edit histories. Based on this, we present a DSL integrated into an existing modeling tool. We conducted a mixed-methods usability study with 15 participants in which they had to answer various questions about a model’s evolution using EditQL. Results: All participants agreed on the usefulness of the query language, particularly the possibility of querying for semantic changes in the model. The measured System Usability Scale (SUS) scores range from OK to good. In addition, we identified a set of possible improvements. Conclusion: The study confirmed that EditQL and the underlying concepts are suitable tools to help domain experts understand the evolution of a model.

In a collaborative multi-user model-driven engineering context, it becomes important to track who changed what model part how and why. Operation-based versioning addresses this need by persisting a meaningful edit history which enables a single user to navigate through a model’s evolution over time, to analyze arbitrary previous model versions, or to trace the impact of an operation. However, to load a distinct prior version, it must be restored by reapplying all previous operations, which is time-consuming and, thus, interrupts a user’s workflow. Caching with a fixed distance between caches helps to overcome this problem to the cost of increasing memory requirements. Further, there is no caching approach supporting branches, merges, and possibly resolved conflicts. We propose two advanced caching strategies for operation-based versioning capable of the previously mentioned features: zonal and adaptive caching. Both strategies reduce the memory in use by not applying the same static distance between two caches across the whole edit history. Instead, the distance increases depending on a version’s age and its distance to a branch’s head. Both strategies aim to reduce the restoration time of arbitrary prior versions below a threshold to not interrupt a user’s flow of thought. Zonal caching employs predefined distances compatible with a broad range of model sizes. In contrast, adaptive caching derives the distances individually depending on the initial time to load the model on a user’s computer and the model’s size.We conducted controlled experiments with models of varying sizes and compared the time to restore model versions and the memory in use for no caching, caching with static distances, zonal, and adaptive strategies on different computers. The developed strategies decrease the time to restore a version remarkably while using less memory than static caching. Our results show that for all considered systems and models individual adaptive caching reduces memory usage even further compared to zone-based caching while still satisfying application responsiveness requirements.

The data layer of today's model management solutions often is either centralized or Git-based. We point out a number of limitations of current approaches, such as poor replicability, manually configured access control, centralization, hard-coded 'meta-data', and inflexible encodings. We argue for a set of fundamental features / restrictions (most importantly immutability and capability-based security) for decentralized model management systems to adapt, to solve these problems at their root. We distinguish a fundamental core from non-fundamental applications (such as versioning), that can be built on top.

Context: Technically sophisticated systems are the result of the joint work of several domain experts. However, the more people collaborate, the more important it becomes to make the model evolution and its single edit operations accessible and comprehensible for involved stakeholders. Objective: We developed the textual and semantic aware query language EditQL. It enables domain experts to search for model versions, changes, and causing edit operations within a model's edit history. Based on an operation-based versioning system, the query language covers both edit operations and all model states. Method: We systematically elaborate the requirements of a query language for edit histories. Based on this, we present a DSL integrated into an existing modeling tool. We conducted a mixed-methods usability study with 15 participants in which they had to answer various questions about a model's evolution using EditQL. Results: All participants agreed on the usefulness of the query language, particularly the possibility of querying for semantic changes in the model. The measured System Usability Scale (SUS) scores range from OK to good. In addition, we identified a set of possible improvements. Conclusion: The study confirmed that EditQL and the underlying concepts are suitable tools to help domain experts understand the evolution of a model.

CONTEXT: Today's industry heavily depends on the collaboration of multiple companies that have to exchange a lot of information. When these companies use technology roadmapping and model-driven development, this leads to the exchange of very large models, which is governed by competition laws, and the companies' interest in protecting their intellectual property. OBJECTIVE: We suggest an automated one-way model transformation approach to remove content worth protecting from a given model in the context of the graphical technology-roadmapping modeling tool IRIS. MET HOD: We elaborate constraints that an obfuscated model must fulfill. Based on these, we systematically identify and analyze appropriate one-way transformations to enable the desired level of obfuscation, implementing a proof of concept implementation in IRIS. Our approach first transforms the model into a flattened constraint system and uses nine selected transformations-ranging from constant folding to the tailoring of expressions-to create a new model without the sensitive content. We evaluate our transformations according to a set of predefined properties and constraints regarding their effects on the behavior of the model and the inferable information. LIM ITATIONS: Our obfuscation concerns the model and the embedded formulas but does not deal with individual data, which may be subject to privacy-related issues. RESULTS: We find that the identified transformations are applicable in practice and that they can remove a lot of sensitive information from a given model. Future work includes dealing with individual data and protecting against reverse-engineering attacks by domain experts.

CONTEXT: Versioning allows users to efficiently create and evolve artifacts, not only but especially in the domain of model-driven engineering. Due to collaboration tools, the place and time where users jointly work at their artifacts do not play an important role anymore. Objective: We systematically elaborated a classification framework for collaboration and versioning tools. The intention is threefold: First, it should be possible to classify existing approaches. Second, deriving from user goals requirements to be met, and capabilities to be supported by a new tool. Third, given a set of capabilities, highlight which user goals can be achieved. Method: According to Kang and Lee, we systematically elaborated a problem space and a solution space and created mappings between both spaces and their sub-spaces. To demonstrate the applicability, we classified existing VCS like git, Google Docs, and several MDE-specific approaches. Results: The created feature diagram covers 238 features and contains about 87 constraints. Conclusion: The developed framework supports researchers and developers in classifying their tools, revealing new opportunities to improve their tools, and guiding the development of new tools.

Context: Operation-based versioning introduces the benefit of meaningful edit histories. However, to load a distinct prior version, it must be restored by reapplying all previous operations, which is time-consuming and interrupts the user's workflow. Caching helps to overcome this problem to the cost of increasing memory requirements. Further, there is no caching approach supporting branches, merges, and possibly resolved conflicts. Objective: We developed an adaptive caching strategy capable of the previously mentioned features. The adaptive strategy aims at reducing the memory in use by garbage collecting aged caches by not using the same static distance between two caches across the whole edit history. Instead, the distance increases depending on a version's age and its distance to a branch's head. Method: We conducted a controlled experiment with models of several sizes and compared the time to restore model versions and the memory in use for no caching, static caching, and our developed adaptive caching. Results: Adaptive caching decreases the time to restore a version to 0.0007 % and 8.3 % compared to no caching. While static caching performs slightly better, it uses 70 % more memory than adaptive caching. Conclusion: Our adaptive caching strategy performs well on models with branches and merges and reduces the time to restore below thresholds which would negatively impact the user experience.

The complexity of modern software-intensive systems and the need for flexibility in their development process forces developers to collaborate using the most appropriate language(s) for each given task, view and component. Blended modeling is the ability to edit a model through multiple concrete syntaxes simultaneously.To support collaborative blended modeling, we present a variation of operation-based versioning that allows bi-directional propagation of changes between concrete and abstract syntaxes. This allows us to support layout continuity between different versions, and to handle information that is not (yet) available (e.g., layout information) when rendering changes from abstract to concrete syntax. Finally, our approach does not enforce immediate conflict resolution. Rather, different merge options and their consequences can be presented to the users, who may choose to only perform partial conflict resolution, deferring final resolution till later.In this article, we present the general approach and describe salient parts of an implementation.

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.

Optimistic versioning is a key component in supporting collaborative workflows. Text-based versioning has been widely adopted for versioning code, but in model-driven engineering, dealing with visual concrete syntaxes, new methods are required. In the case of blended modeling, a mixture of both textual and visual syntaxes, concurrently editable and synchronizable, introduces additional challenges. We propose a type of operation-based versioning to record not only user edits, but also bi-directional change propagations between concrete and abstract syntax. This way we can support blended modeling with layout continuity, and flexible handling of missing information (e.g., layout information) when rendering changes from abstract to concrete syntax. In addition, the proposed versioning approach enables collaborative conflict resolution by allowing partial conflict resolution, thus deferring a final resolution.

The introduction of major innovations in industry requires a collaboration across the whole value chain. A common way to organize such a collaboration is the use of technology roadmaps, which act as an industry-wide long-term planning tool. Technology roadmaps are used to identify industry needs, estimate the availability of technological solutions, and identify the need for innovation in the future. Roadmaps are inherently both time-dependent and based on uncertain values, i.e., properties and structural components can change over time. Furthermore, roadmaps have to reason about alternative solutions as well as their key performance indicators. Current approaches for model-based engineering do not inherently support these aspects. We present a novel model-based approach treating those aspects as first-class citizens. To address the problem of missing support for time in the context of roadmap modeling, we introduce the concepts of a common global time, time-dependent properties, and time-dependent availability. This includes requirements, properties, and the structure of the model or its components as well. Furthermore, we support the specification and analysis of key performance indicators for alternative solutions. These concepts result in a continuous range of various valid models over time instead of a single valid model at a certain point of time. We present a graphical user interface to enable the user to efficiently create and analyze those models. We further show the semantics of the resulting model by a translation into a set of global constraints as well as how we solve the resulting constraint system. We report on the evaluation of these concepts and the Iris tool with domain experts from different companies in the automotive value chain based on the industrial case of a smart sensing electrical fuse.

Context: Modeling industrial systems is mostly done collaboratively. In such a scenario, a model is modified by multiple people over a possibly long period of time. In consequence, modelers have to be able to understand a model’s evolution and, in particular, what elements of a model have changed, how, why, when, and by whom. Objective: We derive six distinct user goals and systematically design a graphical modeling languageagnostic set of tools that support users in achieving these goals. Method: We implement those tools and integrate them into an existing graphical modeling tool for technology roadmaps. To measure the tools’ usability, we conducted a mixed-methods study with participants of different levels of experience. With the set of developed tools at hand, in different scenarios, participants had to answer several questions regarding the evolution of a model. Results: The SUS score for assessing usability ranged from 80 to 95, indicating good to excellent usability. Task completeness (measured per scenario) ranged from 92% to 100%. Further, participants emphasized the added value of the tools while completing the scenarios. Conclusion: Although participants stated that the set of tools can be classified as expert tools, the developed tools achieve the goal of enabling users to comprehend changes made by others and trace the impacts of operations.

In the domain of Model-driven Engineering (MDE), modeling of software and technical systems is often a collaborative and interactive activity performed by several people. However, existing tools do not offer sufficient collaboration features as reported by studies conducted with industrial practitioners. In this paper, we introduce a new operation-based approach enabling both synchronous and asynchronous collaboration in graphical modeling tools. The presented approach is capable of conflict detection, resolving, branching, and merging. Furthermore, we demonstrate how a seamless transition between both collaboration modes can be ensured. We define user performed edit operations, such as adding a new block or changing a property’s value, as first-class citizens. Edit operations do not have to be atomic and can result in multiple atomic operations which are finally applied to the local model. Both kinds of operations are persisted in a sequential history and they are also distributed to other connected clients through a central server, which ensures a global unified history across all clients. Due to the sequential history consisting of operations and the change information they contain, we can apply a conflict detection method that is able to narrow down conflicts to the minimal possible set of individual conflicting operations for manual resolution while automatically merging the remaining changes.

Graceful degradation is an established concept to improve the resilience of systems, especially when other resilience mechanisms have failed. Its implementation is often heavily tied to the application code and, thus, cumbersome and error prone. As IoT systems get not only ubiquitous but also critical, reliable graceful degradation would be ideal. In this paper, we present the Morpheus framework that provides a TypeScript-internal DSL to enable a systematic development of degradable IoT systems. The design of the framework is based on the concept of separation of concerns by providing distinct yet linked languages to specify hierarchical components and their connections; the components’ operating modes and transfer functions between them; as well as state machines for the specification of the components’ behaviour in each operating mode. The operating modes for each component serve as degradation levels. Automatic degradation of a component is triggered in case of failures of connected components. With recovery from underlying failures, the component is automatically upgraded back to a higher level. We illustrate our framework using a simplified prototype of an entrance barrier of a parking garage.

Various studies conducted in the context of model-driven engineering (MDE) identified insufficient collaboration support of modeling tools. In the course of this paper, we present a research agenda to improve collaborative graphical modeling with a focus on users and change history. In contrast to other approaches, user level edit operations should be persisted instead of calculating differences of model versions a posteriori. We expect a detailed series of edit operations to be more self-descriptive than the differences between two versions of a model, which likely represents only the result of multiple edit operations. The expected advantages based on the more detailed history include a more understandable change history of an evolving model and new possibilities in collaboration, such as micro cherry picking of a set of specific edit operations instead of a whole commit. In addition, branching of only sub elements of a model as a way to explore alternatives during concurrent modeling is target of our research. Compared to existing approaches which mostly support either synchronous or asynchronous collaboration, the proposed research aims to support both through the use of Event Sourcing.

Modeling the architecture and behavior of embedded systems has long been a success story in the engineering of embedded systems due to the positive effects on quality and productivity, e.g., by declarative specifications, by enabling formal analyses, and by the generation of optimized code. These benefits, however, can only be reaped with extensive investments in specialized languages and tools which typically come with a closed and highly restrictive ecosystem. In this paper, we report our experiences while building an internal domain-specific language for IoT systems. We present our modeling language realized in TypeScript and integrated into the TypeScript/JavaScript ecosystem. The modeling language supports the declarative specification and execution of components, connectors, and state machines. We also provide a simple state space exploration to enable quality assurance techniques like test case generation and model checking. The language is illustrated by a running example with IoT devices. We believe that our solution lies at a sweet spot of providing a declarative modeling experience while reaping benefits from modern programming languages and their ecosystem to boost productivity.

The introduction of major innovations in industry requires a collaboration across the whole supply chain. A common way to organize such a collaboration is the use of technology roadmaps, which act as an industry-wide long-term planning tool. Technology roadmaps are used to identify industry needs, estimate the availability of technological solutions, and identify the need for innovation in the future. Roadmaps are inherently both time-dependent and based on uncertain values, i.e., properties and structural components can change over time. Current approaches for model-driven engineering do not inherently support these aspects. We present a novel model-driven approach treating those aspects as first-class citizens. To address the problem of missing support for time in the context of roadmap modeling, we introduce the concepts of a common global time, time-dependent properties, and time-dependent availability. This includes requirements, properties, and the structure of the model or its components as well. These concepts result in a continuous range of various valid models over time instead of a single valid model at a certain point of time. We present concepts for an interactive graphical user interface to enable the user to efficiently interact with those models. We illustrate the application of these concepts on an industrial example of a next generation electrical fuse.

The increasing societal pervasion and importance of the Internet-of-Things (IoT) raises questions regarding the fault tolerance and robustness of IoT applications as these increasingly become part of critical infrastructures. In this position paper, we outline novel ideas that focus on the design of a resilient and self-organizing execution platform for IoT applications called SORRIR. Its main ambition is to simplify, alleviate and accelerate the development, configuration and operation of resilient IoT systems. We follow a holistic approach which is based on a novel design process, a library containing resilience mechanisms and a robust execution platform that is equipped with monitoring and self-organizing capabilities. The goal is that developers only need to specify the desired resilience degree without having to worry about the technical, implementation-level details of employed resilience mechanisms.