A Dynamic Instance Binding Mechanism Supporting Run-Time Variability of Role-Based Software Systems

Role-based approaches gain more and more interest for modeling and implementing variable software systems. Role models clearly separate static behavior represented by players and dynamic behavior modeled as roles which can be dynamically bound and unbound to players at run time. To support the execution of role-based systems, a dynamic binding mechanism is required. Especially, since instances of the same player type can play different roles in a single context, the binding mechanism is required to operate at instance level. In this paper, we introduce a mechanism called dynamic instance binding for implementing a runtime for role-based systems. It maintains a look-up table that allows the run-time system to determine and invoke the currently active role binding at instance level. We explain dynamic instance binding mechanism in detail and demonstrate that it is flexible enough to support both adaptation and evolution of software systems at run time

Consistent Unanticipated Adaptation for Context-Dependent Applications

Unanticipated adaptation allows context-dependent applications to overcome the limitation of foreseen adaptation by incorporating previously unknown behavior. Introducing this concept in language-based approaches leads to inconsistencies as an object can have different views in different contexts. Existing language-based approaches do not address unanticipated adaptation and its associated run-time inconsistencies. We propose an architecture for unanticipated adaptation at run time based on dynamic instance binding crafted in a loosely manner to asynchronously replace adaptable entities that allow for behavioral changes of objects. To solve inconsistencies, we introduce the notion of transactions at the object level. Transactions guard the changing objects during their execution, ensuring consistent views. This allows for disruption-free, safe updates of adaptable entities by means of consistent unanticipated adaptation

Decentralized Coordination of Dynamic Software Updates in the Internet of Things

Large scale IoT service deployments run on a high number of distributed, interconnected computing nodes comprising sensors, actuators, gateways and cloud infrastructure. Since IoT is a fast growing, dynamic domain, the implementation of software components are subject to frequent changes addressing bug fixes, quality insurance or changed requirements. To ensure the continuous monitoring and control of processes, software updates have to be conducted while the nodes are operating without losing any sensed data or actuator instructions. Current IoT solutions usually support the centralized management and automated deployment of updates but are restricted to broadcasting the updates and local update processes at all nodes. In this paper we propose an update mechanism for IoT deployments that considers dependencies between services across multiple nodes involved in a common service and supports a coordinated update of component instances on distributed nodes. We rely on LyRT on all IoT nodes as the runtime supporting local disruption-minimal software updates. Our proposed middleware layer coordinates updates on a set of distributed nodes. We evaluated our approach using a demand response scenario from the smart grid domain

Efficient Late Binding of Dynamic Function Compositions

Adaptive software becomes more and more important as computing is increasingly context-dependent. Runtime adaptability can be achieved by dynamically selecting and applying context-specific code. Role-oriented programming has been proposed as a paradigm to enable runtime adaptive software by design. Roles change the objects’ behavior at runtime and thus allow adapting the software to a given context. However, this increased variability and expressiveness has a direct impact on performance and memory consumption. We found a high overhead in the steady-state performance of executing compositions of adaptations. This paper presents a new approach to use run-time information to construct a dispatch plan that can be executed efficiently by the JVM. The concept of late binding is extended to dynamic function compositions. We evaluated the implementation with a benchmark for role-oriented programming languages leveraging context-dependent role semantics achieving a mean speedup of 2.79× over the regular implementation

Efficient Dispatch of Multi-object Polymorphic Call Sites in Contextual Role-Oriented Programming Languages

Adaptive software becomes more and more important as computing is increasingly context-dependent. Runtime adaptability can be achieved by dynamically selecting and applying context-specific code. Role-oriented programming has been proposed as a paradigm to enable runtime adaptive software by design. Roles change the objects’ behavior at runtime, thus adapting the software to a given context. The cost of adaptivity is however a high runtime overhead stemming from executing compositions of behavior-modifying code. It has been shown that the overhead can be reduced by optimizing dispatch plans at runtime when contexts do not change, but no method exists to reduce the overhead in cases with high context variability. This paper presents a novel approach to implement polymorphic role dispatch, taking advantage of run-time information to effectively guard abstractions and enable reuse even in the presence of variable contexts. The concept of polymorphic inline caches is extended to role invocations. We evaluate the implementation with a benchmark for role-oriented programming languages achieving a geometric mean speedup of 4.0× (3.8× up to 4.5×) with static contexts, and close to no overhead in the case of varying contexts over the current implementation of contextual roles in Object Team

Decentrally Coordinated Execution of Adaptations in Distributed Self-Adaptive Software Systems

Software systems in domains like Smart Cities, the Internet of Things or autonomous cars are coined by a high degree of distribution across several independent computing devices and the requirement to be able to adjust themselves to varying situations in their operational environment. Self-adaptive software systems are a natural choice to implement such context-dependent software systems. A multitude of approaches already implement self-adaptive systems and some consider even distribution aspects.Yet, none of the existing solutions supports the coordination of adaptation operations spanning multiple independent nodes, which is necessary to ensure a consistent adaptation even in presence of network errors or node failures. In this paper, we tackle this challenge to execute adaptations in distributed self-adaptive software systems in a coordinated manner. We present a protocol that enables the self-adaptive software system to execute correlated adaptations on multiple nodes in a transactional manner ensuring an atomic and consistent transition of the distributed system from its source to the desired target configuration. The protocol is validated to be free of deadlocks for any given adaptation at any point in time using a model-checking approach. The performance of our approach is investigated in experiments that emulate the protocol's execution on real devices for different sizes of distributed applications and adaptation scenarios

Role-based Adaptation of Business Reference Models to Application Models: An Enterprise Modeling Methodology for Software Construction

Large software systems are in need of a construction plan to determine and define every concept and element used in order to not end up in complex, unusable, and cost-intensive systems. Different modeling languages, like UML, support the development of these construction plans and visualize them for the system’s stakeholders. Reference models are a specific kind of construction plan, used as templates for information systems and already capture business domain knowledge for reuse and tailoring. By adaptation, reference models are tailored to enterprise-specific application models, which can be used for software construction and maintenance. However, current adaptation methods suffer from the limitations of pure object-oriented development (e.g., identity issues, large inheritance trees, and inflexibility). In this thesis, the usage of roles as the sole adaptation mechanism is proposed to solve these challenges. With the help of conceptual roles, it is possible to create rich model variations and adaptations from existing (industry standard) reference models, and it is simpler to react to model evolution and changing business logic. Adaptations can be specified with more precision by maintaining or even increasing the model’s expressiveness. As a consequence, the role-enriched final application model can be used to describe software systems in more detail, with different perspectives, and, if available, can be implemented with a role supporting programming language. However, even without this step, the application model itself will provide valuable insights into the overall construction plan of a software system by the combination of structure and behavior and a clear separation of relatively stable domain knowledge from its use case specific adaptation

Run-time Adaptation of Role-based Software Systems

Self-adaptive software systems possess the ability to modify their own structure or behavior in response to changes in their operational environment. Access to sensor data providing information on the monitored environment is a necessary prerequisite in such software systems. In the future, self-adaptive software systems will be increasingly distributed and interconnected to perform their assigned tasks, e.g., within smart environments or as part of autonomous systems. Adaptations of the software systems\\\' structure or behavior will therefore have to be performed consistently on multiple remote subsystems. Current approaches, however, do not completely support the run-time adaptation of distributed and interconnected software systems. Supported adaptations are local to a specific device and do not require further coordination or the execution of such adaptations is controlled by a centralized management system. Approaches that support the decentralized adaptation process, help to determine a stable state, e.g., defined by quiescence, of one adaptable entity without central knowledge ahead of the actual adaptation process. The execution of complex adaptation scenarios comprising several adaptations on multiple computational devices is currently not supported. Consequently, inherent properties of a distributed system such as intermittent connectivity or local adaptation failures pose further challenges on the execution of adaptations affecting system parts deployed to multiple devices. Adaptation operations in the current research landscape cover different types of changes that can be performed upon a self-adaptive software system. Simple adaptations allow the modification of bindings between components or services as well as the removal or creation and integration of such components or services into the system. Semantically more expressive operations allow for the relocation of behavioral parts of the system. In this thesis, a coordination protocol is presented that supports the decentralized execution of multiple, possibly dependent adaptation operations and ensures a consistent transition of the software system from its source to a desired target configuration. An adaptation operation describes exactly one behavioral modification of the system, e.g., the addition or replacement of a component representing a behavioral element of the system\\\'s configuration. We rely on the notion of Roles as an abstraction to define the software system\\\'s static and dynamic, i.e., context-dependent, parts. Roles are an intuitive means to describe behavioral adaptations in distributed, context-dependent software systems due to their behavioral, relational and context-dependent nature. Adaptation operations therefore utilize the Role concept to describe the intended run-time modifications of the software system. The proposed protocol is designed to maintain a consistent transition of the software system from a given source to a target configuration in the presence of link failures between remote subsystems, i.e., messages used by the protocol to coordinate the adaptation process are lost on transmission, and in case of local failures during the adaptation process. The evaluation of our approach comprises two aspects: In one step, the correctness of the coordination protocol is formally validated using the model checking tool PRISM. The protocol is shown to be deadlock-free even in the presence of coordination message losses and local adaptation failures. In a second step, the approach is evaluated with the help of an emulated execution environment in which the degree of coordination message losses and adaptation failures is varied. The adaptation duration and the partial unavailability of the system, i.e., the time roles are passive due to ongoing adaptations, is measured as well as the success rate of the adaptation process for different rates of message losses and adaptation failures