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.

this paper we consider remote creation, migration, and reachability snapshot services: their specification at different levels of abstraction, and their composition. 1.1 About Actors

Bisimilarity (also known as `applicative bisimulation ') has attracted a good deal of attention as an operational equivalence for -calculi. It approximates or even equals Morris-style contextual equivalence and admits proofs of program equivalence via co-induction. It has an elementary construction from the operational definition of a language. We consider bisimilarity for one of the typed object calculi of Abadi and Cardelli. By defining a labelled transition system for the calculus in the style of Crole and Gordon and using a variation of Howe's method we establish two central results: that bisimilarity is a congruence, and that it equals contextual equivalence. So two objects are bisimilar iff no amount of programming can tell them apart. Our third contribution is to show that bisimilarity soundly models the equational theory of Abadi and Cardelli. This is the first study of contextual equivalence for an object calculus and the first application of Howe's method to subtyping. By the...

. This paper presents an imperative and concurrent extension of the functional object-oriented calculus described in [FHM94]. It belongs to the family of so-called prototype-based object-oriented languages, in which objects are created from existing ones via the inheritance primitives of object extension and method override. Concurrency is introduced through the identification of objects and processes. To our knowledge, the resulting calculus is the first concurrent object calculus to be studied. We define an operational semantics for the calculus via a transition relation between configurations, which represent snapshots of the run-time system. Our static analysis includes a type inference system, which statically detects message-not-understood errors, and an effect system, which guarantees that synchronization code, specified via guards, is side-effect free. We present a subject reduction theorem, modified to account for imperative and concurrent features, and type and effect soundne...

A number of efforts in heterogeneous computing involve the development of basic architecture independent communication primitives. We present a new programming paradigm, called ActorSpace, which provides a new communication model based on destination patterns. An actorspace is a computationally passive container of actors which acts as a context for matching patterns. Patterns are matched against listed attributes of actors and actorspaces that are visible in the actorspace. Both visibility and attributes are dynamic. Messages may be sent to one or all members of a group defined by a pattern. The paradigm provides powerful support for component-based construction of heterogeneous scalable distributed applications. In particular, it supports open interfaces to servers and pattern-directed access to software repositories. 1 Introduction Heterogeneous systems are an integral part of computing today. Our approach to heterogeneity is to provide an abstraction layer on top of different arc...

Software executing on distributed systems consists of many asynchronous, autonomous components which interact in order to coordinate local activity. The need for such coordination, as well as requirements such as heterogeneity, scalability, security and availability, considerably increase the complexity of code in distributed applications. Moreover, changing requirements, as well as changes in hardware platforms, lead to software that is constantly evolving and complicates reuse. To support development and evolution of distributed applications requires techniques which allow coordination code to be specified, customized, and maintained independently of application components; goals which cannot be realized solely through object-oriented techniques. This thesis demonstrates that meta-level specification of interaction policies enables modular description of component interaction policies, as well as customization of policy implementations. We present the high-level language Dil for spec...

CORBA (The Common Object Request Broker Architecture) has to continually evolve in order to cope with the changes of requirement of applications which become larger and more distributed. For this reason new features are being added to the CORBA specification, for instance the last proposal for a revised CORBA Messaging Service includes two new asynchronous models of request invocation. Since these new features will be added in the next CORBA implementations a relevant issue is to study their operational behaviour from different perspectives in order to facilitate the task of implementors. This paper addresses this issue providing an analysis of the CORBA Messaging Service which includes the new asynchronous features. In particular we illustrate how CORBA models for request invocation can be mapped into a message passing architecture based on the actor model. For this purpose we exploit an algebra of actors which supports some of the main features of the abstract Object ...

. We describe high-level language constructs for specifying parallel programs and show how they may be used to provide modular specification of communication, synchronization and placement. The high-level constructs are translated into actors which provide flexible low-level primitives for interconnecting distributed components and efficient execution on concurrent computers. We argue that our linguistic constructs allow parallel program specifications that are easier to reason about and efficient to implement. 1. Introduction Current methods for programming parallel computers involve very low-level mechanisms which allow efficient execution only on particular architectures. In order to raise the level of abstraction at which programs are specified, a number of requirements must be met by high-level languages for parallel computing. Specifically, in order for high-level parallel languages to be practical they must: ffl provide constructs which abstract over the coordination structure...

In this paper, we present a language framework for describing dependable systems. Our framework emphasizes modularity and composition. The dependability and functionality aspects of an application may be described independently, providing separation of design concerns. Furthermore, the dependability protocols of an application may be constructed bottom-up as simple protocols that are composed into more complex protocols. Composition makes it easier to reason about the behavior of complex protocols and supports the construction of generic reusable dependability schemes. A significant aspect of our language framework is that dependability protocols may be loaded into a running application and installed dynamically. Dynamic installation makes it possible to impose additional dependability protocols on a server as clients with new dependability demands are integrated into a system. Similarly, if a given dependability protocol is only necessary during some particular phase of execution it m...

We present a fully abstract, denotational model for mobile, timed, nondeterministic data- ow networks whose components communicate in a point-to-point fashion. In this model components and networks of components are represented by sets of stream processing functions. Each stream processing function is required to be strongly guarded, generic and point-to-point. A stream processing function is strongly guarded if it is contractive with respect to the metric on streams. This property guarantees the existence of unique x-points. Genericity is a privacy requirement specific to mobile systems. It guarantees that a function never accesses, depends on or sends a port whose name it does not already know. The point-to-point property guarantees that no port is known to more than two components: the sender and the receiver. Our model allows the description of a wide variety of networks - in particular, the description of mobile, unbounded nondeterministic networks. We demonstrate some features of our model by specifying a communication central.