Actor model

Categories: Actor model

In computer science, the Actor model, first published in 1973, is a mathematical model of concurrent computation. According to Will Clinger [1981] the Actor model "is motivated by the prospect of highly parallel computing machines consisting of dozens, hundreds or even thousands of independent microprocesors, each with its own local memory and communications processor, communicating via a high-performance communications network." Since that time the motivation has broadened to include the prospect of massive concurrency due to the advent of Web Services and many-core computer architecture (see Prospects below).

Actors are the universal primitives of concurrent digital computation. In response to a message that it receives, an Actor can make local decisions, create more Actors, send more messages, and determine how to respond to the next message received. The theory and formalism are further defined in Actor model theory and implementation issues are discussed in Actor model implementation. The relationship of the model to other work is discussed in Actor model, mathematical logic, and physics and Actor model and process calculi. Historical issues in the development of the Actor model are discussed in Actor model early history.

The keys to practical success with the Actor model are specialization for functionality and optimization for performance. Currently the most common use cases are through electronic mail, Web Services (using SOAP) and concurrent programming languages (e.g. Java and C#).

A Serializer is an important kind of Actor defined by the property that it is continually available to the arrival of new messages. One of the defining characteristics of the Actor model is that every message sent to a serializer is guaranteed to arrive. Lockable objects (e.g. in Java and C#) are serializers provided that their implementations are such that messages can continually arrive (perhaps by being stored in an internal queue).

The Actor model was influenced by Lisp, Simula, capability-based systems, packet switching and early versions of Smalltalk. It differs from previous models of computation in that the Actor model was inspired by the laws of physics (physical laws). See Actor model early history.

The model was developed at CalTech Computer Science, Kyoto University Tokoro Laboratory, MCC, MIT Artificial Intelligence Laboratory, SRI, Stanford University, University of Illinois Open Systems Laboratory, University of Paris 6, University of Pisa, University of Tokyo Yonezawa Laboratory and elsewhere.

Contents 1 Applications 2 Control Structure 2.1 Procedural embedding of knowledge 2.2 Planner 2.3 Control structure characterizations 2.4 Hairy control structure 3 Patterns of passing messages 3.1 Control structures are patterns of passing messages 3.2 Simula 3.3 Smalltalk 3.4 Lambda calculus 3.5 Behaviors 3.6 Empty messages allowed 3.7 No required output message queues 3.8 Security 4 Concurrency 4.1 The global state approach to modeling computational steps 4.2 Concurrency control 4.3 The unbounded nondeterminism controversy 5 Modularity 5.1 No global state in the Actor model 5.2 Simplicity, Power, Latency, Throughput, and Storage Efficiency 5.3 Locality 5.4 Compositionality 6 Prospects for the Actor model 7 Actor researchers 8 See also 9 References 10 External links

Applications

Electronic mail can be modeled as an Actor system. Accounts are modeled as Actors and email addresses as Actor addresses. Web Services can be modeled with SOAP endpoints modeled as Actor addresses. An object with a lock (e.g. as in Java and C#) can be modeled as an Actor (see Actor model implementation).

Control Structure

Procedural embedding of knowledge

In the latter half of the 1960s, under the leadership of Marvin Minsky and Seymour Papert, the MIT Artificial Intelligence Laboratory developed a procedural approach in contrast to the logical approach pioneered by John McCarthy who advocated expressing knowledge declaratively in mathematical logic. Bill Woods was also pursuing a procedural approach.

Planner

Carl Hewitt instantiated the MIT approach as "procedural embedding of knowledge" in the programming language Planner that featured pattern-directed invocation of high level procedural plans from goals and assertions. A subset called Micro Planner was implemented by Gerry Sussman, Eugene Charniak and Terry Winograd and was used in Winograd's natural-language understanding program SHRDLU, Gene Charniak's story understanding work, and some other projects which generated a great deal of excitement in Artificial Intelligence.

However, computer memories were very small by current standards because they were expensive, being made of iron ferrite cores at that time. So Planner adopted the then common expedient of using backtracking control structures to economize on the use of computer memory. In this way, the computer only had to store one possibility at a time in exploring alternatives.

One implementation decision in Micro Planner had unfortunate consequences. Lisp had adopted the programming pun of identifying NIL, the empty list with logical false (at memory location 0) because testing for 0 was faster than anything else. Because of the pun, testing for NIL was extremely common in Lisp programs. Micro Planner extended this pun also to use NIL as a signal to begin backtracking. In Micro Planner, it was common to write programs to perform some operation on every element of a list by using a loop to process the first element of a list, take the rest of the list, and then jump back to the top of the loop to test if the list was empty. If the list tested empty, then the program would go on to do other things. Such a program never made it to testing the empty list after processing all the elements because when the last element was processed and the rest of the list was taken, NIL was returned as a value. The Micro Planner interpreter took this as the signal to begin backtracking and began undoing all the work of processing the elements of the list! People were dumbfounded.

In this and several other ways, backtracking proved unwieldy helping to fuel the great control structure debate. Hewitt investigated some alternatives in his thesis.

Control structure characterizations

Using program schemas, Hewitt in collaboration with Mike Paterson proved that recursion is more powerful than iteration and parallelism more powerful than sequential recursion. (He also conjectured that coroutines are more powerful than recursion but couldn't convincingly prove it until recently using a more powerful formalism.)

Hairy control structure

Peter Landin had introduced an even more powerful control structure using his J (for Jump) operator that could perform a nonlocal goto into the middle of a procedure invocation. In fact the J operator could jump back into the middle of a procedure invocation even after it had already returned. Drew McDermott and Gerry Sussman called Landin's concept the "Hairy Control Structure" and used it in the form of a nonlocal goto for the Conniver programming language. Scott Fahlman used Conniver in his planning system for robot construction tasks. This is related to what are now called Re-invocable Continuations.

Patterns of passing messages

Difficulties in communication were a root cause of the control structure difficulties.

Control structures are patterns of passing messages

Hewitt reported: ... we have found that we can do without the paraphernalia of "hairy control structure" (such as possibility lists, non-local gotos, and assignments of values to the internal variables of other procedures in CONNIVER.)... The conventions of ordinary message-passing seem to provide a better structured, more intuitive foundation for constructing the communication systems needed for expert problem-solving modules to cooperate effectively. The Actor model provided the foundation for solving the Artificial Intelligence control structure problem. It took considerable time to develop programming methodologies for the Actor model. Indeed, the implementation of the Scientific Community Metaphor requires sophisticated message passing that is still the subject of research.

Simula

Simula 67 pioneered using message passing for computation, motivated by discrete event simulation applications. These applications had become large and unmodular in previous simulation languages. At each time step, a large central program would have to go through and update the state of each simulation object that changed depending on the state of which ever simulation objects that it interacted with on that step. Kristen Nygaard and Ole-Johan Dahl developed the idea (first described in an IFIP workshop in 1967) of having methods on each object that would update its own local state based on messages from other objects. In addition they introduced a class structure for objects with inheritance. Their innovations considerably improved the modularity of programs.

However Simula used coroutine control structure instead of true concurrency.

Smalltalk

Alan Kay was influenced by message passing in the pattern-directed invocation of Planner in developing Smalltalk-71. Hewitt was intrigued by Smalltalk-71 but was put off by the complexity of communication that included invocations with many fields including global, sender, receiver, reply-style, status, reply, operator selector, etc.

In 1972 Kay visited MIT and discussed some of his ideas for Smalltalk-72 building on the Logo work of Seymour Papert and the "little person" model of computation used for teaching children to program. However, the message passing of Smalltalk-72 was quite complex. Code in the language was viewed by the interpreter as simply a stream of tokens. As Dan Ingalls later described it:

The first (token) encountered (in a program) was looked up in the dynamic context, to determine the receiver of the subsequent message. The name lookup began with the class dictionary of the current activation. Failing there, it moved to the sender of that activation and so on up the sender chain. When a binding was finally found for the token, its value became the receiver of a new message, and the interpreter activated the code for that object's class.

This led some to believe that a new mathematical model of concurent computation based on message passing should be simpler than Smalltalk-72.

Subsequent versions of the Smalltalk language largely followed the path of using the virtual methods of Simula in the message passing structure of programs. However Smalltalk-72 made primitives such as integers, floating point numbers, etc. into objects. The authors of Simula had considered making such primitives into objects but refrained largely for efficiency reasons. Java later adopted the expedient of having both primitive and object versions of integers, floating point numbers, etc. The C# programming language later adopted the more elegant solution of using boxing and unboxing, a variant of which had been used earlier in some Lisp implementations.

The Smalltalk system went on to become very influential, innovating in bitmap displays, personal computing, the class browser interface, and many other ways. For details see Kay's early history of Smalltalk. Meanwhile the Actor efforts at MIT remained focused on developing the science and engineering of higher level concurrency. (See the paper by Jean-Pierre Briot for ideas that were developed later on how to incorporate some kinds of Actor concurrency into later versions of Smalltalk.)

Lambda calculus

The lambda calculus of Alonzo Church can be viewed as the earliest message passing programming language. For example the lambda expression below implements a tree data structure when supplied with parameters for a leftSubTree and rightSubTree. When such a tree is given a parameter message "getLeft", it returns leftSubTree and likewise when given the message "getRight" it returns rightSubTree.

 λ(leftSubTree,rightSubTree)
   λ(message)
     if (message == "getLeft") then leftSubTree
     else if (message == "getRight") then rightSubTree

However, the semantics of the lambda calculus were expressed using variable substitution in which the values of parameters were substituted into the body of an invoked lambda expression. The substitution model is unsuitable for concurrency because it does not allow the capability of sharing of changing resources. Inspired by the lambda calculus, the interpreter for the programming language Lisp made use of a data structure called an environment so that the values of parameters did not have to be substituted into the body of an invoked lambda expression. This allowed for sharing of the effects of updating shared data structures but did not provide for concurrency.

Behaviors

A key innovation was the introduction of behavior specified as a mathematical function to express what an Actor does when it processes a message including specifying a new behavior to process the next message that arrives. Behaviors provided a mechanism to mathematically model the sharing in concurrency.

Behaviors also freed the Actor model from implementation details, e.g., the Smalltalk-72 token stream interpreter. However, it is critical to understand that the efficient implementation of systems described by the Actor model require extensive optimization. See Actor model implementation for details.

Empty messages allowed

Influenced by packet switched networks [1961 and 1964], Hewitt proposed the development of a new model of concurrent computation in which communications would not have any required fields at all: they could be empty. Of course, if the sender of a communication desired a recipient to have access to addresses which the recipient did not already have, the address would have to be sent in the communication.

A computation might need to send a message to a recipient from which it would later receive a response. The way to do this is to send a communication which has the message along with the address of another Actor called the resumption (sometimes also called continuation or stack frame) along with the message. The recipient could then cause a response message to be sent to the resumption.

No required output message queues

Hewitt argued against making output message ordering a requirment of the Actor model. If output message ordering is desired then it can be modeled by a queue Actor that provides this functionality. Such a queue Actor would queue the messages that arrived so that they could be retrieved in FIFO order. So if an Actor X sent a message M1 to an Actor Y and in response to a subsequent message that X received, it sent another message M2 to Y, there is no requirement that M1 arrives at Y before M2<tt>.

In this respect the Actor model mirrors packet switching systems which do not guarantee that packets must be received in the order sent. Not providing the order of delivery guarantee allows packet switching to buffer packets, use multiple paths to send packets, resend damaged packets, and to provide other optimizations.

For example, Actors are allowed to pipeline the processing of messages. What this means is that in the course of processing a message <tt>M1, an Actor can designate the behavior to be used to process the next message, and then in fact begin processing another message M2 before it has finished processing M1. Just because an Actor is allowed to pipeline the processing of messages does not mean that it must pipeline the processing. Whether a message is pipelined is an engineering tradeoff. How would an external observer know whether the processing of a message by an Actor has been pipelined? There is no ambiguity in the definition of an Actor created by the possibility of pipelining. Of course, it is possible to perform the pipeline optimization incorrectly in some implementations, in which case unexpected behavior may occur.

Security

The security of Actors can be protected in the following ways:

• hardwiring in which Actors are physically connected
• hardware as in Burroughs B5000, Lisp machine, etc.
• virtual machines as in Java virtual machine, Common Language Runtime, etc.
• operating systems as in capability-based systems
• signing and/or encryption of Actors and their addresses

Concurrency

The global state approach to modeling computational steps

The first models of computation (e.g. Turing machines, Post productions, the lambda calculus, etc.) were based on mathematics and made use of a global state to represent a computational step. Each computational step was from one global state of the computation to the next global state. The global state approach was continued in automata theory for finite state machines and push down stack machines, including their nondeterministic versions. Such nondeterministic automata have the property of bounded nondeterminism; that is, if a machine always halts when started in its initial state, then there is a bound on the number of states in which it halts.

Probably the first concurrent models of computation were based on shared memory symmetric multiple processors. Such a computer was modeled as a nondeterministic global state machine (with an unbounded number of memory locations).

Concurrency control

Having parallelism with shared memory gave rise to the problem of concurrency control. Originally this problem was conceived as being one of mutual exclusion on a single computer. First Edsger Dijkstra developed semaphores and then Tony Hoare and Per Brinch Hansen developed monitors to solve the mutual exclusion problem. However, neither of these solutions provided a programming language construct that encapsulated access to shared resources. This encapsulation was accomplished by the serializer construct (published in 1979).

The unbounded nondeterminism controversy

Edsger Dijkstra further developed the nondeterministic global state approach. Dijkstra's model gave rise to a controversy concerning unbounded nondeterminism. Unbounded nondeterminism (also called unbounded indeterminacy, a title preferred by Hewitt following Niels Bohr), is a property of concurrency by which the amount of delay in servicing a request can become unbounded as a result of arbitration of contention for shared resources while still guaranteeing that the request will eventually be serviced. Hewitt argued that the Actor model should provide the guarantee of service. In Dijkstra's model, although there could be an unbounded amount of time between the execution of sequential instructions on a computer, a (parallel) program that started out in a well defined state could terminate in only a bounded number of states [Dijkstra 1976]. Consequently, his model could not provide the guarantee of service. Dijkstra argued that it was impossible to implement unbounded nondeterminism.

Hewitt argued otherwise: there is no bound that can be placed on how long it takes a computational circuit called an arbiter to settle (see metastability in electronics due to quantum indeterminacy). Arbiters are used in computers to deal with the circumstance that computer clocks operate asynchronously with input from outside, e.g. keyboard input, disk access, network input, etc. So it could take an unbounded time for a message sent to a computer to be received and in the meantime the computer could traverse an unbounded number of states.

Modularity

The above insights influenced by Lisp, Simula, capability-based systems and early versions of Smalltalk were the genesis of the Actor model.

No global state in the Actor model

The Actor Model features unbounded nondeterminism which was captured in a mathematical model by Will Clinger using domain theory. There is no global state in the Actor model.

Simplicity, Power, Latency, Throughput, and Storage Efficiency

Hewitt argued that the most important criteria for computer architecture are simplicity, power, latency, throughput, and storage efficiency.

1. Simplicity is by far the most important. Extra functionality should be built on the most basic mechanisms.
2. Powerful mechanisms to get the job done are next in importance.
3. Latency means a minimum of overhead in the basic communication mechanisms.
4. Throughput comes in importance just after latency. Decreasing latency has a tendency to increase throughput.
5. Storage Efficiency is also important. Sometimes it is possible to improve the above criteria by using more storage.

Locality

Another important characteristic of the Actor model is locality.

Locality means that in processing a message: an Actor can send messages only to addresses that it receives in the message, addresses that it already had before it received the message, addresses for Actors that it creates while processing the message, and addresses which it synthesizes while processing the message. Note that there are some Actors for which addresses cannot be synthesized because of security, e.g., being hardwired, etc.

Also locality means that there is no simultaneous change in multiple locations. In this way it differs from some other models of concurrency, e.g., the Petri net model in which tokens are simultaneously removed from multiple locations.

Compositionality

Compositionality, i.e., the ability to compose Actor systems into larger ones, is an important aspect of modularity that was developed in Gul Agha's doctoral dissertation and later by Gul Agha, Ian Mason, Scott Smith, and Carolyn Talcott.

Prospects for the Actor model

On the 40th anniversary of the publication of Moore's Law, hardware development is furthering both local and nonlocal massive concurrency. Local concurrency is being enabled by new hardware for 64-bit many-core (Platform 2015 Unveiled at IDF Spring 2005) microprocessors, multi-chip modules, and high performance interconnect. Nonlocal concurrency is being enabled by new hardware for wired and wireless broadband packet switched communications. Both local and nonlocal storage capacities are growing exponentially. All of the above developments favor the Actor model.

The Actor model stands to continue to foster developments in computer and communications architecture, concurrent programming languages, and Web Services. The following are important issues:

• scalability: the challenge of scaling up concurrency both locally and nonlocally.
• transparency: bridging the chasm between local and nonlocal concurrency. Transparency is currently a controversial issue. Some researchers have advocated a strict separation between local concurrency using concurrent programming languages (e.g. Java and C#) from nonlocal concurrency using SOAP for Web services. Strict separation produces a lack of transparency that causes problems when it is desirable/necessary to change between local and nonlocal access to a (Web Services) component. Bridging the chasm will require making binary XML (including XSD) a native data type on Java Virtual Machine and Common Language Runtime.

Actor researchers

Gul Agha, Beppe Attardi, Henry Baker, Will Clinger, Irene Grief, Carl Manning, Ian Mason, Ugo Montanari, Maria Simi, Scott Smith, Carolyn Talcott, and Aki Yonezawa have made important contributions to the semantics of Actors. Important contributions to the implementation of Actors have been made by Bill Athas, Russ Atkinson, Beppe Attardi, Henry Baker, Gerry Barber, Peter Bishop, Nanette Boden, Jean-Pierre Briot, Bill Dally, Peter de Jong, Jessie Dedecker, Ken Kahn, Henry Lieberman, Carl Manning, Tom Reinhardt, Chuck Seitz, Richard Steiger, Dan Theriault, Mario Tokoro, and Darrell Woelk.

See also

• Data flow
• General relativity and Quantum physics, for some physical motivation
• Multi-agent system
• Neural networks
• Ptolemy Project
• Scientific Community Metaphor

References

• Alonzo Church. The calculi of lambda-conversion Princeton University Press. 1941.
• Burroughs Corporation. The Descriptor-a Definition of the B5000 Information Processing System 1961.
• Leonard Kleinrock. Information Flow in Large Communication Nets MIT Research Laboratory on Electronics Quaterly Progress Report. July 1961.
• Ivan Sutherland. Sketchpad, A Man-machine Graphical Communication System Ph.D. dissertation. MIT. Electrical Engineering. January, 1963.
• Paul Baran. On Distributed Communications Networks IEEE Transactions on Communications Systems. March 1964.
• John McCarthy, Paul Abrahams, Dan Edwards, Timothy Hart, and Michael Levin. LISP 1.5 Programmer's Manual M.I.T. Press. 1965.
• Peter Landin. A Generalization of Jumps and Labels Report. UNIVAC Systems Programming Research. August 1965. Reprinted in Higher Order and Symbolic Computation. 1998.
• Edsger Dijkstra Solution of a Problem in Concurrent Programming Control CACM. 1965.
• Jack Dennis and Earl Van Horn. Programming Semantics for Multiprogrammed Computations CACM. March 1966.
• Ole-Johan Dahl and Kristen Nygaard. Class and subclass declarations IFIP TC2 Conference on Simulation Programming Languages. May 1967.
• Doug Englebart, et. al. Augmenting Human Intellect (The Mother of All Demos) At the Fall Joint Computer Conference. December, 1968.
• Carl Hewitt. PLANNER: A Language for Proving Theorems in Robots IJCAI 1969
• Mike Paterson and Carl Hewitt. Comparative Schematology MIT AI Memo 201. August 1970.
• Gerry Sussman and Terry Winograd. Micro-planner Reference Manual AI Memo No, 203, MIT Project MAC, July 1970.
• William A. Woods. Transition network grammars for natural language analysis CACM. 1970.
• Terry Winograd. Procedures as a Representation for Data in a Computer Program for Understanding Natural Language MIT AI TR-235. January 1971.
• Carl Hewitt. Procedural Embedding of Knowledge In Planner IJCAI 1971.
• Drew McDermott and Gerry Sussman. The Conniver Reference Manual MIT AI Memo 259. May 1972.
• G.M. Birtwistle, Ole-Johan Dahl, B. Myhrhaug and Kristen Nygaard. SIMULA Begin Auerbach Publishers Inc, 1973.
• Daniel Bobrow: A Model for Control Structures for Artificial Intelligence Programming Languages IJCAI 1973.
• Carl Hewitt, Peter Bishop and Richard Steiger. A Universal Modular Actor Formalism for Artificial Intelligence IJCAI 1973.
• Scott Fahlman. A Planning System for Robot Construction Tasks MIT AI TR-283. June 1973.
• Robin Milner. Processes: A Mathematical Model of Computing Agents in Logic Colloquium 1973.
• Carl Hewitt, et. al. Actor Induction and Meta-evaluation Conference Record of ACM Symposium on Principles of Programming Languages, January 1974.
• Carl Hewitt, et. al. Behavioral Semantics of Nonrecursive Control Structure Proceedings of Colloque sur la Programmation, April 1974.
• John Reynolds. On the Relation between Direct and Continuation Semantics Proceedings of Second Colloquium on Automata, Languages, and Programming. 1974.
• C.A.R. Hoare. Monitors: An Operating System Structuring Concept CACM. October 1974.
• Irene Greif and Carl Hewitt. Actor Semantics of PLANNER-73 Conference Record of ACM Symposium on Principles of Programming Languages. January 1975.
• Carl Hewitt. How to Use What You Know IJCAI. September, 1975..
• Irene Greif. Semantics of Communicating Parallel Professes MIT EECS Doctoral Dissertation. August 1975.
• Gerald Sussman and Guy Steele. SCHEME: An Interpreter for Extended Lambda Calculus AI Memo 349, MIT Artificial Intelligence Laboratory, Cambridge, Massachusetts, December 1975.
• Edsger Dijkstra. A discipline of programming Prentice Hall. 1976.
• Gordon Plotkin. A powerdomain construction SIAM Journal of Computing, September 1976.
• Alan Kay and Adele Goldberg. Smalltalk-72 Instruction Manual Xerox PARC Memo SSL-76-6. May 1976.
• Carl Hewitt and Henry Baker Actors and Continuous Functionals Proceeding of IFIP Working Conference on Formal Description of Programming Concepts. August 1-5, 1977.
• Henry Baker and Carl Hewitt The Incremental Garbage Collection of Processes Proceeding of the Symposium on Artificial Intelligence Programming Languages. SIGPLAN Notices 12, August 1977.
• Carl Hewitt and Henry Baker Laws for Communicating Parallel Processes IFIP-77, August 1977.
• Gilles Kahn and David MacQueen. Coroutines and networks of parallel processes IFIP. 1977
• Alan Bawden, Richard Greenblatt, Jack Holloway, Thomas Knight, David Moon and Daniel Weinreb. LISP Machine Progress Report MIT AI Memo 444. August 1977.
• Aki Yonezawa Specification and Verification Techniques for Parallel Programs Based on Message Passing Semantics MIT EECS Doctoral Dissertation. December 1977.
• Peter Bishop Very Large Address Space Modularly Extensible Computer Systems MIT EECS Doctoral Dissertation. June 1977.
• Carl Hewitt. Viewing Control Structures as Patterns of Passing Messages Journal of Artificial Intelligence. June 1977.
• Henry Baker. Actor Systems for Real-Time Computation MIT EECS Doctoral Dissertation. January 1978.
• Michael Smyth. Power domains Journal of Computer and System Sciences. 1978.
• C.A.R. Hoare. Communicating sequential processes CACM. August 1978.
• Carl Hewitt and Russ Atkinson. Specification and Proof Techniques for Serializers IEEE Journal on Software Engineering. January 1979.
• Ken Kahn. A Computational Theory of Animation MIT EECS Doctoral Dissertation. August 1979.
• Carl Hewitt, Beppe Attardi, and Henry Lieberman. Delegation in Message Passing Proceedings of First International Conference on Distributed Systems Huntsville, AL. October 1979.
• Nissim Francez, C.A.R. Hoare, Daniel Lehmann, and Willem-Paul de Roever. Semantics of nondetermiism, concurrency, and communication Journal of Computer and System Sciences. December 1979.
• George Milne and Robin Milner. Concurrent processes and their syntax JACM. April 1979.
• Jerald Schwartz Denotational semantics of parallelism in Semantics of Concurrent Computation. Springer-Verlag. 1979.
• Russ Atkinson. Automatic Verification of Serializers MIT Doctoral Dissertation. June, 1980.
• Bill Kornfeld and Carl Hewitt. The Scientific Community Metaphor IEEE Transactions on Systems, Man, and Cybernetics. January 1981.
• Henry Lieberman. Thinking About Lots of Things at Once without Getting Confused: Parallelism in Act 1 MIT AI memo 626. May 1981.
• Henry Lieberman. A Preview of Act 1 MIT AI memo 625. June 1981.
• Gerry Barber. Reasoning about Change in Knowledgeable Office Systems MIT EECS Doctoral Dissertation. August 1981.
• Bill Kornfeld. Parallelism in Problem Solving MIT EECS Doctoral Dissertation. August 1981.
• Will Clinger. Foundations of Actor Semantics MIT Mathematics Doctoral Dissertation. June 1981.
• Daniel Theriault. A Primer for the Act-1 Language MIT AI memo 672. April 1982.
• Henry Lieberman and Carl Hewitt. A real Time Garbage Collector Based on the Lifetimes of Objects CACM June 1983.
• Daniel Theriault. Issues in the Design and Implementation of Act 2 MIT AI technical report 728. June 1983.
• Henry Lieberman. An Object-Oriented Simulator for the Apiary Conference of the American Association for Artificial Intelligence, Washington, D. C., August 1983
• Carl Hewitt and Peter de Jong. Analyzing the Roles of Descriptions and Actions in Open Systems Proceedings of the National Conference on Artificial Intelligence. August 1983.
• Carl Hewitt and Henry Lieberman. Design Issues in Parallel Architecture for Artificial Intelligence MIT AI memo 750. Nov. 1983.
• Daniel Ingalls. The Evolution of the Smalltalk Virtual Machine in Smalltalk-80: Bits of History, Words of Advice. Addison Wesley. 1983.
• Charles Seitz. The Cosmic Cube CACM. Jan. 1985.
• C.A.R. Hoare. Communicating Sequential Processes Prentice Hall. 1985.
• Carl Hewitt. The Challenge of Open Systems Byte Magazine. April 1985. Reprinted in The foundation of artificial intelligence---a sourcebook Cambridge University Press. 1990.
• Matthew Hennessy and Robin Milner. Algebraic laws for nondeterminism and concurrency JACM. January 1985.
• Gul Agha. Actors: A Model of Concurrent Computation in Distributed Systems Doctoral Dissertation. MIT Press. 1986.
• Carl Manning. Traveler: the actor observatory ECOOP 1987. Also appears in Lecture Notes in Computer Science, vol. 276.
• William Athas and Charles Seitz Multicomputers: message-passing concurrent computers IEEE Computer August 1988.
• William Athas and Nanette Boden Cantor: An Actor Programming System for Scientific Computing in Proceedings of the NSF Workshop on Object-Based Concurrent Programming. 1988. Special Issue of SIGPLAN Notices.
• Jean-Pierre Briot. From objects to actors: Study of a limited symbiosis in Smalltalk-80 Rapport de Recherche 88-58, RXF-LITP, Paris, France, September 1988
• William Dally and Wills, D. Universal mechanisms for concurrency PARLE 1989.
• W. Horwat, A. Chien, and W. Dally. Experience with CST: Programming and Implementation PLDI. 1989.
• Carl Hewitt. Towards Open Information Systems Semantics Proceedings of 10th International Workshop on Distributed Artificial Intelligence. October 23-27, 1990. Bandera, Texas.
• Akinori Yonezawa, Ed. ABCL: An Object-Oriented Concurrent System MIT Press. 1990.
• Carl Hewitt. Open Information Systems Semantics Journal of Artificial Intelligence. January 1991.
• Carl Hewitt and Gul Agha. Guarded Horn clause languages: are they deductive and Logical? International Conference on Fifth Generation Computer Systems, Ohmsha 1988. Tokyo. Also in Artificial Intelligence at MIT, Vol. 2. MIT Press 1991.
• Carl Hewitt and Jeff Inman. DAI Betwixt and Between: From "Intelligent Agents" to Open Systems Science IEEE Transactions on Systems, Man, and Cybernetics. Nov./Dec. 1991.
• William Dally, et al. The Message-Driven Processor: A Multicomputer Processing Node with Efficient Mechanisms IEEE Micro. April 1992.
• Gul Agha, Ian Mason, Scott Smith, and Carolyn Talcott. A Foundation for Actor Computation Journal of Functional Programming January 1993.
• Alan Kay. The Early History of Smalltalk The second ACM conference on history of programming languages. 1993.
• Carl Hewitt and Carl Manning. Negotiation Architecture for Large-Scale Crisis Management AAAI-94 Workshop on Models of Conflict Management in Cooperative Problem Solving. Seattle, WA. Aug. 4, 1994.
• Harold Abelson and Gerald Sussman with Julie Sussman. Structure and Interpretation of Computer Programs – 2nd Edition MIT Press 1996.
• Darrell Woelk. Developing InfoSleuth Agents Using Rosette: An Actor Based Language Proceedings of the CIKM '95 Workshop on Intelligent Information Agents. 1995.
• Carl Hewitt and Carl Manning. Synthetic Infrastructures for Multi-Agency Systems Proceedings of ICMAS '96. Kyoto, Japan. December 8–13, 1996.
• Jaques Ferber Multiagent Systems: An Introduction to Distributed Artificial Intelligence Addison-Wesley. 1999.
• Don Box, David Ehnebuske, Gopal Kakivaya, Andrew Layman, Noah Mendelsohn, Henrik Nielsen, Satish Thatte, Dave Winer. Simple Object Access Protocol (SOAP) 1.1 W3C Note. May 2000.

External links

• An interesting set of speculations by Paul Mackay that is now somewhat dated can be found at Why has the actor model not succeeded?