We describe the design of a runtime system for a fine-grained concurrent object-oriented (actor) language and its performance. The runtime system provides considerable flexibility to users; specifically, it supports location transparency, actor creation and dynamic placement, and migration. The runtime system includes an efficient distributed name server, a latency hiding scheme for remote actor creation, and a compiler-controlled intra-node scheduling mechanism for local messages and dynamic load balancing. Our preliminary evaluation results suggest that the efficiency that is lost by the greater flexibility of actors can be restored by an efficient runtime system which provides an open interface that can be used by a compiler to allow optimizations. On several standard algorithms, the performance results for our system are comparable to efficient C implementations. Key Words: Concurrent Object-Oriented Programming, Actors, Location Transparency, Migration 1 Introduction We argue t...

This paper describes the integration of concurrency control in BALLOON, an object-oriented language that separates the concepts of type and class as well of subtyping and subclassing. Types are interface specifications enriched with concurrency control annotations. Classes are used to implement the operational functionality of types as well as concurrency control mechanisms. Types, classes and concurrency control annotations are independently reusable and derivable. The language takes advantage of this separation to solve the typical problems of the inheritance anomaly. 1

This thesis describes a technique for designing systems which can adapt to patterns of faults as they occur. Such adaptively dependable systems are especially critical in isolated systems which must maintain long-term fault tolerance and in open systems where future system configurations are unknown. Through the use of a reflective language structure, we support dynamic installation and composition of fault-tolerance protocols. These protocols are constructed as operations on messages to allow reuse and transparency: applications and protocol may be developed separately without prior knowledge of their future composition. We have implemented our techniques in the language Screed which runs on the actor platform Broadway. Details of the implementation are also described.

Abstract An essential motivation behind concurrent object-oriented programming is to exploit the software reuse potential of object-oriented features in the development of concurrent systems. Early attempts to introduce concurrency to object-oriented languages uncovered interferences between object-oriented and concurrency features that limited the extent to which the benefits of object-oriented programming could be realized for developing concurrent systems. This has fostered considerable research into languages and approaches aiming at a graceful integration of object-oriented and concurrent programming. We will examine the issues underlying concurrent object-oriented programming, examine and compare how different approaches for language design address these issues. Although it is not our intention to make an exhaustive survey of concurrent object-oriented languages, we provide a broad coverage of the research in the area. Considerable research activity in the past few years has concentrated on the design of concurrent

This position paper presents some of the problems we had and the results we achieved in the last 4 years of work when defining and developing DASCo [24]. DASCo (Development of Distributed Applications with Separation of Concerns) is an approach for developing objectoriented concurrent and distributed programs using a separation of concerns strategy. In this position paper we emphasize separation and composition of nonorthogonal concerns. The interested reader can obtain more information from the DASCo web page at http://www.esw.inesc.pt/ars/dasco. 1. Introduction Separation of concerns approaches have to deal with two different issues: abstractions and integration mechanisms. The former describes solutions for domain-specific aspects of the software, e.g. object synchronization. The latter are responsible for integrating abstractions among themselves and with the functionality object, e.g. the integration of an object synchronization abstraction with the functionality object. Non-se...

. This paper introduces a new approach of using automata to model behaviour of objects. Automata allow to design a software model on the abstract level of states and transitions. We make precise the meaning of states and transitions in the context of objects and types. This formal semantics serves as a link between informal and formal software development methods. Second, we give a formal, but nevertheless intuitive definition of automata specialization which not only provides a way for reuse of type definitions in subtypes, but also shows how to incrementally design types through refinement. Third we define the notion of a role an object takes when viewed from the environment. Then we can give a formal, but short proof that our definitions satisfy the subtype requirement, that means that an object of the subtype plays the roles of its supertypes. 1 Motivation Object oriented analysis and design (OOA/OOD) results in software models capturing static and dynamic aspects of ...

Abstract not found

We introduce Jeeg, a dialect of Java based on a declarative replacement of the synchronization mechanisms of Java that results in a complete decoupling of the `business' and the `synchronization' code of classes. Synchronization constraints in Jeeg are expressed in a linear temporal logic which allows to effectively limit the occurrence of the inheritance anomaly that commonly affects concurrent object oriented languages. Jeeg is inspired by the current trend in aspect oriented languages. In a Jeeg program the sequential and concurrent aspects of object behaviors are decoupled: specified separately by the programmer these are then weaved together by the Jeeg compiler.

Inheritance is one of the key concepts in object-oriented programming. However, the

A considerable number of language mechanisms have been proposed during the last several years, to specify and implement concurrent object-oriented programs. The major concern of these proposals is to design an expressive language that provides extensible concurrent processing and synchronization features. Almost all these efforts, however, have focused on the multiple-clientsingle-server model where each server determines its synchronization semantics without cooperating with other objects. We believe that object-oriented concurrent languages must not only support a single-server model, but cooperatively synchronizing servers as well. We refer to this as multi-server synchronization. This paper first classifies multi-server synchronization in five categories. The intention here is to define a framework for evaluating current approaches and identifying the requirements for designing new languages. In addition, this paper presents a composable multi-server synchronization technique, adopting the concept of composition-filters. 1.