To operate in dynamic and potentially unknown scenarios a mobile client discovers the local services that match its requirements, and interacts with these to obtain the application functionality. However, mobile environments are populated by heterogeneous mobile service platforms; these range from discovery protocols including SLP, UPnP and Jini to different styles of service interaction paradigms e.g. Remote Procedure Call, Publish-Subscribe and agent based solutions. Therefore given this type of heterogeneity, utilizing single discovery and interaction systems is not optimal as the client will only be able to use the services available to that particular platform. Hence, in this paper we present an adaptive middleware solution to this problem. ReMMoC is a Web-Services based reflective middleware that allows mobile clients to be developed independently of both discovery and interaction mechanisms. We describe the architecture, which dynamically reconfigures to match the current service environment. Finally, we investigate the incurred performance overhead such dynamic behaviour brings to the discovery and interaction process. I.

Abstract. Next-generation Grid applications will be highly heterogeneous in nature, will run on many types of computer and device, will operate within and across many heterogeneous network types, and must be explicitly configurable and runtime reconfigurable. We refer to this future Grid environment as the “divergent Grid”. In this paper, we propose a “deep middleware ” approach to meeting key requirements of the divergent Grid. Deep middleware reaches down into the network to provide highly flexible network support that underpins a rich, extensible and reconfigurable set of application-level “interaction paradigms ” (such as publish-subscribe, multicast, tuple spaces etc.). In our Gridkit middleware platform, these facilities are encapsulated in two key component frameworks: the interaction framework and the overlay framework, which are the subject of this paper. The paper also evaluates the two frameworks in terms of their configurability (e.g. ability to be profiled for different device types) and reconfigurability (e.g. to self-optimise as the environment changes). 1

This paper describes Infopipes -- a new high-level abstraction for information flow applications -- and a middleware framework that supports them. Infopipes handle the complexities associated with control flow and multi-threading, relieving the programmer of these tasks. Starting from a high-level description of an information flow pipeline, the framework determines which parts of a pipeline require separate threads or coroutines, and handles synchronization transparently to the application programmer. The framework also gives the programmer the freedom to write or reuse components in a passive style, even though the configuration will actually require the use of a thread or coroutine. Conversely, it is possible to write a component using a thread and know that the thread will be eliminated if it is not needed in a pipeline. This allows the most appropriate programming model to be chosen for a given task, and existing code to be reused irrespective of its activity model

Middleware solutions for sensor networks have so far mainly focused on communication abstractions, ad-hoc message routing protocols, and power conservation techniques. We argue that customisation and dynamic reconfiguration of sensor network middleware are additional important dimensions to consider. This paper describes a sensor middleware that can be customised to suit different sensor application types, and provides a reflective approach for co-ordinated network-wide dynamic reconfiguration of sensor behaviour. To evaluate our approach we illustrate customisation and dynamic reconfiguration of the Gridkit sensor middleware in a flood-monitoring scenario.

This dissertation examines how the architectural layering of middleware constrains the design of a middleware security architecture, and analyses the complications that arise from that. First, we define a precise notion of middleware that includes its architecture and features. Our definition is based on the Common Object Request Broker Architecture (CORBA), which is used throughout this dissertation both as a reference technology and as a basis for a proof of concept implementation. In several steps, we construct a security model that fits to the described middleware architecture. The model facilitates conceptual reasoning about security. The results of our analysis indicate that the cryptographic identities available on the lower layers of the security model are only of limited use for expressing fine-grained security policies, because they are separated from the application layer entities by the middleware layer. To express individual application layer entities in access policies, additional more fine-grained descriptors are required. To solve this problem for the target side (i.e., the receiving side of an invocation), we propose an improved middleware security model that supports individual access policies on a per-target basis. The model is based on so-called "resource descriptors", which are used in addition to cryptographic identities to describe application layer entities in access policies. To be useful, descriptors need to fulfil a number of properties, such as local uniqueness and persistency. Next, we examine the information available at the middleware layer for its usefulness as resource descriptors, in particular the interface name and the instance information inside the object reference. Unfortunately neither fulfils all required properties. However, it ...

Dynamic reconfiguration is the process of making changes to software at run-time. The motivation for this is typically to facilitate adaptive systems which change their behavior in response to changes in their operating environment or to allow systems with a requirement for continuous service to evolve uninterrupted. To enable development of reconfigurable applications, we have developed OpenRec, a framework which comprises a reflective component model plus an open and extensible reconfiguration management infrastructure. Recently we have extended OpenRec to verify whether an intended (re)configuration would result in an application’s structural constraints being satisfied. Consequently OpenRec can automatically veto proposed changes that would violate configuration constraints. This functionality has been realized by integrating OpenRec with the AL-LOY Analyzer tool via a service-oriented architecture. AL-LOY is a formal modelling notation which can be used to specify systems and associated constraints. In this paper, we present an overview of the OpenRec framework. In addition, we describe the application of ALLOY to modelling reconfigurable component based systems and highlight some interesting experiences with integrating OpenRec and the ALLOY Analyzer. 1.

In this paper we propose an approach to support the design and operation of dynamically adaptive systems. We apply the concept of variability modeling from software product lines to define how systems adapt at runtime to changes in their environment. Our approach models two dynamic variability dimensions; environment variability, which defines the conditions under which a system must adapt, and structural variability which defines the resulting architectural configurations. The variability dimensions identified are modeled using domain-specific languages (DSMLs) tailored to adaptive middleware technologies that provide support for runtime variability according to reconfiguration policies. We describe our experience with applying this approach through a case study; the design of a flood warning system.

Abstract. Grid applications are fragile when changes to service implementations, non-functional properties or communication protocols take place. Moreover, developing Grid applications with current toolkits result in a tangling of toolkit-specific and application-specific code that makes maintenance and evolution difficult. This paper proposes solving these problems by using reflection to open up Grid toolkits, and to allow Grid applications to be developed as if they were centralised applications. This would allow changes to be handled dependably, and a clean separation between toolkit-specific and application-specific code. 1

Today’s software component technology does not support safe deployment of real-time and multimedia applications. We propose platform managed deployment configuration and dynamic adaptation to enable component middleware to exploit adaptive components. An example of a remote video binding shows how alternate configurations are compared using error prediction functions to select the best for the current deployment environment.

In this paper we propose an approach to support dynamic or runtime variability in systems that must adapt dynamically to changing runtime context. The approach is founded on reflective component-based technologies to support the dynamic variability at the architectural level. Adaptive behaviour is encoded in reconfiguration policies that are consulted at run-time when changes in the underlying environment are detected. Specifically, the reconfiguration policies dictate the component-based architecture to be used in actively changing contexts. However, the increasing number of variants and their interdependency relationships add to the complexity of variability management. Therefore, the paper also proposes a notation and associated models to address the management of dynamic variability. We describe our experience with applying this approach through a case study; the support and management of dynamic variability for service discovery protocols.