The Structure and Semantics of Actor Languages

The actor model is developed as a foundation for concurrent object-oriented programming. The model provides for non-interference of state changes with multiple threads, inherent concurrency, reconfigurability, encapsulation of namespace, and weak fairness. The paper provides a survey of work in actor languages and can be divided into two areas: namely, formal aspects of the actor model and the structure of actor languages. We provide an abstract view of actor computations in terms of event diagrams and the laws of concurrent computing. The event diagrams can be given a semantics in terms of power domains. We then define the necessary constructs in a minimal actor language. This provides the building blocks for constructing a rich variety of concurrent computing structures. The second part of the paper shows how these higher level structures are built in terms of the actor primitives. In particular, this discussion illustrates how delayed evaluation, streams, continuations, higher-order functions, and other structures, can be built in terms of actor languages. We also note some experiences gained from the implementation of actor systems and argue for the potential advantages discovered by this work. Finally, we discuss some recent research on computational reflection. This work provides the ability to model control, and the ability to treat inheritance as a programmer defined method rather than a predefined linguistic object. The resulting flexibility is very much in the actor tradition of languages.

[1]  Gul A. Agha,et al.  Concurrent object-oriented programming , 1993, CACM.

[2]  Joseph E. Stoy,et al.  Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory , 1981 .

[3]  Edsger W. Dijkstra,et al.  A Discipline of Programming , 1976 .

[4]  Jens Palsberg,et al.  A Denotational Semantics of Inheritance and its Correctness , 1989, OOPSLA.

[5]  Suresh Jagannathan,et al.  A programming language supporting first-class parallel environments , 1989 .

[6]  Luca Cardelli,et al.  On understanding types, data abstraction, and polymorphism , 1985, CSUR.

[7]  Jean-Marc Andreoli,et al.  LO and behold! Concurrent structured processes , 1990, OOPSLA/ECOOP '90.

[8]  Randall B. Smith,et al.  Self: The power of simplicity , 1987, OOPSLA 1987.

[9]  William J. Dally,et al.  Universal Mechanisms for Concurrency , 1989, PARLE.

[10]  Carl Hewitt,et al.  Guarded Horn Clause Languages: Are They Deductive and Logical? , 1991, FGCS.

[11]  Pattie Maes,et al.  Computational reflection , 1987, The Knowledge Engineering Review.

[12]  Bruce D. Shriver,et al.  Research Directions in Object-Oriented Programming , 1987 .

[13]  Charles L. Seitz,et al.  Multicomputers: message-passing concurrent computers , 1988, Computer.

[14]  Samuel N. Kamin Inheritance in smalltalk-80: a denotational definition , 1988, POPL '88.

[15]  Luca Cardelli,et al.  A Semantics of Multiple Inheritance , 1984, Inf. Comput..

[16]  Gul A. Agha,et al.  Supporting Multiparadigm Programming on Actor Architectures , 1989, PARLE.

[17]  William C. Athas,et al.  Fine Grain Concurrent Computations , 1987 .

[18]  William D. Clinger,et al.  Foundations of Actor Semantics , 1981 .

[19]  José Meseguer,et al.  A logical theory of concurrent objects , 1990, OOPSLA/ECOOP '90.

[20]  William B. Ackerman,et al.  Scenarios: A Model of Non-Determinate Computation , 1981, ICFPC.

[21]  Carl Roger Manning,et al.  Acore--the design of a core actor language and its compiler , 1987 .

[22]  Akinori Yonezawa,et al.  ABCL: an object-oriented concurrent system , 1990 .

[23]  Lynn Conway,et al.  Introduction to VLSI systems , 1978 .

[24]  J. W. de Bakker,et al.  Mathematical theory of program correctness , 1980, Prentice-Hall international series in computer science.

[25]  C. Tomlinson,et al.  Inheritance and Synchronization with Enabled Sets , 1989, OOPSLA.

[26]  M.N. Sastry,et al.  Structure and interpretation of computer programs , 1986, Proceedings of the IEEE.

[27]  Gul A. Agha,et al.  Semantic Considerations in the Actor Paradigm of Concurrent Computation , 1984, Seminar on Concurrency.

[28]  William J. Dally,et al.  A VLSI Architecture for Concurrent Data Structures , 1987 .

[29]  Gul A. Agha,et al.  ACTORS - a model of concurrent computation in distributed systems , 1985, MIT Press series in artificial intelligence.

[30]  Henry Lieberman,et al.  Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems , 1986, OOPSLA.

[31]  Uday S. Reddy,et al.  Objects as closures: abstract semantics of object-oriented languages , 1988, LISP and Functional Programming.

[32]  Carl Hewitt,et al.  Viewing Control Structures as Patterns of Passing Messages , 1977, Artif. Intell..