Geoff Coulson

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.

The RUNES middleware: a reconfigurable component-based approach to networked embedded systems

In this paper the RUNES approach to the development of software for networked embedded systems is described. There is a need for a program platform with abstractions that are able to span the full range of heterogeneous embedded systems, and which also offers consistent mechanisms with which to configure, deploy, and dynamically reconfigure networked embedded systems software. This paper discusses the need of such a programming platform. The work is being carried out in the context of the RUNES project (reconfigurable, ubiquitous, and networked embedded systems) which has the general goal of developing an architecture for networked embedded systems that encompasses dedicated radio layers, networks

GRIDKIT: Pluggable Overlay Networks for Grid Computing

A ‘second generation’ approach to the provision of Grid middleware is now emerging which is built on service-oriented architecture and web services standards and technologies. However, advanced Grid applications have significant demands that are not addressed by present-day web services platforms. As one prime example, current platforms do not support the rich diversity of communication ‘interaction types’ that are demanded by advanced applications (e.g. publish-subscribe, media streaming, peer-to-peer interaction). In the paper we describe the Gridkit middleware which augments the basic service-oriented architecture to address this particular deficiency. We particularly focus on the communications infrastructure support required to support multiple interaction types in a unified, principled and extensible manner—which we present in terms of the novel concept of pluggable overlay networks.

Reflection, self-awareness and self-healing in OpenORB

There is a growing interest in the area of self-healing systems. Self-healing does however impose considerable demands on system infrastructures---especially in terms of openness and support for reconfigurability. This paper proposes that the self-awareness inherent in reflective technologies lends itself well to the construction of self-healing systems. In particular, the paper examines the support provided by the Open ORB reflective middleware technology for the construction of this increasingly important class of system.

Experiments with Reflective Middleware

Middleware platforms have emerged as an effective answer to the requirements of open distributed processing. However, in our opinion, a new engineering approach based on configurability and openess of platform implementations is essential to meet the needs of applications areas such as multimedia, groupware and mobile computing. This paper outlines our architecture for configurable and open middleware platforms, along with a first prototype. The architecture is based on the concept of reflection, the ability for a program to access, reason about and alter its own implementation in a principled way, according to a well-defined Meta-Object Protocol (MOP) [1].

Supporting adaptive multimedia applications through open bindings

In order to support multimedia applications in mobile environments, it will be necessary for applications to be aware of the underlying network conditions and also to be able to adapt their behaviour and that of the underlying platform. This paper focuses on the role of middleware in supporting such adaptation. In particular, we investigate the role of open implementation and reflection in the design of middleware platforms such as CORBA. The paper initially extends CORBA with the concept of explicit binding, where path of communication between objects is represented as first class objects. We then introduce the concept of open bindings which support inspection and adaptation of the path of communications. An implementation of open bindings is described, based on the Ensemble protocol suite from Cornell University.

Reconfigurable Component-based Middleware for Networked Embedded Systems

Next generation embedded systems will be composed of large numbers of heterogeneous devices. These will typically be resource-constrained (such as sensor motes), will use different operating systems, and will be connected through different types of network interfaces. Additionally, they may be mobile and/or form ad-hoc networks with their peers, and will need to be adaptive to changing conditions based on context-awareness. Our focus in this paper is on the provision of a middleware framework for such system environments. Our approach is based on a small and efficient ‘middleware kernel’ which supports highly modularised and customisable component-based middleware services that can be tailored for specific embedded environments, and are runtime reconfigurable to support adaptivity. These services are primarily communications-related but also address a range of other concerns including service discovery and logical mobility. In the paper we provide an overview of our approach, focusing in detail on both the middleware kernel and the services. We also discuss an application scenario in which we are currently applying and evaluating our middleware approach.

Flexible experimentation in wireless sensor networks

Virtual testbeds model them by seamlessly integrating physical, simulated, and emulated sensor nodes and radios in real time.

The Design of a Resource-Aware Reflective Middleware Architecture

Middleware has emerged as an important architectural component in supporting distributed applications. With the expanding role of middleware, however, a number of problems are emerging. Most significantly, it is becoming difficult for a single solution to meet the requirements of a range of application domains. Hence, the paper argues that the next generation of middleware platforms should be both configurable and re-configurable. Furthermore, it is claimed that reflection offers a principled means of achieving these goals. The paper then presents an architecture for reflective middleware based on a multi-model approach. The main emphasis of the paper is on resource management within this architecture (accessible through one of the meta-models). Through a number of worked examples, we demonstrate that the approach can support introspection, and fine- and coarse- grained adaptation of the resource management framework. We also illustrate how we can achieve multi-faceted adaptation, spanning multiple meta-models.

Managing complexity: middleware explained

Traditionally, most definitions seeking to characterize middleware suggest that it is the software that facilitates remote database access and systems transactions. More recently, the term has come to be associated-somewhat limitingly-with distributed platforms such as the Open Software Foundations Distributed Computing Environment (DCE) and the Object Management Groups Common Object Request Broker Architecture (CORBA). And some have loosely applied it to systems as diverse as workflow support environments and even to the Web itself. We believe the essential role of middleware is to manage the complexity and heterogeneity of distributed infrastructures and thereby provide a simpler programming environment for distributed-application developers. It is therefore most useful to define middleware as any software layer that is placed above the distributed systems infrastructure-the network OS and APIs-and below the application layer.