Mobile objects in distributed Oz

Proceedings of the Second International Symposium on Parallel Symbolic Computation, 1997

We present a design for a distributed programming system, Distributed Oz, that abstracts away the network. This means that all network operations are invoked implicitly by the system as an incidental result of using particular language constructs. However, since network operations are expensive, the programmer must retain control over network communication patterns. This control is provided through the language constructs. While retaining their centralized semantics, they are extended with a distributed semantics. Distributed Oz is an extension of Oz, a concurrent state-aware language with rst-class procedures. Distributed Oz extends Oz with just two concepts: mobility control and asynchronous ordered communication. Mobility control provides for truly mobile objects in a simple and clean way. Asynchronous ordered communication allows to conveniently build servers. These two concepts give the programmer a control over network communications that is both simple and predictable. We give scenarios to show how common distributed programming tasks can be implemented e ciently. There are two reasons for the simplicity of Distributed Oz. First, Oz has a simple formal semantics. Second, the distributed extension is built using network protocols that are natural extensions to the centralized language operations. We discuss the operational semantics of Oz and Distributed Oz and the architecture of the distributed implementation. We give an overview of the basic network protocols for communication and mobility.

2009

Abstract The fundamental ideas of distributed objects have changed little in the last 20 years. Existing languages are retrofitted with transparent distribution mechanisms based on proxies. Experiments with mobile code demonstrate its power but have little impact on practice. The problems with transparency and mobile code have been well known since at least 1994. But in the absence of any fundamental new ideas, the same problematic approaches are used, for example in the design of Java RMI.

1997

Some of the most di cult questions to answer when designing a distributed application are related to mobility: what information to transfer between sites and when and how to transfer it. Transparent distribution, the property that a program's behavior is independent of how it is partitioned among sites, does not directly address these questions. Therefore we propose to extend the language semantics with mobility control, the ability for objects to migrate between sites or to remain stationary at one site. In this way, the syntax and semantics of objects are the same regardless of whether they are used as stationary servers, mobile agents, or simply as caches. We show how to give objects an arbitrary mobility behavior that is independent of the object's de nition. This gives the programmer a simple and e ective control both over information transfer and over the resulting network communication patterns. These ideas have been implemented in Distributed Oz, a concurrent object-oriented language which is state-aware and has data ow synchronization. Distributed Oz is an extension to the publicly-available DFKI Oz 2.0 system.

Advances in Parallel Computing, 2004

Lecture Notes in Computer Science, 2005

In the age of the world-wide web and mobile computing, program- ming communication-centric software is essential. Thus, programmers and pro- gram designers are exposed to new levels of complexity, such as ensuring the correct composition of communication behaviours and guaranteeing deadlock- freedom of their protocols. This paper proposes the language Ldoos, a simple distributed object-oriented language augmented with session communication

1988

The Computer Journal, 1997

As use of object orientation for application development has increased, many researchers have investigated the design of object-based programming languages for the distributed and persistent programming. This paper concentrates on reviewing a number of object-oriented languages for distributed or persistent programming. In each case, the focus is on the object model supported and the mechanisms and policies employed in the implementation of distributed or persistent objects. In particular, each language reviewed has been chosen to illustrate a particular object model or implementation strategy.

1996

Programming of distributed applications is now supported by multiple alternatives when considering high level distributed environments. Using a system platform for remote access to services Such a platform can be a pure distributed operating system or a distributed language runtime like Emerald[1], Argus[2] , Guide[3] , or a platform that integrates distribution like CORBA[4], ILU[5] , Network OLE, etc. Those technologies aim at providing transparent and easy access to distributed services available on a workstation cluster, thus normalizing the way of accessing them. Such a normalization most often deals with the interface description language (IDL[6]) that statically describe services available from various objects, and the mapping of such a language with existing programming languages used for the core implementation of objects. In order to access a service, a client object must first know the identity of the server object (that really provides the desired service), the type of interface that can be dynamically accessed. Then the client object submits a request to the system platform that handles the search for the server, the execution of the request and the delivery of the results. In contrast with this rather static approach, message busses[7][8] are providers of distributed access to dynamically declared services. A client requesting a service is

We hav e developed the Object Space approach which integrates that communication style with object-oriented techniques. It allows encapsulation of protocols for interactions in distributed applications into classes, thus providing a newlev elofabstraction.

JOURNAL OF OBJECT ORIENTED …, 1999

The achievement of efficient implementations is still considered an open problem in the distributed object-oriented programming languages field. In this paper we present an approach to implement in a reasonable efficient way distributed objects. This approach is based on the use of a protocol that allows objects to be migrated and replicated. The basic idea is to reduce the overhead of remote invocations among objects making them local. The effectiveness of our scheme requires a strict programming model, where object invocations must be enclosed between pairs of acquire and release operations, and operations are classified in commands or queries. Details of a thread based implementation are presented. Experiments with a parallel matrix multiply program and a parallel branch and bound program, executed in three different architectures, demonstrate that significant speedups can be obtained.