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.

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.

Behavioral programming is a paradigm that allows to develop software based on scenarios and use cases. Behavior is implemented in asynchronous threads (b-threads) that run concurrently with each other and use event-based mechanisms to communicate and effect the overall system state. While the approach enables a natural and incremental development process, with a growing number of threads it gets increasingly harder to comprehend the system's state changes. In this paper, we address this problem with a debugger for behavioral programs. The debugger increases program comprehension by providing a clear overview of the system state as well as debugging-specific control capabilities such as breakpoints and advanced techniques like time-traveling and trace-comparison. For this, we utilize a runtime model of the system's state that is causally connected to the running system. We evaluate our approach using two case studies from literature.

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.

Model-driven software development addresses the growing need for individualized software and fast-changing requirements. To support timely changes to the software, adaptive object modeling realizes the domain model of an application as a runtime model represented by a changeable metamodel. Users can change both runtime- and metamodel. This leads, in principle, to a user-driven eternal system at runtime. However, model evolution is non-trivial as it introduces the co-evolution problem, i.e., what happens to the instances of an evolved model? Various approaches to address this problem exist. These approaches have weaknesses, leading to a system that ages with each evolution step. This work introduces a novel approach to cope a priori with the evolution of entity models at runtime. The Eternal Subspace Instance (ESI) approach bypasses the co-evolution problem by defining model instances as a "rich" composite structure capturing not just the current state of an instance. ESI are generated from a model extended with metadata specifying variants and versions. This information is used to interpret each ESI individually, independent of its variant and version. This work defines ESIs and proposes a framework for the resulting heterogeneous but variability-aware instances. We evaluate our approach with a publicly available reference implementation called modicio applied to an example scenario.

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.

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.

More than a decade ago, the research topic [email protected] was coined. Since then, the research area has received increasing attention. Given the prolific results during these years, the current outcomes need to be sorted and classified. Furthermore, many gaps need to be categorized in order to further develop the research topic by experts of the research area but also newcomers. Accordingly, the paper discusses the principles and requirements of [email protected] and the state of the art of the research line. To make the discussion more concrete, a taxonomy is defined and used to compare the main approaches and research outcomes in the area during the last decade and including ancestor research initiatives. We identified and classified 275 papers on [email protected], which allowed us to identify the underlying research gaps and to elaborate on the corresponding research challenges. Finally, we also facilitate sustainability of the survey over time by offering tool support to add, correct and visualize data.

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.

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.

SUMMARY Software is changed frequently during its life cycle. New requirements come, and bugs must be fixed. To update an application, it usually must be stopped, patched, and restarted. This causes time periods of unavailability, which is always a problem for highly available applications. Even for the development of complex applications, restarts to test new program parts can be time consuming and annoying. Thus, we aim at dynamic software updates to update programs at runtime. There is a large body of research on dynamic software updates, but so far, existing approaches have shortcomings either in terms of flexibility or performance. In addition, some of them depend on specific runtime environments and dictate the program's architecture. We present JavAdaptor, the first runtime update approach based on Java that (a) offers flexible dynamic software updates, (b) is platform independent, (c) introduces only minimal performance overhead, and (d) does not dictate the program architecture. JavAdaptor combines schema changing class replacements by class renaming and caller updates with Java HotSwap using containers and proxies. It runs on top of all major standard Java virtual machines. We evaluate our approach's applicability and performance in non‐trivial case studies and compare it with existing dynamic software update approaches. Copyright © 2012 John Wiley & Sons, Ltd.

Dynamic software updates (DSU) are one of the top-most features requested by developers and users. As a result, DSU is already standard in many dynamic programming languages. But, it is not standard in statically typed languages such as Java. Even if at place number three of Oracle's current request for enhancement (RFE) list, DSU support in Java is very limited. Therefore, over the years many different DSU approaches for Java have been proposed. Nevertheless, DSU for Java is still an active field of research, because most of the existing approaches are too restrictive. Some of the approaches have shortcomings either in terms of flexibility or performance, whereas others are platform dependent or dictate the program's architecture. With JavAdaptor, we present the first DSU approach which comes without those restrictions. We will demonstrate JavAdaptor based on the well-known arcade game Snake which we will update stepwise at runtime.

The particular benefit of cloud computing is the simple scalability of large applications, and many companies have already decided to use the cloud for their infrastructures. An enterprise IT infrastructure often includes a workflow management system. In a cloud, various workflow engines can coexist, each with its specific functional responsibility. A central instance is in charge of distributing process fragments without causing high technical or economic costs. The derivation of cost functions, the determination of the fragments to be executed on the respective engines with minimal costs, is a complex issue, especially if various processes have to be executed simultaneously. This paper approaches the problem of delegating an entire process to a distributed infrastructure and shows how it can be solved efficiently with neural networks. To ensure computation performance when handling various neural networks, we use the MapReduce framework. The distributed computation capability of MapReduce can help process the mass of training data generated by system monitoring in the networks. So, the performance usage in the central instance is decreased and the entire system is able to scale with the growing infrastructure.

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.