R. Balter, L. Bellissard, F. Boyer, M. Riveill and J.Y. Vion-Dury
INRIA, France

Middleware platforms are today solutions to the problem of designing and implementing distributed applications. They provide facilities for heterogeneous software components to communicate remotely, according to various interaction model, for example client server communication or asynchronous message passing. However, middleware platforms, like message busses or object request brokers, hardly provide tools for the design, configuration and installation of complex software architectures.

This paper presents the Olan environment which primary objective is the description of complex architecture, their configuration according to application requirements and the deployment on heterogeneous distributed environments. The Olan environment is based on an Architecture Description Language where the application is considered as a hierarchy of interconnected software components. A set of software engineering tools assist the application designer in his task of wrapping existing software modules into components which are in turned interconnected through various communication models and finally assembled together according to specific configuration criteria. At run time, a set of system services in charge of automating the installation of the components and their communication channels on a given middleware platform, thus facilitating the overall deployment process of the global application.

Appears: Session 6 (Components), Thursday PM

J. Baumann, F. Hohl, K. Rothermel, M. Schwehm and M. Strasser
University of Stuttgart, Germany

Mole is one of the first Java-based mobile agent systems. It runs on an unmodified Java virtual machine on PCs under Windows 95/NT and on workstations under several UNIX dialects. Earlier versions of Mole have provided a basic infrastructure for communication and migration of mobile agents. Version 3.0 of Mole has been strongly revised and several requests and proposals from users of the earlier versions of Mole were integrated into the new release. In particular Mole supports communication between agent groups and the concept of sessions. The infrastructure of Mole includes a resource manager, a directory service and a global naming scheme for agents. In order to support the design of agents, a graphical agent monitor allows to visualize the system behavior as a whole or of a single agent in particular. Mole further provides a thread management unit to overcome some shortcomings of the Java virtual machine. Mole provides a simple means for installation and configuration of the system. This paper describes the architecture and infrastructure of Mole 3.0.

Appears: Session 8 (Mobile Objects), Friday AM

G. S. Blair, G. Coulson, P. Robin and M. Papathomas
Lancaster University, UK

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).

Appears: Session 5 (ORB Architecture), Thursday AM

P. Cao, J. Zhang and K. Beach
University of Wisconsin-Madison, USA

Dynamic documents constitute an increasing percentage of contents on the Web, and caching dynamic documents becomes an increasingly important issue that affects the scalability of the Web. In this paper, we propose the Active Cache scheme to support caching of dynamic contents at Web proxies. The scheme allows servers to supply cache applets to be attached with documents, and requires proxies to invoke cache applets upon cache hits to furnish the necessary processing without contacting the server. We describe the protocol, interface and security mechanisms of the Active Cache scheme, and illustrate its use via several examples. Through prototype implementation and performance measurements, we show that Active Cache is a feasible scheme that can result in significant network bandwidth savings at the expense of moderate CPU costs.

Appears: Session 9 (Web Services), Friday AM

Y. Chawathe and E. Brewer
University of California at Berkeley, USA

Over the past few years, we have seen the proliferation of Internet-based services ranging from search engines and map services to video-on-demand servers. All of these kinds of services need to be able to provide guarantees of availability and scalability to their users. With millions of users on the Internet today, these services must have the capacity to handle a large number of clients and remain available even in the face of extremely high load.

In this paper, we present a generic architecture for supporting such Internet applications. We provide a substrate for Scalable Network Services (SNS), on top of which application developers can design their services without worrying about the details of service management. We back our design with three real-world services: a web distillation proxy, a proxy-based web-browser for PDAs, and an MBone archive server.

Appears: Session 2 (Scalability), Wednesday AM

S. Crawley and K. Duddy
University of Queensland, Australia / Defence Science and Technology Organisation, Australia

CORBA presents a model of distributed computing in which distributed objects communicate using a high-level "information bus" called an Object Request Broker (ORB). In this paper we describe a problem with the current CORBA specification that makes ORB communication non-type-safe in certain situations. We describe a solution to the problem based on the use of unique identifiers and show how it can be implemented efficiently in both stand-alone and federated CORBA-based systems.

Appears: Session 7 (Type Safety and Security), Thursday PM

X. Defago, K. Mazouni and A. Schiper
Ecole Polytechnique Federale de Lausanne, Switzerland

The Swiss Exchange system (SWX system) was the first stock exchange system in service to be fully computerised. For high availability, the trading system is built as a replicated service based on Isis. For portability reasons, the SWX team has considered basing the next version of the trading system on CORBA. Despite the numerous advantages of a CORBA based solution, it was necessary not only to meet the functionality requirements of the system, but also to evaluate the performance of the chosen middleware.

This paper describes a model that simulates the communication behavior of the trading system on Iona's Orbix and OrbixTalk. We have evaluated this model in order to illustrate some of the performance limitations of this communication infrastructure. We have also studied the fault-tolerance of the system and found that a key aspect in such a system is the state transfer. We have extended our model to support different schemes for state transfer. Measurements have shown us the conditions under which a state transfer could be performed in the background, concurrently with the normal operations.

Appears: Session 3 (Availability and Integrity), Wednesday PM

D. Donaldson, M. Faupel, R. Hayton, A. Herbert, N. Howarth, A. Kramer, I. MacMillan, D. Otway and S. Waterhouse
APM Limited, UK

DIMMA - A Distributed Interactive Multi-Media Architecture - is an open distributed processing (ODP) platform that facilitates the production of distributed applications. It has particular support for those applications that have soft real-time constraints, and those that make use of multi-media.

DIMMA consists of a portable layer of distribution engineering (middleware), together with tools to interface applications to this engineering. The most popular commercial ODP platform is the Common Object Request Broker Architecture (CORBA) whose definition is managed by the Object Management Group (OMG). In recognition of this popularity, DIMMA supports a CORBA compliant API so that CORBA applications may be easily ported to or from the DIMMA platform.

This paper describes the example implementation of DIMMA. It gives an overview of the motivations behind the design of DIMMA and then highlights some key features of the DIMMA implementation. It concludes with a brief analysis of DIMMA's performance.

Appears: Session 4 (ORB Engineering), Thursday AM

B. Dumant, F. Horn, F. Tran and J. Stefani
France Telecom - CNET, France

This article describes a minimal and modular ORB framework from which highly flexible ORBs supporting the introduction of arbitrary binding mechanisms between interacting objects can be built. This framework essentially extends the Java notion of object reference to make it distributed. Jonathan is a Java implementation of this framework, featuring a CORBA 2.0 'personality' and several different binding factories. It could be easily extended with new binding factories and personalities (e.g. a RMI personality) or scaled down to fit particular needs.

Appears: Session 5 (ORB Architecture), Thursday AM

F. Eliassen and S. Mehus
University of Tromso, Norway

In middleware the notion of interface type is important for supporting type checking of interfaces during bind time. In this paper we present the design of a prototype generic flow type checker founded on a generic type model of stream flows and a general definition of stream flow compatibility ensuring the correctness of binding attempts of stream flow endpoints. The type checker determines compatibility by computing the set of common flow capabilities supported by the two endpoints. We illustrate the application of the type checker through its use as part of a flow binding facility, and as a basis for capability negotiations. The performance of the type checker is critical for its overall usefulness in interactive distributed multimedia applications. We therefore report on the results of some measurements to determine its performance.

Appears: Session 7 (Type Safety and Security), Thursday PM

A. Fox, I. Goldberg, S. D. Gribble, D. C. Lee, A. Polito and E. A. Brewer
University of California at Berkeley, USA

After an inauspicious debut, communication-enabled personal digital assistants (or PDA's) and handheld PC's are being "rediscovered" as mobile information access terminals. In response, developers have attempted to bring complex applications such as Web browsers to such devices. However, the limited resources available on thin client platforms make them unsuitable for hosting such applications. In this paper, we advocate moving application complexity from thin clients to an adaptive middleware proxy (AMWP), an infrastructural application server platform designed to support large populations and diverse applications. We describe one such application, Top Gun Wingman, a graphical, split Web browser for the Palm Pilot PDA that is currently in use by more than 11,000 users around the world. Our discussion focuses on the design philosophy, implementation, performance, and lessons learned from our experience with the Wingman client and the middleware proxy that supports it.

Appears: Session 9 (Web Services), Friday AM

A. Geppert and D. Tombros
University of Zurich, Switzerland

In event-driven workflow execution, events and event-condition-action rules are the fundamental metaphors for defining and enforcing workflow logic. Processing entities enact workflows by reacting to and generating new events. The foundation on events facilitates the integration of processing entities into coherent systems. In this paper, we present an event engine, called EVE, implementing event-driven execution of distributed workflows. Its functionality includes event registration, detection and management, as well as event notification to distributed, autonomous, reactive software components which represent workflow processing entities. We describe the distributed, multi-server, multi-client architecture of EVE and its use for workflow execution.

Appears: Session 10 (Events), Friday PM

S. Gibson, S. Gorain, D. Povey and P. Clutterbuck
Queensland University of Technology, Australia

Hector is a work-in-progress middleware solution for distributed objects. It is modelled on the Reference Model for Open Distributed Processing (RM-ODP) and is designed to sit above a mixture of communication protocols and other middleware environments (such as CORBA and DCE), hence creating a common platform for the interoperability of distributed objects. For a middleware solution to be used in a distributed and heterogeneous environment, in a less than perfect world, it is necessary to consider security implications, and incorporate solutions into the design. The SecArch project attempts to incorporate security into Hector without creating a proprietary solution and by utilising new and developing ideas as well as established and proven security concepts. The project also aims to keep Hector as open and flexible as possible.

Appears: Session 7 (Type Safety and Security), Thursday PM

D. Hagimont and D. Louvegnies
INRIA, France

We have implemented a service for the development of distributed cooperative applications on the Internet. This service provides the abstraction of a distributed shared object space. The objects managed by the applications are transparently shared between the client nodes, so that the application developer can program as in a centralized setting. It consists of a set of system classes and a proxy generator implemented in the Java environment. The service and the applications that use it are dynamically deployed to client nodes at run-time, thanks to Java mobile code. Our system support relies on object replication on the client nodes. Logically related objects are grouped in clusters, the cluster being the unit of sharing, replication and coherence. One of the main advantages of our proposal is that the object clustering policy is tightly coupled with the application code, thus ensuring locality, while keeping clustering transparent to the application programmer.

Appears: Session 8 (Mobile Objects), Friday AM

R. Hayton, M. Bursell, D. Donaldson and A. Herbert
APM Limited, UK

In this paper we discuss the engineering requirements for adding object mobility to the Java programming language, and give an overview of the design and implementation of our mobile object system. We show that it is helpful to cluster objects for mobility, and that if these clusters represent untrusted pieces of code (for example Agents) then they must be encapsulated both to control their access and to control access to them. We show that managing large numbers of mobile objects in an open environment is a difficult problem, but has its roots in the management of large distributed name spaces. We propose an architecture for re-locating moved objects that is both scaleable and tuneable.

The mobile object system we describe has been implemented, and is currently in use as part of an ESPRIT agent project. We are currently evolving the design and implementation to provide additional security and distribution facilities.

Appears: Session 8 (Mobile Objects), Friday AM

S. Lo and S. Pope
Olivetti & Oracle Research Laboratory, UK

This paper describes the implementation of a high performance Object Request Broker (ORB) - omniORB2. The discussion focuses on the experience in achieving high performance by exploiting the protocol and other characteristics of the CORBA 2.0 specification. The design is also highly adaptable to a variety of network transports. The results of running the ORB over TCP/IP, shared memory, Scalable Coherent Interface (SCI) and ATM Adaptation Layer 5 (AAL5) are presented. In both null calls and bulk data transfers, the performance of omniORB2 is significantly better than other commercial ORBs.

Appears: Session 4 (ORB Engineering), Thursday AM

X. Logean, F. Dietrich, H. Karamyan and S. Koppenhoefer
Ecole Polytechnique Federale de Lausanne, Switzerland

In this paper we present a method to perform run-time monitoring of distributed applications built on top of a distributed object oriented processing environment. For this, we instrument the code at the compilation time in order to send notifications to an Observer when relevant events occur in the system; the instrumentation is done in an automated manner, requiring a minimum of programmer interactions. One advantage of our run-time monitoring approach is that it does not hinder the development process already adopted. In our proposal, the choice of the information to select for observation is made simple by the definition of events which are generic and useful for all distributed applications; the user does not need to specify them. We apply our run-time monitoring method to a telecommunication service implemented on top of the distributed processing environment CORBA Orbix from IONA.

Appears: Session 10 (Events), Friday PM

P. Melliar-Smith, L. Moser, V. Kalogeraki and P. Narasimhan
University of California, Santa Barbara, USA

The Realize middleware manages the resources of CORBA distributed systems for soft real-time applications, and replicates CORBA objects to provide high availability and fault tolerance. By measuring the usage of the resources and by monitoring the behavior of the application, Realize allocates the objects to the processors and schedules the tasks in order to balance the load and to meet soft real-time deadlines. By using totally ordered multicast messages, Realize maintains the consistency of the replicas of the objects. The difficult issues of distribution, real-time scheduling, replication, consistency, and fault detection and recovery are handled by Realize and are hidden from the application programmer.

Appears: Session 3 (Availability and Integrity), Wednesday PM

G. Pierre and M. Makpangou
INRIA, France

Designing a distributed cache infrastructure to improve the Web performance for the users of a large-scale organization is a difficult task. To guide the decisions of system administrators, we propose Saperlipopette!, a tool that can be used to evaluate, a-priori, the quality of the service offered by each potential configuration of the distributed cache infrastructure. Saperlipopette! is based on trace-driven simulations. Our methodology is two-fold. First, we monitor the targeted organizations' Web related activity. Second, we replay the organization's access pattern while simulating the distributed Web support infrastructure.

This paper presents the information gathering as well as the design of the tool. We show that beyond a certain cache's size, the performance stays constant whereas the consistency continues to decrease. We also evaluated a number of distributed configurations, among which peer-to-peer Relais cooperation proved to be the best one.

Appears: Session 9 (Web Services), Friday AM

M. Radestock and S. Eisenbach
Imperial College, UK

Configuration and coordination are central issues in the design and implementation of middleware systems and are one of the reasons why building such systems is more difficult and complex than constructing stand-alone sequential programs. Through configuration, the structure of the system is established - which elements it contains, where they are located and how they are interconnected. Coordination is concerned with the interaction of the various components - when an interaction takes place, which parties are involved, what protocols are followed. Its purpose is to coordinate the behaviour of the various components in a way that meets the overall system specification. The open and adaptive nature of middleware systems makes the task of configuration and coordination particularly challenging. We propose a model than can operate in such an environment and enables the dynamic integration and coordination of components through observation of their behaviour.

Appears: Session 6 (Components), Thursday PM

R. van Renesse, Y. Minsky and M. Hayden
Cornell University, USA

Failure Detection is valuable for system management, replication, load balancing, and other distributed services. To date, Failure Detection Services scale badly in the number of members that are being monitored. This paper describes a new protocol based on gossiping that does scale well and provides timely detection. We analyze the protocol, and then extend it to discover and leverage the underlying network topology for much improved resource utilization. We then combine it with another protocol, based on broadcast, that is used to handle partition failures.

Appears: Session 2 (Scalability), Wednesday AM

A. Schill and C. Mittasch
TU Dresden, Germany

This paper describes a generic approach for building object-oriented workflow management systems in a distributed environment. It is based on business objects that encapsulate resources and basic business processes. They are accessible via CORBA interfaces. As opposed to more conventional work-flow approaches, control is fully decentralised, arbitrary workflow control structures can be modelled, and involved resources maintain autonomy. Moreover, the approach is not limited to one specific implementation of a workflow management system but can be applied on a more generic basis.

The concepts are validated by an implementation on top of Orbix and are illustrated by concrete examples of workflows. All distributed interactions are based on CORBA object communication. Selected CORBA services such as naming, events, persistence and externalisation are utilised, and experiences with their integration into our environment are reported, too.

Appears: Session 1 (Workflow), Wednesday AM

M. Spiteri and J. Bates
University of Cambridge, UK

This paper describes the architecture we designed and constructed to support the storage and retrieval of events. We define an event as an asynchronous occurrence containing parameterised details of an activity that has occurred within a distributed component. Our past experience has demonstrated how using events as the glue to build distributed active systems simplifies the construction of complex applications, and enables legacy stand-alone components to be rapidly integrated within a larger collaborative environment. Examples of such active systems are interactive multimedia applications, distributed debugging environments, co-operative working applications, agent architectures, and active. Our motivation for storing events is that events represent indexing points into application sessions. Our event repository architecture can capture and store events, as well as inject them back into distributed application components to simulate replay of sequences of activity, or for re-building lost state. The architecture co-exists and inter-operates with other event-based active systems, as well as with middleware event services like traders and brokers. Using a generic object-oriented model for events, the repository architecture provides powerful search and retrieval facilities, enabling extraction of behaviour patterns, searching for simple and composite occurrences, and replay of stored sequences. We illustrate how the repository can be a viable alternative to past system-specific solutions in areas like capture of collaboration and memory prosthesis, and visualisation of user mobility.

Appears: Session 10 (Events), Friday PM

M. van Steen, A. Tanenbaum, I. Kuz and H. Sips
Vrije University, The Netherlands

To alleviate the scalability problems in the Web, many researchers are concentrating on how to incorporate more advanced caching and replication techniques than those currently supported. Many solutions incorporate object-based techniques. In particular, Web resources are considered as distributed objects offering a well-defined interface.

We argue that most proposals ignore two important aspects. First, there is little discussion on what kind of coherence should be provided. Proposing specific caching or replication solutions makes sense only if we know what coherence model they should implement. Second, most proposals treat all Web resources alike. Such a one-size-fits-all approach will never work in a wide-area system.

We propose a solution in which Web resources are encapsulated in physically distributed shared objects. In our model, each object not only encapsulates state and operations, but also the policy by which its state is distributed, cached, replicated, migrated, etc. All implementation details are hidden from a client behind an object's interface.

Appears: Session 2 (Scalability), Wednesday AM

E. Totel, Lj. Beus-Dukic, J.-P. Blanquart, Y. Deswarte, D. Powell and A. Wellings
LAAS-CNRS, France / University of York, UK / Matra Marconi Space, France

We present an approach for the management of highly critical tasks coexisting with non-critical tasks in a single processor or multiprocessor architecture. To prevent error propagation from non-critical to critical tasks, an integrity level is assigned to groups of tasks according to their trustworthiness. Multiple levels of integrity are implemented using spatial and temporal isolation, and mediation via an integrity policy. The integrity policy defines the rules for data flow between integrity levels and resource utilisation by the tasks at different levels. Since the GUARDS project aims to provide generic solutions for a variety of application domains, the described integrity management can be implemented either in a middleware, the operating system or both. In this paper, we show a CORBA-compliant implementation of the integrity policy.

Appears: Session 3 (Availability and Integrity), Wednesday PM

R. Vanegas, J. A. Zinky, J. P. Loyall, R. E. Schantz and D. E. Bakken
BBN Technologies, USA

Most distributed applications are brittle; they work in a limited environment and cannot adapt to changes in this environment. Making these applications less brittle is a complex engineering task that is hard for specific application areas and even harder to generalize. The Quality Objects (QuO) project offers a framework for creating applications that adapt to different Quality of Services (QoS) offered by the underlying resources. QuO offers several layers of tools for creating adaptive distributed applications using the familiar CORBA development process of code generators and runtime support libraries. In this paper we describe the QuO Runtime and the components it uses to maintain and adapt to QoS. The QuO Runtime is the base functionality on which QuO code generators specialize for a specific adaptive application. The QuO Runtime handles much of the complexity of collecting, organizing, and acting on changing QoS, thus reducing the burden for application developers.

Appears: Session 5 (ORB Architecture), Thursday AM

S. Wheater, S. Shrivastava and F. Ranno
Newcastle University, UK

The paper describes an application composition and execution environment implemented as a transactional workflow system that enables sets of inter-related tasks to be carried out and supervised in a dependable manner. The paper describes how the system meets the requirements of interoperability, scalability, flexible task composition, dependability and dynamic reconfiguration. The system is general purpose and open: it has been designed and implemented as a set of CORBA services, running on top of a given ORB. The system serves as an example of the use of middleware technologies to provide a fault-tolerant execution environment for long running distributed applications.

Appears: Session 1 (Workflow), Wednesday AM

A. Zarras and V. Issarny
IRISA, France

Transactions are contracts that guarantee a consistent, transparent, individual system state transition and their use is widespread in many different kinds of computing systems. Some well known standards (e.g. Corba) include the specification of services that provide transactional properties. In this paper, we present a formal method for the systematic synthesis of transactional middleware based on the combination of the aforementioned services. The synthesis of transactional middleware is based on (i) the formal specification of transactional properties and (ii) stub code generation.

Appears: Session 6 (Components), Thursday PM