This paper proposes a concurrent model that takes into account such important concerns. We insist on concept unifications: the underlying reasons that make object-oriented programming adapted to concurrency. The model characteristics, especially reusability, permit us to define a concurrent object-oriented design method.

Due to its platform-independent execution model, its support for networking, multithreading and mobile code, Java has given hope that easy Internet-wide high-performance network computing was at hand. Numerous attempts have then been made at providing a framework for the development of such metacomputing applications. Unfortunately, none of them addresses seamless sequential, multithreaded and distributed computing, i-e the execution of the same application on a multiprocessor shared-memory machine as well as on a network of workstations, or on any hierarchical combination of both. In this article we first identify four requirements for the development of such metacomputing frameworks. We then introduce Java// (pronounce Java Parallel), a 100% Java library that provides transparent remote objects as well as asynchronous two-way calls, high reuse potential and high-level synchronization mechanisms. We also present the metaobject protocol (MOP) Java// is built on and describe a...

Abstract not found

Due to its platform-independent execution model, its support for networking, multithreading and mobile code, Java has given hope that easy Internetwide high-performance network computing was at hand. Numerous attempts have then been made at providing a framework for the development of such metacomputing applications. Unfortunately, none of them addresses seamless cross-paradigm computing, i-e the execution of the same application on a multiprocessor shared-memory machine as well as on a network of workstations, or on any combination of both. In this article we first identify four requirements for the development of such metacomputing frameworks. We then introduce Java//, a 100% Java library that provides transparent remote objects as well as asynchronous calls and high-level synchronization mechanisms. We also present the metaobject protocol Java// is built on and give some performance figures. 1 Introduction In order to provide a framework for the development of cross-paradigm meta...

It seems obvious that reuse should be the next contribution of object-oriented programming to concurrency. None the less, it appeared that many difficulties have to be tackled before taking advantage of the full reuse potential of object-oriented concurrent languages. Based on our experiments, this article attempts to provide a better understanding of reuse : we define 10 language features which seem to be required if we want to achieve a high level of reusability in concurrent programming. The structure of this paper reflects the existence of two very different kinds of reuse : reuse of classes and routines, reuse of synchronization constraints. Keywords : abstraction, asynchronism, class and routine reuse, concurrency, continuation, control (centralized or decentralized, explicit or implicit), sequential or parallel processes, synchronization reuse, wait-by-necessity. 1 Introduction This article studies the choices that can be made to handle concurrency within object-oriented pro...

An increasing range of application systems implemented in concurrent object oriented languages (COOLs) creates a pressing demand for developing approaches which provide a systematic way of tolerating software and hardware faults by using software diversity. This paper deals with the problem of tolerating faults in concurrent systems of this type. The purposes of this paper are as follows: to discuss the most appropriate ways of implementing conversations in COOLs; to map all attributes of conversations onto these languages; to discuss the most relevant peculiarities of COOLs in these terms; to suggest approaches to using the conversation scheme; to find the ways in which characteristics of COOLs can facilitate the use of conversation schemes. Thus we try to show how conversations can be used in existing COOLs in a more practical and realistic manner. Keywords: fault-tolerance, software diversity, backward error recovery, atomic action, concurrent object-oriented languages 1 Concurrent...

INTRODUCTION There is an increasing trend towards using COOLs for implementing concurrent distributed applications. In particular, the time is coming when these languages will be used for systems with high dependability requirements. That is why we believe that there exists a clear demand for approaches to providing tolerance to software faults in concurrent systems designed in COOLs. The concept of the conversation proposed by B.Randell [1] was intended to ensure joint recovery of several processes exchanging information. This general idea has been embodied in several ways in later research (for different languages, kinds of communications, potential applications, etc.) and has proved to be a basic one for designing fault-tolerance schemes in all kinds of concurrent systems. We will map this general idea onto COOLs and discuss the peculiarities of this mapping. We understand the conversation concept in the following way. It is an approach to designing cooperative activity and

Introduction We give an overview of the SLOOP system. A synthetic view of each system component and organization is then presented. 2 The SLOOP system Our group (INRIA--I3S/CNRS--Univ. of Nice) works on three main domains: 1. parallel and distributed discrete event simulations, 2. parallel object-oriented languages, 3. interconnection networks. These three different research goals articulate one with another in the construction of the Sloop system: each level uses the primitives and possibilities of the layer just underneath; Figure 1 summarizes the system structure and topics. The bottom layer deals with: communication algorithms, mapping strategies (both static and dynamic) , and overlapping communication/computations. These primitives are used to define and program the middle layer, a parallel object-oriented language (C++//, an extension of C++), which in turn offers: reusability, flexibility, and exte

oncurrent programming, and even concurrent objects, is vast. Lea [Lea99] provides comprehensive, annotated lists of further readings throughout his book, covering the many different facets of concurrent programming, parallel programming, concurrent object systems and other related areas. Andrews [And91] is a good text on the general issues of systems level concurrent programming, as are [Ben82] and [Ben90], whilst operating systems texts such as [Tan92] and [Sil94] introduce the concepts from an OS perspective. Multi-threading texts are usually based around the usage of particular libraries or interfaces, such as those defined by Unix International (UI) and POSIX. Kleiman et al [Kle96] provides a good account of multi-threaded programming with UI threads in Sun's Solaris Extract from the Ph.D. Thesis: "Synchronisation Rings: Composable Synchronisation for Object-Oriented Systems" by David Holmes, Department of Computing, Macquarie University, Sydney h

this paper we first identify four requirements for the development of such metacomputing frameworks. We then introduce Java//(pronounced Java Parallel), a 100% Java library that provides transparent remote objects as well as asynchronous two-way calls, high reuse potential and high-level synchronization mechanisms. We also present the metaobject protocol (MOP) Java//is built on and describe a distributed collaborative raytracing test application built using Java//. 1998 John Wiley & Sons, Ltd