We present an actor language which is an extension of a simple functional language, and provide a precise operational semantics for this extension. Actor configurations represent open distributed systems, by which we mean that the specification of an actor system explicitly takes into account the interface with external components. We study the composability of such systems. We define and study various notions of testing equivalence on actor expressions and configurations. The model we develop provides fairness. An important result is that the three forms of equivalence, namely, convex, must, and may equivalences, collapse to two in the presence of fairness. We further develop methods for proving laws of equivalence and provide example proofs to illustrate our methodology.

It has been pointed out that inheritance and synchronization constraints in concurrent object systems often conflict with each other, resulting in inheritance anomaly where re-definitions of inherited methods are necessary in order to maintain the integrity of concurrent objects. The anomaly is serious, as it could nullify the benefits of inheritance altogether. Several proposals have been made for resolving the anomaly; however, we argue that those proposals suffer from the incompleteness which allows room for counterexamples. We give an overview and the analysis of inheritance anomaly, and review several proposals for minimizing the unwanted effect of this phenomenon. In particular, we propose (partial) solutions using (1) computational reflection, and (2) transactions in OOCP languages. 1 Introduction Inheritance is the prime language feature in sequential OO (Object-Oriented) languages, and is especially important for code re-use. Another important feature is concurrency; although...

Judging by the looks of the two parties, the marriage between concurrent computation and object-oriented programminga union much desired by practitioners in such fields as telecommunications, high-performance computing, banking and operating systems- appears easy enough to arrange. This appearance, however, is deceptive: the problem is a hard one. This article points the way toward a possible solution. The precise problem examined here is restricted to: What is the smallest, smallest and most convincing extension to the method of systematic object-oriented software construction that can address the need of concurrent and distributed computinng as well as those of sequential computations? The article does not claim to discuss concurrency and distribution in a general and unbiased way

Introduction For the past few years, researchers have been debating the relative merits of object-oriented languages with classes and inheritance as opposed to those with prototypes and delegation. It has become clear that the object-oriented programming language design space is not a dichotomy. Instead, we have identified two fundamental mechanisms---templates and empathy---and several different independent degrees of freedom for each. Templates create new objects in their own image, providing guarantees about the similarity of group members. Empathy allows an object to act as if it were some other object, thus providing sharing of state and behavior. The Smalltalk-80 TM language, 1 Actors, Lieberman's Delegation system, Self, and Hybrid each take differing stands on the forms of templates 1 Smalltalk-80 TM is a trademark of Par

Following our own experience developing a concurrent object-oriented language as well of that of other researchers, we have identb))1 several key problems intT design of a concurrency model compat1}+ wit t he mechanisms ofobject}+4gTT1t programming. We propose an approacht language design in which anexecut1}+ notcut describingte behaviour ofcommunicatTT agent isext+T5+ bysynt4g81 pat4g8 tt encapsulat languageconste1T)+ Weindicat how various language models can beaccommodat5T and how mechanisms such as inherit}+5 can be modeled. Finally, weint6+TT1 a newnotb( oft ypest hat charact(1}T6 concurrent object in t1+6 oft15+ ext5g41}T visible behaviour. 1.

The object-oriented paradigm has gained popularity in various guises not only in programming languages, but in user interfaces, operating systems, databases, and other areas. We argue that the fundamental object-oriented concept is encapsulation, and that all object-oriented mechanisms and approaches exploit this idea to various ends. We introduce the most important of these mechanisms as they are manifested in existing object-oriented systems, and we discuss their relevance in the context of modern application development.

This dissertation makes four contributions towards supporting distributed, multiuser applications over open networks. Dreme, a distributed dialect of the Scheme language in which all first-class language objects are mobile in the network. In particular, various distributed topologies, such as client/server and peer-to-peer, can be created by migrating closures with overlapping scopes around the network, correct inter-process communication being assured by Scheme's lexical scoping rules and network wide addressing. Threads of control are passed around through first-class distributed continuations. A User Interface toolkit for coordinating events in multi-threaded, multi-user applications by organizing continuation callbacks into nested lexical scopes. Each event has certain attributes, such as synchronous/asynchronous. Certain events create new scopes with new events. Continuation callbacks allow both synchronous events which return values to their callers, and asynchronous ones. Applic...

Abstract. A grammar model for concurrent, object-oriented natural language parsing is introduced. Complete lexical distribution of grammatical knowledge is achieved building upon the head-oriented notions of valency and dependency, while inheritance mechanisms are used to capture lexical generalizations. The underlying concurrent computation model relies upon the actor paradigm. We consider message passing protocols for establishing dependency relations and ambiguity handling. 1

Multiple inheritance is still a controversial feature in traditional object-oriented languages, as evidenced by its omission from such languages as Modula-3, Objective C and Java^TM. Nonetheless, users of such languages often complain about having to work around the absence of multiple inheritance. Automating delegation, in combination with a multiple subtyping mechanism, provides many of the same benefits as multiple inheritance, yet sidesteps most of the associated problems. This simple feature could satisfy both the designers and the users of class based object oriented languages. In this paper, we discuss why automated delegation is desirable. We also present Jamie, a freeware preprocessor-based extension to Java that offers such an alternative. Automated Delegation is a Viable Alternative to Multiple Inheritance in Class Based Languages John Viega Dept. Of Computer Science University Of Virginia Charlottesville, VA 22903 viega@list.org Bill Tutt Microsoft Corporat...

Abstract | In this work we discussanumber of issues for the design of hypertext systems in an agent-based model of computation. We examine how the \traditional " fundamental concepts whichare at the basis of the design of hypertexts can be re-visited under a new perspective of collaborative expert agents. The paper presents how some principles of high-level concurrent programming are applied as new methodologies for the design and development of complex software, such ashypertext systems. By adopting an agent-based framework, we gainpowerful control on version management that presents considerable di culties for the developmentofhypertext systems � a general distributed version control mechanism is applied, without signi cant di erences, both in single-user and in collaborative multiuser mode. In both cases, the underlying hypertext architecture is de ned in terms of computational agents interacting each other in order to accomplish common goals. In this paper we present a rst-level prototype implemented in a concurrent object-oriented language, realized on the top of the Common