: Specification diagrams are a novel form of graphical notation for specifying open distributed object systems. The design goal is to define notation for specifying message-passing behavior that is expressive, intuitively understandable, and that has formal semantic underpinnings. The notation generalizes informal notations such as UML's Sequence Diagrams and broadens their applicability to later in the design cycle. In this paper we show how it is possible to reason rigorously and modularly about specification diagrams. An Actor Theory Toolkit is used to great advantage for this purpose. INTRODUCTION Specification diagrams are a novel form of graphical notation for specifying open distributed object systems. Our goal is to define notation for specifying message-passing behavior that is expressive, intuitively understandable, and that has a rigorous underlying semantics. Many specification languages that have achieved widespread usage have a graphical presentation format, primarily be...

PLAN is a language designed for programming active networks, and can more generally be regarded as a model of mobile computation. PLAN generalizes the paradigm of imperative functional programming in an elegant way that allows for recursive, remote function calls, and it provides a clear mechanism for the interaction between host and mobile code. Techniques for specifying and reasoning about such languages are of growing importance. In this paper we describe our specification of PLAN in the rewriting logic language Maude. We show how techniques for specifying the operational semantics of imperative functional programs (syntax-based semantics) and for formalizing variable binding constructs and mobile environments (CINNI calculus) are used in combination with the natural representation of concurrency and distribution provided by rewriting logic to develop a faithful description of the informal PLAN semantics. We also illustrate the wide-spectrum approach to formal modeling supported by Maude: executing PLAN programs; analyzing PLAN programs using search and model-checking; proving properties of particular PLAN programs; and proving general properties of the PLAN language.

We present a two-level model of distributed computation based on the actor model. This two-level model is the basis for developing a semantic framework that supports dynamic customizability and separation of concerns in designing and reasoning about components of open distributed systems (ODS). ODS evolve dynamically and components of ODS interact with an environment that is not under their control. In particular, we would like to be able to consider separately issues such as: functional behavior of a service; failure semantics and fault tolerance protocols; and resource management issues such as memory management, migration, load balancing, and scheduling. In this report we consider remote creation, migration, and reachability snapshot services: their specification at different levels of abstraction, and their composition.

Communication between distributed objects may have to be protected against random failures and malicious attacks; also, communication timeliness may be essential or highly desired. Therefore, a distributed application often has to be extended with communication services providing some kind of fault-tolerance, secrecy, or quality-of-service guarantees. Ideally, such services should be defined in a highly modular and dynamically composable way, so that the combined assurance of several services can be achieved by composition in certain cases, and so that services can be added or removed from applications at runtime in response to changes in the environment. To reason about the formal properties of such composable communication services one first needs to give them a precise semantics. This paper proposes a rewriting logic semantics for the so-called "onion skin" model of distributed object reection, in which different meta-objects, providing different communication services, can be stacked on top of a basic application object. Since the correct behavior of a service depends on the type of hostile environment against which the service must protect the application, rewriting logic should also be used to specify such hostile environments. The service guarantees are then guarantees about the behavior specified by the union of the rewrite theories specifying the basic application, the services, and the hostile environment.

tors and meta actors, distributed over a network of processing nodes. Base level actors carry out application level computation, while meta-actors are part of the runtime system which manages system resources and controls the runtime semantics of the base level. Meta-actors communicate with each other via message passing as do base level actors, but meta-actors may also examine and modify the state of the base actors located on the same node. The model abstracts from the choice of a specific programming language or system architecture, providing a framework for reasoning about heterogeneous systems. The framework has a very natural representation in rewriting logic [4, 6]. A one level framework (called actor theories), restricted to purely base-level systems has been developed and applied to specification and reasoning about actor systems and languages [5, 9]. The two-level architecture naturally extends to multiple levels, with each level manipulating the level below while being prot

Abstract — In this paper we present Clara, a new programming language for high performance distributed computing. Clara has been developed to embody in an efficient distributed computing environment the conceptual clarity of the actor model, an object-based framework for the design and implementation of open distributed systems. We describe our Clara compiler, paying special attention not only to the adopted two stage translation process but also to the runtime environment, which is based on the message passing interface standard. Keywords —Actor model, Object-based languages, Message passing interface, Compiler construction, Distributed systems.

The problem of programming scalable multicore processors has renewed interest in message-passing languages and frameworks. Such languages and frameworks are typically actororiented, implementing some variant of the standard Actor semantics. This paper analyzes some of the more significant efforts to build actor-oriented frameworks for the JVM platform. It compares the frameworks in terms of their execution semantics, the communication and synchronization abstractions provided, and the representations used in the implementations. It analyzes the performance of actor-oriented frameworks to determine the costs of supporting different actor properties on JVM. The analysis suggests that with suitable optimizations, standard Actor semantics and some useful communication and synchronization abstractions may be supported with reasonable efficiency on the JVM platform.