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.

We introduce a simple, programming language independent rule (known in-house as the Law of Demeter) which encodes the ideas of encapsulation and modularity in an easy to follow form for the object-oriented programmer. The rule achieves the following related benefits if code duplication, the number of method arguments and the number of methods per class are minimized: Easier software maintenance, less coupling between your methods, better information hiding, methods which are easier to reuse, and easier correctness proofs using structural induction. We show relationships between the Law and software engineering techniques, such as coupling control, information hiding, information restriction, localization of information, narrow interfaces and structural induction. We discuss two important interpretations of the Law (strong and weak) and we prove that any object-oriented program can be transformed to satisfy the Law. We express the Law in several languages which support object-oriented p...

This thesis introduces the programming language Guarded Horn Clauses which is abbreviated to GHC. Guarded Horn Clauses was born from the examination of existing logic programming languages and logic programming in general, with special attention paid to parallelism. The main feature of

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

The envisaged notion of object is presented as corresponding to the basic, universal building block of (information) systems. A simple mathematical model for fully concurrent objects (actors) is adopted that extends a suitable model for sequential processes. An object is defined as a process possibly endowed with initiative and tracedependent attributes. Transactional requirements are analysed within this framework as liveness requirements. Object aggregation is explained using the general notion of object morphism. The basic inheritance, overriding and reification mechanisms are also presented, as well as a suitable notion of object-type. The computational model is shown through examples to provide a sound basis for (information) systems design, including abstract conceptual modeling and layered implementation of both passive (record-like) and active (procedure-like) objects. The model establishes a suitable semantic domain for the envisaged broad spectrum specification/design languag...

Abstract. Formal semantic definitions of concurrent languages, when specified in a well-suited semantic framework and supported by generic and efficient formal tools, can be the basis of powerful software analysis tools. Such tools can be obtained for free from the semantic definitions; in our experience in just the few weeks required to define a language’s semantics even for large languages like Java. By combining, yet distinguishing, both equations and rules, rewriting logic semantic definitions unify both the semantic equations of equational semantics (in their higher-order denotational version or their first-order algebraic counterpart) and the semantic rules of SOS. Several limitations of both SOS and equational semantics are thus overcome within this unified framework. By using a high-performance implementation of rewriting logic such as Maude, a language’s formal specification can be automatically transformed into an efficient interpreter. Furthermore, by using Maude’s breadth first search command, we also obtain for free a semi-decision procedure for finding failures of safety properties; and by using Maude’s LTL model checker, we obtain, also for free, a decision procedure for LTL properties of finite-state programs. These possibilities, and the competitive performance of the analysis tools thus obtained, are illustrated by means of a concurrent Caml-like language; similar experience with Java (source and JVM) programs is also summarized. 1

We define three semantic models for actor computation starting with a generalization to open systems of Clinger's event diagram model, and forming two abstractions: interaction diagrams and interaction paths. An algebra is defined on each semantic domain with operations for parallel composition, hiding of internal actors, and renaming. We use these models to provide semantics for descriptions of actor components based on actor theories and show that the semantics is a component algebra homomorphism. 1

We present a semantic framework for actor systems based on rewriting logic. This framework accounts for fairness and provides a variety of semantics for actor system components that have good composability properties. 1 Introduction We are interested in developing a semantic foundation for open distributed systems that supports specifying, composing, and reasoning about components of open distributed systems. We take the actor model of computation [12,1,2] as our starting point. Actors are independent computational agents that interact solely via message passing. An actor can create other actors; send messages; and modify its own local state. An actor can only effect the local state of other actors by sending them messages, and it can only send messages to its acquaintances -- addresses of actors it was given upon creation, it received in a message or actors it created. Actor semantics requires computations to be fair. We take two views of actors: as individuals and as elements of com...

This thesis investigates a particular approach, called state-transition specification, to the problem of describing the behavior of modules in a distributed or concurrent computer ,stem. A state-transition specification consists off (1) a state machine, which incorporates the safety or invariance properties of the module, and (2) validity conditions on the computations of the machine, which'capture the desired liveness or eventu;lity properties. The theory and techniques of state. transition specification are developed'from first principles to a point at which it is possible to write example sPeCificatiOns,'to check-the Specifications for coraiatency, and to perform correctlse examples.

In this paper we present two actor languages and a semantics preserving translation between them. The source of the translation is a high-level language that provides object-based programming abstractions. The target is a simple functional language extended with basic primitives for actor computation. The semantics preserved is the interaction semantics of actor systems---sets of possible interactions of a system with its environment. The proof itself is of interest since it demonstrates a methodology based on the actor theory framework for reasoning about correctness of transformations and translations of actor programs and languages and more generally of concurrent object languages.