Run-time Variability with Roles

Adaptability is an intrinsic property of software systems that require adaptation to cope with dynamically changing environments. Achieving adaptability is challenging. Variability is a key solution as it enables a software system to change its behavior which corresponds to a specific need. The abstraction of variability is to manage variants, which are dynamic parts to be composed to the base system. Run-time variability realizes these variant compositions dynamically at run time to enable adaptation. Adaptation, relying on variants specified at build time, is called anticipated adaptation, which allows the system behavior to change with respect to a set of predefined execution environments. This implies the inability to solve practical problems in which the execution environment is not completely fixed and often unknown until run time. Enabling unanticipated adaptation, which allows variants to be dynamically added at run time, alleviates this inability, but it holds several implications yielding system instability such as inconsistency and run-time failures. Adaptation should be performed only when a system reaches a consistent state to avoid inconsistency. Inconsistency is an effect of adaptation happening when the system changes the state and behavior while a series of methods is still invoking. A software bug is another source of system instability. It often appears in a variant composition and is brought to the system during adaptation. The problem is even more critical for unanticipated adaptation as the system has no prior knowledge of the new variants. This dissertation aims to achieve anticipated and unanticipated adaptation. In achieving adaptation, the issues of inconsistency and software failures, which may happen as a consequence of run-time adaptation, are evidently addressed as well. Roles encapsulate dynamic behavior used to adapt players representing the base system, which is the rationale to select roles as the software system's variants. Based on the role concept, this dissertation presents three mechanisms to comprehensively address adaptation. First, a dynamic instance binding mechanism is proposed to loosely bind players and roles. Dynamic binding of roles enables anticipated and unanticipated adaptation. Second, an object-level tranquility mechanism is proposed to avoid inconsistency by allowing a player object to adapt only when its consistent state is reached. Last, a rollback recovery mechanism is proposed as a proactive mechanism to embrace and handle failures resulting from a defective composition of variants. A checkpoint of a system configuration is created before adaptation. If a specialized bug sensor detects a failure, the system rolls back to the most recent checkpoint. These mechanisms are integrated into a role-based runtime, called LyRT. LyRT was validated with three case studies to demonstrate the practical feasibility. This validation showed that LyRT is more advanced than the existing variability approaches with respect to adaptation due to its consistency control and failure handling. Besides, several benchmarks were set up to quantify the overhead of LyRT concerning the execution time of adaptation. The results revealed that the overhead introduced to achieve anticipated and unanticipated adaptation to be small enough for practical use in adaptive software systems. Thus, LyRT is suitable for adaptive software systems that frequently require the adaptation of large sets of objects

Composition of object-oriented software design models

In practice, object-oriented design models have been less useful throughout the lifetime of software systems than they should be Design models are often large and monolithic, and the structure of designs is generally quite different from that of requirements. As a result, developers tend to discard the design, especially as the system evolves, since it is too difficult to keep its relationship to requirements and code accurate, especially when both are changing. This thesis identifies a number of key, well-defined problems with current object-oriented design methods and proposes new techniques to solve them. The new techniques present a different approach to designing systems, based on flexible decomposition and composition. The existing decomposition mechanisms of object-oriented designs (based on class, object, interface and method) are extended to include decomposing designs in a manner directly aligning design with requirements specifications. Composition mechanisms for designs are extended to support the additional decomposition mechanisms. The approach closely aligns designs with both requirements specifications and with code. It is illustrated how this approach permits the benefits of designs to be maintained throughout a system’ s lifetime

Subject Composition by Roles

Subjects model different perspectives on a problem domain by collections of related class hierarchies. Subjects can be seen as the result of separate and possibly independent development processes for partial models. The subjects can be efficiently composed by a technique that builds on the notion of roles. The composition allows already combined subjects to be further combined or to be dissolved and combined anew. 1 Introduction In conceptual programming we model concepts and phenomena by classes and objects, but extended with additional abstraction mechanisms [5]. The objective is to support concept formation explicitly and efficiently by extending the powerful but limited existing abstraction facilities in object-oriented programming and modeling [1] and [11]. The subjects [3] model different perspectives on a problem domain by collections of related class hierarchies. Subjects can be seen as the result of separate and possibly independent development processes for partial models. ..