Introduction

The next generation of the Web will result from the transformation of today’s Web of computers into a pervasive Web of interactive computers and physical devices. In order to realize the potential of this new Web, the problem of developing software that coordinates large numbers of nodes must be addressed. Experience in developing software, especially for interactive networked applications, shows there is no single solution; rather, a grab bag of novel technologies has to be developed and packaged to provide the required flexibility and functionality to address software problems like maintainability and requirements evolution. Adaptive middleware is a central technology for the future pervasive Web.

Middleware provides an abstract interface that gives an application developer a uniform view of low-level operating systems and networks. In the traditional view, middleware is a means for gluing together application components that comply with certain interoperability requirements. Such glue relies only on the interfaces of components, not their representation, to support evolving software requirements.

As we move from traditional distributed systems to mobile systems, however, the glue analogy becomes increasingly misleading. Because in a mobile system many components are not static, it is therefore more reasonable for system architects to view components as autonomous concurrent objects, or actors [1], reacting to events communicated in messages, as if they were on a stage interacting with props, other actors, even the audience. Actors’ autonomy allows them to migrate from one node to another on a network. The nodes on which they reside may themselves move, in effect causing them to migrate as a group. Rather than trying to glue actors together, it makes more sense to think in terms of enabling dynamic interaction patterns.

One consequence of mobility is that the environment in which an actor performs may also be changing dynamically. For example, different fault tolerance and security properties may be enforced in different execution environments. As a consequence, middleware must be sufficiently flexible to enable adaptation to changes in the underlying operating systems and networks, as well as to changes in application requirements.

A decade ago, I advocated thinking in terms of being able to customize meta-actors, implementing the services provided by a middleware system, including fault tolerance, security, synchronization, and other types of interaction protocols [3]. One result of this meta-actor model is the ability of the application developer to express dynamic coordination policies as synchronization constraints between individual or groups of actors and directly execute the constraints by customizing the meta-actors during execution [5]. This notion is especially useful in today’s increasingly dynamic Web-based application environments.

These two aspects of new-generation middleware—dynamic customizability and high-level abstractions—illustrate fundamental themes for a new generation of middleware likely to be available to programmers within this decade. Dynamic customizability provides the flexibility required to adapt the middleware for resource-aware mobile applications [4]. High-level abstractions simplify the problem of expressing complex interaction patterns by enabling application developers to specify interactions [2]. By dynamically composing protocols in the middleware, application developers can thus address the problem of dynamic execution environments.

The six articles in this special section represent leading-edge and novel directions in research on next-generation middleware technologies. A main theme is the use of computational reflection, that is, an application’s ability to access some part of the state of the underlying system and dynamically modify that state, thus changing its own execution semantics. Another theme is support for high-level policy management. These themes are illustrated by a range of applications, from computer-supported cooperative work, to embedded systems, to multimedia, to open distributed information systems.

Fabio Kon et al. provide a definition of the reflective middleware model, discussing the design of related middleware systems; two innovative examples—DynamicTAO and Open ORB—are explored in some detail. DynamicTAO, developed by Douglas Schmidt’s group at Washington University, provides a special interface for inspecting and modifying the middleware; such modifications may involve changing the state of a module or adding or deleting modules. Open ORB, developed by Gordon Blair’s group at Lancaster University, organizes the underlying meta-level system through an expressive programming language semantics, separating a system’s structure from its behavior.

Anand Tripathi presents a framework for middleware architectures allowing high-level development of distributed applications, describing the basic types of services middleware should provide to a distributed application: event notification; context-aware customization of middleware protocols; device mobility and resource discovery; agent mobility; and security. The first two support reflection; the others illustrate the evolving requirements for next-generation middleware.

Douglas Schmidt addresses the critical requirements of distributed real-time and embedded systems, proposing that middleware services be organized in a hierarchy that separates the infrastructure from common services and domain-specific services. He also catalogs recent progress in such systems, including those for financial trading, distributed process control, even avionics mission computing, while outlining future needs.

Reflection is a powerful tool, but its undisciplined use can result in a system’s dangerous and unpredictable breakdown, especially when the modifications result in incompatible changes to the parts of an application. Nalini Venkatasubramanian provides a model for the safe composition of middleware services. In order to make a system more trustworthy, she introduces the notion of core services; an application may customize the middleware available to it by composing different core services to create protocols. One motivation for wanting to enhance a system’s trustworthiness is to simplify reasoning about systems using reflection; the behavior of each core service can be formalized separately and its properties composed with those of other core services, as well as with the application.

Valérie Issarny et al. show how middleware architectures may be modeled so they represent the various relationships between different software components. Such models provide tools for systematically developing middleware architectures. System architects may provide high-level specifications in a temporal logic so their systems ultimately yield architectures satisfying these constraints. This work, which promises to automate composition middleware architectures, is being extended in new directions to account for quality metrics, including reliability.

Finally, Jean Bacon and Ken Moody describe a middleware architecture for enforcing security policies for large-scale, widely distributed systems. The concept of event-based middleware and the use of high-level policies plays a central role. The policy expression and management for role-based access control, discussed in some detail, abstract over the complexity of an implementation, considerably simplifying the application developer’s enforcement task.

These middleware technologies will mature over the next decade to give the new Web the ability to coordinate physical devices and execute distributed computation along with the relatively straightforward information access we are used to today. The result will be the seamless integration of the physical world and the computational world, where every physical object is computationally active and networked. Moreover, physical devices will be more useful because their software will be able to adapt their execution environments to improve their utility while maximizing their energy efficiency.

Back to Top

Back to Top