Context-awareness is crucial for developing cyber-physical systems to enable dynamic behavior. Context-oriented programming (COP) aims to improve the definition of context-dependent behavioral variations. However, existing layer-based COP approaches have two major limitations: layered methods are specified only for single contextual dimensions and restrict adaptations to method replacement or input/output filtering, limiting expressiveness for complex context dependencies.

As the markets for unmanned aerial vehicles (UAVs) and mixed reality (MR) headsets continue to grow, recent research has increasingly explored their integration, which enables more intuitive, immersive, and situationally aware control systems. We present IGUANA, an MR-based immersive guidance, navigation, and control system for consumer UAVs. IGUANA introduces three key elements beyond conventional control interfaces: (1) a 3D terrain map interface with draggable waypoint markers and live camera preview for high-level control, (2) a novel spatial control metaphor that uses a virtual ball as a physical analogy for low-level control, and (3) a spatial overlay that helps track the UAV when it is not visible with the naked eye or visual line of sight is interrupted. We conducted a user study to evaluate our design, both quantitatively and qualitatively, and found that (1) the 3D map interface is intuitive and easy to use, relieving users from manual control and suggesting improved accuracy and consistency with lower perceived workload relative to conventional dual-stick controller, (2) the virtual ball interface is intuitive but limited by the lack of physical feedback, and (3) the spatial overlay is very useful in enhancing the users’ situational awareness.

Abstract Ensembles and swarms occur everywhere in nature, in social and technical contexts. Their modeling and programming form a significant challenge in modern software systems engineering. While it is well-known how self-adaptive or autonomic systems can be designed advantageously, the effective modeling and programming of ensembles often require the engineering of new software languages, which necessitates a tremendous development effort. This paper presents a context-role-oriented approach for modeling the structure and behavior of ensembles. We contribute three design patterns for frequently occurring ensemble types, developed via context-role-oriented modeling. Additionally, we show the feasibility of nesting design patterns to describe the behavior of nested swarms.

In the future, technical systems, e.g., cyber-physical systems will increasingly become adaptive to changing contexts. However, programming context-adaptive systems is challenging. The context-specific behavior as well as when contexts change their activeness must be specified. Common general-purpose object-oriented languages require encoding the context-specific behavior in if-cascades. Standard polymorphism is insufficient to express the changing behavior of objects in different contexts because the complexity rises with the combinatorial explosion of a large, potentially multi-dimensional context space. Moreover, specifying when contexts are active has to be implemented as part of the application logic. In conclusion, there are two problems: the definition of context-specific behavior and the management of context changes. In this paper, we present a framework for the Julia programming language to develop context-adaptive systems. The framework also enables context-adaptive equation-based modeling. For context management, Petri nets are utilized. Julia was chosen for the implementation due to its simulation ecosystem, rich metaprogramming, and multiple dispatch, which enables precise specification of behavioral variants. We evaluate our approach by using two examples. The first scenario is a smart home control application. The second example shows how our framework can be used together with equation-based modeling for simulation.

The development of software applications for robotics is a challenging task for engineers due to the inherent parallelism of the code and the multitude of flexible factors that must be considered. Robotic assembly, a specific type of robotic application, involves the construction of pre-determined products using designated pieces. This further complicates the engineering task, as not only the robots must be considered but also the construction materials and the product itself. While several specialized solutions for robotic assembly exist, they are typically handcrafted and are tightly bound to the robots and materials they were designed for. Thus, it is hard for these solutions to be extended to respond to changes and newly added modules. This work proposes a model-driven approach to robotic assembly supporting diverse domains that can accommodate the seamless integration of robots. Relational reference attribute grammars are used for both metamodels and runtime models. To assess the feasibility and effectiveness of our proposed approach, we conducted a case study based on an industrial research project.

Teaching heterogeneous robotic cells is difficult and time-consuming. We present a context-aware robot teaching solution based on an open-source framework that decouples the task instruction from the task execution to simplify the teaching workflow significantly. To demonstrate the advantages of the solution, a human operator uses a VR headset and controllers to teach a virtual robot to perform a task, e.g., pick-and-place in a virtual world. The task is automatically adapted to different settings of operation cells and executed by physical robots located at different geographical locations.

Robotic systems compute data from multiple sensors to perform several actions (e.g., path planning, object detection). FPGA - based architectures for such systems may consist of several accelerators to process compute-intensive algorithms. Designing and implementing such complex systems tends to be an arduous task. This work proposes a modeling approach to generate architectures for such applications, compliant with existing robotics middlewares (e.g., ROS, ROS2). The challenge is to have a compact, yet expressive description of the system with just enough information to generate all required components and to integrate existing algorithms. This system model must be generalizable, so it is not application-dependent, and it must exploit the benefits of FPGAs over software solutions. Previous work mainly focused on individual accelerators rather than all components involved in a system and their interactions. The proposed approach exploits the advantages of model-driven engineering and model-based code generation to produce all components, i.e., message converters acting as middleware interfaces and wrappers to integrate algorithms. Data type and data flow analysis are performed to derive the necessary information to generate the components and their connections. Solutions to several identified challenges for generating entire systems from such models are evaluated using four different use cases.

Even though model-driven engineering reduces complexity during the development of self-adaptive systems and [email protected] enables using them during runtime, connecting models to different external systems still involves manual work. Those connections are essential to the complete system, as they enable external systems to react to changes in the internal model and vice versa. In our case, the model is based on Relational Reference Attribute Grammars, an extension of Attribute Grammars to enable conceptual models at runtime while retaining their benefits of modular specification and an incremental evaluation scheme. We present an approach to enable concise specification of the causal connection and needed transformations to match required formats or semantics. To show its applicability, a case study showing the coordination of multiple industrial robot arms using models is presented. We show that using our approach, connections can be specified more concisely while maintaining the same efficiency as hand-written code. The artefact comprising all source code and an executable version of the case studies is available at https://doi.org/10.5281/zenodo.7009758.

Abstract Our everyday lives are increasingly pervaded by digital assistants and smart devices forming the Internet of Things (IoT). While user interfaces to directly monitor and control individual IoT devices are becoming more sophisticated and end-user friendly, applications to connect standalone IoT devices and create more complexIoT processesfor automating and assisting users with repetitive tasks still require a high level of technical expertise and programming knowledge. Related approaches for process modelling in IoT mostly suggest extensions to complex modelling languages, require high levels of abstraction and technical knowledge, and rely on unintuitive tools. We present a novel approach for end-user oriented-no-code-IoT process modelling using Mixed Reality (MR) technology:HoloFlows. Users are able to explore the IoT environment and model processes among sensors and actuators as first-class citizens by simply “drawing” virtual wires among physical IoT devices. MR technology hereby facilitates the understanding of the physical contexts and relations among the IoT devices and provides a new and more intuitive way of modelling IoT processes. The results of a user study comparing HoloFlows with classical modelling approaches show an increased user experience and decrease in required modelling knowledge and technical expertise to create IoT processes.

Model-driven Software Development (MDSD) approaches struggle when modeling context-dependent and dynamic systems, as their underlying metamodels cannot capture context-dependent concepts and relations. By contrast, role-based modeling has been studied for more than 35 years as a promising paradigm to model context-dependent and dynamic systems. Although some approaches have considered the application of roles on the metamodel level, no approach employed a contextual and relational role-based metamodel as the basis of a modeling framework. To remedy this, we employ the Compartment Role Object Model (CROM) which is a contextual and relational role-based modeling language, as the underlying metamodel of a novel Role-based Modeling Framework (RMF). In particular, our framework is able to generate inter-operable Java source code that permits the programmatic creation, manipulation, and persistence of role-based models. We illustrate the applicability of RMF by modeling a small system with context-dependent concepts and relations, generating corresponding Java source code, and employing it to load, manipulate, and store role-based models.

The number of Internet of Things (IoT) devices increases and will become an ever important source of information made available through their sensors. As a result, devices form denser networks producing a huge variety and volume of data. If intercommunication and interaction between many decentralized resources are not considered as primary objective by vendors, networking distributed IoT devices will be complicated due to their heterogeneity. Thus, mastering the challenge of collecting and processing data with low-latency is a difficult task. In this paper, we present a practical and easy to employ reference software architecture for fog computing application scenarios, enabling the communication between a multitude of devices which require an efficient and robust real-time system. As proof, we conduct a practical demonstration—a three-dimensional mouse is constructed, called the Cube-It, to control a six-joint robot (i.e., the UR10). The findings of this work are expected to aid researchers studying the integration of heterogeneous IoT devices within fog computing environments comprising many sensors and actuators.

Model-driven Software Development (MDSD) promotes the use of multiple related models to realize a software system systematically. These models usually contain redundant information but are independently edited. This easily leads to inconsistencies among them. To ensure consistency among multiple models, model synchronizations have to be employed, e.g., by means of model transformations, trace links, or triple graph grammars. Model synchronization poses three main problems for MDSD. First, classical model synchronization approaches have to be manually triggered to perform the synchronization. However, to support the consistent evolution of multiple models, it is necessary to immediately and continuously update all of them. Second, synchronization rules are specified at design time and, in classic approaches, cannot be extended at runtime, which is necessary if metamodels evolve at runtime. Finally, most classical synchronization approaches focus on bilateral model synchronization, i.e., the synchronization between two models. Consequently, for more than two models, they require the definition of pairwise model synchronizations leading to a combinatorial explosion of synchronization rules. To remedy these issues, we propose a role-based approach for runtime model synchronization. In particular, we propose role-based synchronization rules that enable the immediate and continuous propagation of changes to multiple interrelated models (and back again). Additionally, our approach permits adding new and customized synchronization rules at runtime. We illustrate the benefits of role-based runtime model synchronization using the Families to Persons case study from the Transformation Tool Contest 2017.

Just like current software systems, models are characterised by increasing complexity and rate of change. Yet, these models only become useful if they can be continuously evaluated and validated. To achieve sufficiently low response times for large models, incremental analysis is required. Reference Attribute Grammars (RAGs) offer mechanisms to perform an incremental analysis efficiently using dynamic dependency tracking. However, not all features used in conceptual modelling are directly available in RAGs. In particular, support for non-containment model relations is only available through manual implementation. We present an approach to directly model uni- and bidirectional non-containment relations in RAGs and provide efficient means for navigating and editing them. This approach is evaluated using a scalable benchmark for incremental model editing and the JastAdd RAG system. Our work demonstrates the suitability of RAGs for validating complex and continuously changing models of current software systems.

Software Product Lines (SPLs) have a long tradition and aim at reducing development costs by increasing reuse. They have been successfully applied to develop families of languages, ultimately establishing the field of Language Product Lines (LPLs). Currently, LPLs facilitate a family of textual languages by defining an SPL of compilers/interpreters. In contrast, this work aims at supporting families of graphical languages by defining an SPL of graphical editors, whereas each language variant is supported by a corresponding product of a Graphical Editor Product Line (GEPL). Thus far, there exists no modular approach for the development of GEPLs for families of visual languages. To remedy this, this paper introduces a feature-oriented development approach for GEPLs that ensures modularity, maintainability, and extensibility of the resulting product line. To showcase the suitability and applicability of our approach, we developed a modular GEPL for the family of role-based modeling languages, a feature rich family of conceptual modeling languages. Finally, we illustrate its extensibility by adding a complex language feature.

Exhibiting and presenting real facilities, machines or related software products to visitors at trade fairs can be very challenging due to space constraints, installation costs or explaining complex data processing. Addressing these challenges, we introduce HoloFacility, Augmented Reality (AR) applications for Microsoft HoloLens. They offer an immersive and interactive experience by using in-air gestures. Visitors become able to explore hidden information and functionality, which otherwise would remain invisible. Thus, HoloFacility supports understanding underlying software systems. It also allows visitors to control certain features of real and virtual facilities. We implemented three use cases with different levels of augmentation and connected them to manufacturing execution and facility management systems: HoloCoffee, HoloMachines and HoloRobot. With demonstrations at trade fairs, we received positive feedback on UX aspects of HoloFacility and first impressions on using HoloLens as explanation support.

Role-based modeling has been investigated for over 35 years as a promising paradigm to model complex, dynamic systems. Although current software systems are characterized by increasing complexity and context-dependence, all this research had almost no influence on current software development practice, still being discussed in recent literature. One reason for this is the lack of a coherent, comprehensive, readily applicable notion of roles. Researchers focused either on relational roles or context-dependent roles rather then combining both natures. Currently, there is no role-based modeling language sufficiently incorporating both the relational and context-dependent nature of roles together with the various proposed constraints. Hence, this paper formalizes a full-fledged role-based modeling language supporting both natures. To show its sufficiency and adequacy, a real world example is employed.

Software product lines (SPLs) and software ecosystems (SECOs) encompass a family of closely related software systems in terms of common and variable assets that are configured to concrete products (variability in space). Over the course of time, variable assets of SPLs and especially SECOs are subject to change in order to meet new requirements as part of software evolution (variability in time). Even though both dimensions of variability have to be handled simultaneously, e.g., as not all customers upgrade their respective products immediately or completely, there currently is no approach that can create variants with a selection of variable assets in various versions. In this paper, we introduce an integrated approach to manage variability in space and time in software families using Hyper Feature Models (HFMs) with feature versions and combine them with an extension of the transformational variability realization mechanism delta modeling. This allows derivation of concrete software systems from an SPL or SECO configuring both functionality (features) as well as versions.

Software Product Lines (SPLs) are a successful approach to software reuse in the large. Even though tools exist to create SPLs, their evolution is widely unexplored. Evolving an SPL manually is tedious and error-prone as it is hard to avoid unintended side-effects that may harm the consistency of the SPL. The main contribution of this paper is the conceptual basis of a system for the evolution of model-based SPLs, which maintains consistency of models and feature mapping. As further contribution, a novel classification is introduced that distinguishes evolutions by their potential to harm the mapping of an SPL. In addition, multiple remapping operators are presented that can remedy the negative side-effects of evolutions in order to co-evolve the feature mapping. Finally, an implementation of the evolution system in the SPL tool FeatureMapper is provided to demonstrate the capabilities of the presented approach when co-evolving models and feature mapping of an SPL.

Separation of Concerns (SoC) is a common principle to reduce the complexity of large software and hypermedia systems. Amongst a variety of approaches, adaptation aspects are a well-known solution to significantly improve SoC in adaptive hypermedia applications. To model adaptation aspects in XML-based hypermedia applications, we developed PX-Weave, a tool which allows to specify and weave such aspects in multi-staged XML transformation environments. However, while aspects increase modularity and thus decrease complexity of software, they do also introduce some complex problems. The most prominent one, aspect interaction, has received a lot of attention from researchers during the last decade. In this paper we investigate the problem of aspect interaction for adaptation aspects. We present a combined approach for static and dynamic detection of aspect interactions in multi-staged XML-based hypermedia applications, which we implemented as an add-on to PX-Weave.

Model-driven software development (MDSD) bridges the gap between domain-specific abstractions and general purpose implementation languages and promises enhanced productivity for software engineering. The availability and appropriateness of tool environments supporting the developer is a crucial factor for such productivity promises. The widespread use of MDSD on various domains means a special challenge for the development of MDSD environments. Tool users expect advanced tools customised for the very special domain they are working in. However, tool development and customisation is a complex and expensive task. To address these challenges we propose to apply the principles of software product line engineering (SPLE) for feature-based customisation of MDSD tool environments. This paper is an experience report for the development of a product-line of MDSD tool environments that employ ontology technology to advance MDSD. Finally, we discuss the lessons learned as well as the benefits and challenges observed for feature-based tool customisation.

The role of data analytics increases in several application domains to cope with the large amount of captured data. Generally, data analytics are data-intensive processes, whose efficient execution is a challenging task. Each process consists of a collection of related structured activities, where huge data sets have to be exchanged between several loosely coupled services. The implementation of such processes in a service-oriented environment offers some advantages, but the efficient realization of data flows is difficult. Therefore, we use this paper to propose a novel SOA-aware approach with a special focus on the data flow. The tight interaction of new cloud technologies with SOA technologies enables us to optimize the execution of data-intensive service applications by reducing the data exchange tasks to a minimum. Fundamentally, our core concept to optimize the data flows is found in data clouds. Moreover, we can exploit our approach to derive efficient process execution strategies regarding different optimization objectives for the data flows.

Variants in a family of office documents are usually created by ad-hoc copy and paste actions from a set of base documents. As a result, the set of variants is decoupled from the original documents and is difficult to manage. In this paper we present a novel approach that uses concepts from Feature Oriented Domain Analysis (FODA) to specify document families to generate variants. As a proof of concept, we implemented the Document Feature Mapper tool, which is based on our previous experience in Software Product Line Engineering (SPLE) with FODA. In our tool, variant spaces are precisely specified using feature models and mappings relating features to slices in the document family. Gives a selection of features satisfying the feature model's constraints a variant can be derived. To show the applicability of our approach and tool, we conducted two case studies with documents in the Open Document Format (ODF).

Although the API of a software framework should stay stable, in practice it often changes during maintenance. When deploying a new framework version such changes may invalidate plugins - modules that used one of its previous versions. While manual plugin adaptation is expensive and error-prone, automatic adaptation demands cumbersome specifications, which the developers are reluctant to write and maintain. Basing on the history of structural framework changes (refactorings), in our previous work we formally defined how to automatically derive an adaptation layer that shields plugins from framework changes. In this paper we make our approach practical. Two case studies of unconstrained API evolution show that our approach scales in a large number of adaptation scenarios and comparing to other adaptation techniques. The evaluation of our logic-based tool ComeBack! demonstrates that it can adapt efficiently most of the problem-causing API refactorings.

In data-centric environments, for example, in the field of scientific computing, the transmission of large amount of structured data to Web services is required. In service-oriented environments (SOA), the Simple Object Access Protocol (SOAP) is commonly used as the main transport protocol. However, the resulting 'by value' data transmission approach is not efficiently applicable in data-centric environments. One challenging bottleneck of SOAP arises from the XML serialization and deserialization when processing large SOAP messages. In this paper, we present an extended Web service framework which explicitly considers the data aspects of functional Web services. Aside from the possibility to integrate specialized data transfer methods in SOA, this framework allows the efficient and scalable data handling and processing within Web services. In this case, we combine the advantages of the functional perspective (SOA) and the data perspective to efficiently support data-centric environments.

Graph rewrite systems can be used to specify and generate program optimizations. For termination of the systems several rule-based criteria are developed, defining exhaustive graph rewrite systems . For nondeterministic systems stratification is introduced which automatically selects single normal forms. To illustrate how far the methodology reaches, parts of the lazy code motion optimization are specified. The resulting graph rewrite system classes can be evaluated by a uniform algorithm, which forms the basis for the optimizer generator OPTIMIX. With this tool several optimizer components have been generated, and some numbers on their speed are presented.