this paper we discuss four major problems we have observed in our developing and deploying wide-area distributed object applications and middleware. First, most programs are developed ignoring the variable wide area conditions. Second, when application programmers do try to handle these conditions, they have great difficulty because these harsh conditions are different from thost of the local objects they are used to dealing with. Third, IDL hides information about the tradeoffs any implementation of an object must make. Fourth, there is presently no way to systematically reuse current technology components which deal with these conditions, so code sharing becomes impractical. In this paper we also describe our architecture, Quality of Service for CORBA Objects (QuO), which we have developed to overcome these limitations and integrate their solution by providing QoS abstractions to CORBA objects. First, it makes these conditions first class entities and integrates knowledge of them over time, space, and source. Second, it reduces their variance by masking. Third, it exposes key design decisions of an object's implementation and how it will be used. Fourth, it supports reuse of various architectural components and automatically generates others.

Java's Remote Method Invocation is an example of a synchronous communication mechanism with a well defined protocol. Many software systems require more flexibility in their communication mechanisms, including asynchronous communication and delayed referencing of objects (Futures). This paper introduces a novel mechanism allowing Java remote objects to use extended communication protocols without changes to the underlying wire or serialisation protocols. These extensions can be utilised by standard remote objects without additional coding changes and can be incorporated with standard Java clients. This paper explores the possibilities of implementing client controlled versus server controlled asynchronous communication and dynamic selection of protocols through the use of a precompiler for the remote object classes. A discussion of the possibility of integrating Futures and Batched Futures, and any required programming abstractions, into this mechanism is conducted. It is prop...

Abstract-Remote procedure call (RPC) is the most popular paradigm used today to build distributed systems and applica-tions. As a consequence, the term “RPC ” has grown to include a range of vastly different protocols above the transport layer. A resulting problem is that programs often use different RPC proto-cols, cannot be interconnected directly, and building a solution for each case in a large heterogeneous environment is prohibitively expensive. In this paper, we describe the design of a system that can synthesize programs (RPC agents) to accommodate RPC het-erogeneities. Because of its synthesis capability, our system also facilitates the design and implementation of new RPC protocols through rapid prototyping. We have built a prototype system to validate the design and to estimate the agent development costs and cross-RPC performance. Our evaluation shows that our synthesis approach provides a more general solution than

There are increasing numbers of systems and research projects involving software agents and mobile agents. However, there is no reference model or conceptual framework to compare the resulting systems. In this paper, we propose a reference model to identify, classify and evaluate mobile agent systems having a significant set of non-trivial architectural issues and technical and functional features in order to support agent-based applications. Our proposed reference model describes a generic and global architecture and identifies a set of technical and functional features. The items analyzed include the following: execution, management of agent types, management of identifiers, persistence, navigation, communication, interaction with external resources, and security. We apply this reference model to analyze, compare, and discuss some well-known mobile agent systems: Telescript, Aglets, ffMain, D’Agents, and AgentSpace.

We report on a portable, easily usable communication environment, `Sciddle', for distributing computations over heterogenous networks of UNIX computers. Sciddle is based on the client-server model. It was designed to support the distribution of large scale numerical computations and to keep its usage as simple as possible. A convenient array handling has been implemented. We demonstrate the usefulness of the system with an application from quantum chemistry on internet-connected workstations and supercomputers.

Data futures in a metacomputing system refer to data products that have not yet been created but which can be uniquely named and manipulated. We employ data flow mechanisms expressed as high level task graphs in our DISCWorld metacomputing system. Nodes in these task graphs can themselves be expanded into further task graphs or can be represented as futures in the processing schedule. We find this this a generally useful approach to the dynamic and optimal execution of task graphs. In this paper we describe our DISCWorld Remote Access Mechanism for Futures (DRAMFs) and its implementation using Java technology. DRAMFs embody these ideas and allow data products to be lazily de-referenced and to be manipulated as first class objects in the object space of the metacomputing system. Our system aids in the provision against partial failure or network disruptions in a distributed system such as DISCWorld. Keywords: data futures; task graphs; DISCWorld; Java; distributed systems; metacomputing. 1

. GARF is an object-oriented programming environment aimed to support the design of reliable distributed applications. Its computational model is based on two programming levels: the functional level and the behavioral level. At the functional level, software functionalities are described using passive objects, named data objects, in a centralized, volatile, and failure free environment. At the behavioral level, data objects are dynamically bound to encapsulators and mailers which support distribution, concurrency, persistence and fault tolerance. Encapsulators wrap data objects by controlling how the latter send and receive messages, while mailers perform communications between encapsulators. This paper describes how the GARF computational model enables to build flexible and highly modular abstractions for the design of reliable distributed applications. 1 Introduction Transparency has been recognized to be a worthwhile goal in the design of distributed systems. A user of a transpa...

This paper describes the design of an RPC system for building object-oriented distributed software systems. The general requirements for such a system are to provide mechanisms for supporting inheritance, polymorphism, dynamic binding, and modular development in implementing distributed software systems. This paper presents the functionalities of this RPC system to support these general requirements. It also briefly describes the experiences with the previous two versions of this system and how they led to the design of the final system. This system was implemented as a part of the programming environment of the Nexus distributed operating system. Keywords: Distributed computing, Network transparency, Object-oriented programming, Operating systems, Parallel programming, Remote procedure call. INTRODUCTION Some of the major developments over the past two decades in programming systems have been in the areas of distributed computing and object-oriented programming. A large numb...

Creating robust real-time embedded software is critical in combining the physical world with computing, such as in consumer electronics or robotics. One challenge is the complexity of dealing with time together with implementation details that often end up implicitly determining the temporal behavior of the program. In this paper we suggest deconstructing a program into two separate aspects, the functional implementation and a temporal pattern, each expressed separately in a different language. This separation enables independent specification, analysis and prediction of the temporal behavior without regard to the implementation. Meanwhile the implementation is optimized for platforms with different capabilities through a scalable programming model that automatically adapts the execution to the level of concurrency a platform can support. Finally the aspects are put together to create a working system. This paper presents the use of futures and partitures to achieve predictability and performance in embedded systems. A new real-time scheduler for partiture based futures execution is introduced, along with multiple implementations, including one for an 8-bit microcontroller. The paper explains how to create, model, and execute futures and partitures. 1.

This paper presents COMET, a Common Object Management EnvironmenT, that investigates basic problems associated with distributed computing in an internet environment with mobile objects. COMET offers a uniform invocation model, based on dialogues, that integrates both communication and execution aspects. On the communication side, dialogues support asynchronous invocation with preservation of causal relationships. Applications can thus take advantage of the increased parallelism that is possible in a distributed environment. Furthermore COMET's invocation model supports multiple object flavors, offering high-level functionality, s.a. persistence, replication and atomicity. This is realized by modeling invocations as flavor-specific actions, that manipulate typed memory. Reflective techniques are used to dynamically adjust dialogue algorithms according to object flavor. 1. Introduction The concept of Open Systems is becoming increasingly important in today's computing world. A typical c...