Gordon S. Blair

Models@ run.time

Runtime adaptation mechanisms that leverage software models extend the applicability of model-driven engineering techniques to the runtime environment. Contemporary mission-critical software systems are often expected to safely adapt to changes in their execution environment. Given the critical roles these systems play, it is often inconvenient to take them offline to adapt their functionality. Consequently, these systems are required, when feasible, to adapt their behavior at runtime with little or no human intervention. A promising approach to managing complexity in runtime environments is to develop adaptation mechanisms that leverage software models, referred to as models@run. time. Work on models@run.time seeks to extend the applicability of models produced in model-driven engineering (MDE) approaches to the runtime environment. Models@run. time is a causally connected self-representation of the associated system that emphasizes the structure, behavior, or goals of the system from a problem space perspective.

The case for reflective middleware

Its flexible and reconfigurable yet simple for programmers to use, notably for building dynamic distributed applications operating on the Net.

An architecture for next generation middleware

This paper proposes an approach to the design of configurable and open middleware platforms based on the concept of reflection. More specifically, the paper introduces a language-independent reflective architecture featuring a per-object meta-space, the use of meta-models to structure meta-space, and a consistent use of object graphs for composite components. This is complemented by a component framework supporting the construction of meta-spaces. The paper also reports on experiences of implementing the architecture (with emphasis on experiments with open bindings).

A generic component model for building systems software

Component-based software structuring principles are now commonplace at the application level; but componentization is far less established when it comes to building low-level systems software. Although there have been pioneering efforts in applying componentization to systems-building, these efforts have tended to target specific application domains (e.g., embedded systems, operating systems, communications systems, programmable networking environments, or middleware platforms). They also tend to be targeted at specific deployment environments (e.g., standard personal computer (PC) environments, network processors, or microcontrollers). The disadvantage of this narrow targeting is that it fails to maximize the genericity and abstraction potential of the component approach. In this article, we argue for the benefits and feasibility of a generic yet tailorable approach to component-based systems-building that offers a uniform programming model that is applicable in a wide range of systems-oriented target domains and deployment environments. The component model, called OpenCom, is supported by a reflective runtime architecture that is itself built from components. After describing OpenCom and evaluating its performance and overhead characteristics, we present and evaluate two case studies of systems we have built using OpenCom technology, thus illustrating its benefits and its general applicability.

The design of a configurable and reconfigurable middleware platform

Summary. It is now well established that middleware platforms must accommodate an increasingly diverse range of requirements arising from the needs of both applications and underlying systems. Moreover, it is clear that to achieve this accommodation, platforms must be capable of both deployment-time configurability and run-time reconfigurability. This paper describes a middleware platform that addresses these requirements. The platform is built using a well-founded lightweight component model, uses reflective techniques to facilitate (re)configuration, and employs the notion of component frameworks to manage and constrain the scope of reconfiguration operations. Importantly, the platform also aims to achieve high performance and a level of standards conformance (e.g., with CORBA and COM). We demonstrate that, despite its high degree of configurability, the platform performs on a par with standard commercial CORBA ORBs.

ReMMoC: A Reflective Middleware to Support Mobile Client Interoperability

Mobile client applications must discover and interoperate with application services available to them at their present location. However, these services will be developed upon a range of middleware types (e.g. RMI and publish-subscribe) and advertised using different service discovery protocols (e.g. UPnP and SLP) unknown to the application developer. Therefore, a middleware platform supporting mobile client applications should ideally adapt its behaviour to interoperate with any type of discovered service. Furthermore, these applications should be developed independently from particular middleware implementations, as the interaction type is unknown until run-time. This paper presents ReMMoC, a reflective middleware platform that dynamically adapts both its binding and discovery protocol to allow interoperation with heterogeneous services. Furthermore, we present the ReMMoC programming model, which is based upon the Web Services concept of abstract services. We evaluate this work in terms of supporting mobile application development and the memory footprint cost of utilising reflection to create a mobile middleware platform.

L 2 imbo: a distributed systems platform for mobile computing

Mobile computing environments increasingly consist of a range of supporting technologies offering a diverse set of capabilities to applications and end-systems. Such environments are characterised by sudden and dramatic changes in the quality-of-service (QoS) available to applications and users. Recent work has shown that distributed systems platforms can assist applications to take advantage of these changes in QoS and, more specifically, facilitate applications to adapt to their environment. However, the current state-of-the-art in these platforms reflects their fixed network origins through their choice of synchronous connection-oriented communications paradigms. In this paper we argue that these paradigms are not well suited to operation in the emerging mobile environments. Furthermore, we offer an alternative programming paradigm based on tuple spaces which, we believe, offers a number of benefits within a mobile context. The paper presents the design, implementation and evaluation of a new platform based on this paradigm.

CSCW and distributed systems: the problem of control

The user-centred philosophy of CSCW challenges the established principles of many existing technologies but the development of CSCW is dependent on the facilities provided by these technologies. It is therefore important to examine and understand this inter-relationship. This paper focuses on distributed computing, a technology central to the development of CSCW systems. The nature of both CSCW and distribution are compared by using a common framework. In this discussion, control emerges as the major problem in supporting CSCW systems. It is argued that existing approaches to control in distributed systems are inadequate given the rich patterns of cooperation found in CSCW. A number of recommendations are made for improving distributed support for CSCW.

An Aspect-Oriented and Model-Driven Approach for Managing Dynamic Variability

Constructing and executing distributed systems that can adapt to their operating context in order to sustain provided services and the service qualities are complex tasks. Managing adaptation of multiple, interacting services is particularly difficult since these services tend to be distributed across the system, interdependent and sometimes tangled with other services. Furthermore, the exponential growth of the number of potential system configurations derived from the variabilities of each service need to be handled. Current practices of writing low-level reconfiguration scripts as part of the system code to handle run time adaptation are both error prone and time consuming and make adaptive systems difficult to validate and evolve. In this paper, we propose to combine model driven and aspect oriented techniques to better cope with the complexities of adaptive systems construction and execution, and to handle the problem of exponential growth of the number of possible configurations. Combining these techniques allows us to use high level domain abstractions, simplify the representation of variants and limit the problem pertaining to the combinatorial explosion of possible configurations. In our approach we also use models at runtime to generate the adaptation logic by comparing the current configuration of the system to a composed model representing the configuration we want to reach.

Exploiting reflection in mobile computing middleware

The increasing popularity of portable devices and recent advances in wireless networking technologies facilitate the engineering of new classes of applications, which present challenging problems to designers. Mobile devices face temporary and unannounced loss of network connectivity when they are moved, they are likely to have scarce resources, and they are required to react to frequent changes in the environment. To accommodate these new requirements imposed by mobility, middleware platforms for mobile computing must be capable of both deployment-time configurability and run-time reconfigurability. We illustrate how reflective techniques can be exploited by middleware designers to address these requirements. We discuss two complementary approaches: CARISMA, where reflection is used to support dynamic adaptation of middleware behaviour to changes in context, and ReMMoC, which uses reflection to accommodate heterogeneity requirements imposed by both applications and underlying device platforms.