Add: title. Changed bare reference to CS1/2. | Use this bot. Report bugs. | Suggested by BrownHairedGirl | #UCB_webform 404/3220
|
Apache Pekko is no longer in incubation. Fixed link.
|
||
(47 intermediate revisions by 39 users not shown) | |||
Line 1: | Line 1: | ||
{{short description|Model of concurrent computation}} |
{{short description|Model of concurrent computation}} |
||
The '''actor model''' in [[computer science]] is a [[mathematical model]] of [[concurrent computation]] that treats ''actor'' as the |
The '''actor model''' in [[computer science]] is a [[mathematical model]] of [[concurrent computation]] that treatsan ''actor'' as the basic building block of concurrent computation. In response to a [[Message (computing)|message]] it receives, an actor can: make local decisions, create more actors, send more messages, and determine how to respond to the next message received. Actors may modify their own [[private state]], but can only affect each other indirectly through messaging (removing the need for [[Lock (computer science)|lock-based synchronization]]). |
||
The actor model originated in 1973.<ref>{{cite journal|ref={{harvid|Hewitt et al.|1973}} |last1=Hewitt|first1=Carl|author-link=Carl Hewitt|last2=Bishop|first2=Peter|last3=Steiger|first3=Richard|title=A Universal Modular Actor Formalism for Artificial Intelligence|publisher=IJCAI|year=1973}}</ref> It has been used both as a framework for a [[Actor model theory|theoretical understanding]] of [[Concurrency (computer science)|computation]] and as the theoretical basis for several [[Actor model implementation|practical implementations]] of [[Concurrency (computer science)|concurrent systems]]. The relationship of the model to other work is discussed in [[actor model and process calculi]]. |
The actor model originated in 1973.<ref>{{cite journal|ref={{harvid|Hewitt et al.|1973}} |last1=Hewitt|first1=Carl|author-link=Carl Hewitt|last2=Bishop|first2=Peter|last3=Steiger|first3=Richard|title=A Universal Modular Actor Formalism for Artificial Intelligence|publisher=IJCAI|year=1973}}</ref> It has been used both as a framework for a [[Actor model theory|theoretical understanding]] of [[Concurrency (computer science)|computation]] and as the theoretical basis for several [[Actor model implementation|practical implementations]] of [[Concurrency (computer science)|concurrent systems]]. The relationship of the model to other work is discussed in [[actor model and process calculi]]. |
||
Line 6: | Line 7: | ||
== History == |
== History == |
||
{{Main|History of the Actor model}} |
{{Main|History of the Actor model}} |
||
According to [[Carl Hewitt]], unlike previous models of computation, the actor model was inspired by [[physics]], including [[general relativity]] and [[quantum mechanics]].{{Citation needed|date=March 2018}} It was also influenced by the programming languages [[Lisp (programming language)|Lisp]], [[Simula]], early versions of [[Smalltalk]], [[capability-based security|capability-based systems]], and [[packet switching]]. Its development was "motivated by the prospect of highly parallel computing machines consisting of dozens, hundreds, or even thousands of independent microprocessors, each with its own local memory and communications processor, communicating via a high-performance communications network."<ref name="clinger1981">{{cite journal|author=William Clinger|author-link=William Clinger (computer scientist)|title=Foundations of Actor Semantics|publisher=MIT|version=Mathematics Doctoral Dissertation|date=June 1981|hdl=1721.1/6935}}</ref> Since that time, the advent of massive concurrency through [[Multi-core (computing)|multi-core]] and [[manycore]] computer architectures has revived interest in the actor model. |
According to [[Carl Hewitt]], unlike previous models of computation, the actor model was inspired by [[physics]], including [[general relativity]] and [[quantum mechanics]].{{Citation needed|date=March 2018}} It was also influenced by the programming languages [[Lisp (programming language)|Lisp]], [[Simula]], early versions of [[Smalltalk]], [[capability-based security|capability-based systems]], and [[packet switching]]. Its development was "motivated by the prospect of highly [[parallel computing]] machines consisting of dozens, hundreds, or even thousands of independent microprocessors, each with its own local memory and communications processor, communicating via a high-performance communications network."<ref name="clinger1981">{{cite journal|author=William Clinger|author-link=William Clinger (computer scientist)|title=Foundations of Actor Semantics|publisher=MIT|version=Mathematics Doctoral Dissertation|date=June 1981|hdl=1721.1/6935}}</ref> Since that time, the advent of massive concurrency through [[Multi-core (computing)|multi-core]] and [[manycore]] computer architectures has revived interest in the actor model. |
||
Following Hewitt, Bishop, and Steiger's 1973 publication, [[Irene Greif]] developed an [[operational semantics]] for the actor model as part of her doctoral research.<ref name="greif1975">{{cite journal|author=Irene Greif|author-link=Irene Greif|title=Semantics of Communicating Parallel Processes|publisher=MIT|version=EECS Doctoral Dissertation|date=August 1975}}</ref> Two years later, [[Henry Baker (computer scientist)|Henry Baker]] and Hewitt published a set of axiomatic laws for actor systems.<ref name="baker1977">{{cite journal|author=Henry Baker|author-link=Henry Baker (computer scientist)|author2=Carl Hewitt|title=Laws for Communicating Parallel Processes|publisher=IFIP|date=August 1977|author-link2=Carl Hewitt}}</ref><ref>{{cite web|url=http://dspace.mit.edu/bitstream/handle/1721.1/41962/AI_WP_134A.pdf|title=Laws for Communicating Parallel Processes|date=10 May 1977}}</ref> Other major milestones include [[William Clinger (computer scientist)|William Clinger's]] 1981 dissertation introducing a [[Denotational semantics of the Actor model|denotational semantics]] based on [[power domains]]<ref name="clinger1981" /> and [[Gul Agha (computer scientist)|Gul Agha]]'s 1985 dissertation which further developed a transition-based semantic model complementary to Clinger's.<ref name="agha1986">{{cite journal|author=Gul Agha|title=Actors: A Model of Concurrent Computation in Distributed Systems|version= Doctoral Dissertation|publisher=MIT Press|year=1986|hdl=1721.1/6952}}</ref> This resulted in the full development of [[actor model theory]]. |
Following Hewitt, Bishop, and Steiger's 1973 publication, [[Irene Greif]] developed an [[operational semantics]] for the actor model as part of her doctoral research.<ref name="greif1975">{{cite journal|author=Irene Greif|author-link=Irene Greif|title=Semantics of Communicating Parallel Processes|publisher=MIT|version=EECS Doctoral Dissertation|date=August 1975}}</ref> Two years later, [[Henry Baker (computer scientist)|Henry Baker]] and Hewitt published a set of axiomatic laws for actor systems.<ref name="baker1977">{{cite journal|author=Henry Baker|author-link=Henry Baker (computer scientist)|author2=Carl Hewitt|title=Laws for Communicating Parallel Processes|publisher=IFIP|date=August 1977|author-link2=Carl Hewitt}}</ref><ref>{{cite web|url=http://dspace.mit.edu/bitstream/handle/1721.1/41962/AI_WP_134A.pdf|title=Laws for Communicating Parallel Processes|date=10 May 1977|access-date=11 June 2014|archive-date=24 June 2016|archive-url=https://web.archive.org/web/20160624000258/http://dspace.mit.edu/bitstream/handle/1721.1/41962/AI_WP_134A.pdf|url-status=live}}</ref> Other major milestones include [[William Clinger (computer scientist)|William Clinger's]] 1981 dissertation introducing a [[Denotational semantics of the Actor model|denotational semantics]] based on [[power domains]]<ref name="clinger1981" /> and [[Gul Agha (computer scientist)|Gul Agha]]'s 1985 dissertation which further developed a transition-based semantic model complementary to Clinger's.<ref name="agha1986">{{cite journal|author=Gul Agha|title=Actors: A Model of Concurrent Computation in Distributed Systems|version= Doctoral Dissertation|publisher=MIT Press|year=1986|hdl=1721.1/6952}}</ref> This resulted in the full development of [[actor model theory]]. |
||
Major software implementation work was done by Russ Atkinson, Giuseppe Attardi, Henry Baker, Gerry Barber, Peter Bishop, Peter de Jong, Ken Kahn, Henry Lieberman, Carl Manning, Tom Reinhardt, Richard Steiger and Dan Theriault in the Message Passing Semantics Group at [[Massachusetts Institute of Technology]] (MIT). Research groups led by Chuck Seitz at [[California Institute of Technology]] (Caltech) and Bill Dally at MIT constructed computer architectures that further developed the message passing in the model. See [[Actor model implementation]]. |
Major software implementation work was done by Russ Atkinson, Giuseppe Attardi, Henry Baker, Gerry Barber, Peter Bishop, Peter de Jong, Ken Kahn, Henry Lieberman, Carl Manning, Tom Reinhardt, Richard Steiger and Dan Theriault in the Message Passing Semantics Group at [[Massachusetts Institute of Technology]] (MIT). Research groups led by Chuck Seitz at [[California Institute of Technology]] (Caltech) and [[Bill Dally]] at MIT constructed computer architectures that further developed the message passing in the model. See [[Actor model implementation]]. |
||
Research on the actor model has been carried out at [[California Institute of Technology]], [[Kyoto University]] Tokoro Laboratory, [[Microelectronics and Computer Technology Corporation]] (MCC), [[MIT Artificial Intelligence Laboratory]], [[SRI International|SRI]], [[Stanford University]], [[University of Illinois at Urbana–Champaign]],<ref>{{cite web|url=http://osl.cs.uiuc.edu |title=Home |publisher=Osl.cs.uiuc.edu |access-date=2012-12-02 |url-status=dead |archive-url=https://web.archive.org/web/20130222175604/http://osl.cs.uiuc.edu/ |archive-date=2013-02-22}}</ref> [[Pierre and Marie Curie University]] (University of Paris 6), [[University of Pisa]], [[University of Tokyo]] Yonezawa Laboratory, [[Centrum Wiskunde & Informatica]] (CWI) and elsewhere. |
Research on the actor model has been carried out at [[California Institute of Technology]], [[Kyoto University]] Tokoro Laboratory, [[Microelectronics and Computer Technology Corporation]] (MCC), [[MIT Artificial Intelligence Laboratory]], [[SRI International|SRI]], [[Stanford University]], [[University of Illinois at Urbana–Champaign]],<ref>{{cite web|url=http://osl.cs.uiuc.edu |title=Home |publisher=Osl.cs.uiuc.edu |access-date=2012-12-02 |url-status=dead |archive-url=https://web.archive.org/web/20130222175604/http://osl.cs.uiuc.edu/ |archive-date=2013-02-22}}</ref> [[Pierre and Marie Curie University]] (University of Paris 6), [[University of Pisa]], [[University of Tokyo]] Yonezawa Laboratory, [[Centrum Wiskunde & Informatica]] (CWI) and elsewhere. |
||
Line 35: | Line 36: | ||
* [[Operational semantics]]<ref name="greif1975"/><ref name="agha1993">{{cite journal|author=Gul Agha|author2=Ian Mason|author3=Scott Smith|author4=Carolyn Talcott|title=A Foundation for Actor Computation|journal=Journal of Functional Programming|date=January 1993}}</ref> |
* [[Operational semantics]]<ref name="greif1975"/><ref name="agha1993">{{cite journal|author=Gul Agha|author2=Ian Mason|author3=Scott Smith|author4=Carolyn Talcott|title=A Foundation for Actor Computation|journal=Journal of Functional Programming|date=January 1993}}</ref> |
||
* Laws for actor systems<ref name="baker1977"/> |
* Laws for actor systems<ref name="baker1977"/> |
||
* [[Denotational semantics]]<ref name="clinger1981"/><ref name="hewitt2006">{{cite journal|author=Carl Hewitt|author-link=Carl Hewitt|url=http://www.pcs.usp.br/~coin-aamas06/10_commitment-43_16pages.pdf|title=What is Commitment? Physical, Organizational, and Social |
* [[Denotational semantics]]<ref name="clinger1981"/><ref name="hewitt2006">{{cite journal|author=Carl Hewitt|author-link=Carl Hewitt|url=http://www.pcs.usp.br/~coin-aamas06/10_commitment-43_16pages.pdf|title=What is Commitment? Physical, Organizational, and Social|date=2006-04-27|access-date=2006-05-26|archive-date=2021-02-11|archive-url=https://web.archive.org/web/20210211011938/http://www2.pcs.usp.br/~coin-aamas06/10_commitment-43_16pages.pdf|url-status=live}}</ref> |
||
* Transition semantics<ref name="agha1986"/> |
* Transition semantics<ref name="agha1986"/> |
||
There are also formalisms that are not fully faithful to the actor model in that they do not formalize the guaranteed delivery of messages including the following (See [[Actor model later history#Attempts to relate Actor semantics to algebra and linear logic|Attempts to relate actor semantics to algebra and linear logic]]): |
There are also formalisms that are not fully faithful to the actor model in that they do not formalize the guaranteed delivery of messages including the following (See [[Actor model later history#Attempts to relate Actor semantics to algebra and linear logic|Attempts to relate actor semantics to algebra and linear logic]]): |
||
* Several different actor algebras<ref name="gaspari1997">{{cite book|author=Mauro Gaspari|title=Formal Methods for Open Object-Based Distributed Systems|pages=3–18|author2=Gianluigi Zavattaro|chapter=An Algebra of Actors|version=Technical Report UBLCS-97-4|publisher=University of Bologna|date=May 1997|chapter-url=https://link.springer.com/content/pdf/10.1007/978-0-387-35562-7_2.pdf|doi=10.1007/978-0-387-35562-7_2|isbn=978-1-4757-5266-3}}</ref><ref name="gaspari1999">{{cite journal|author= M. Gaspari|author2=G. Zavattaro|title=An Algebra of Actors |publisher=Formal Methods for Open Object Based Systems |year=1999}}</ref><ref name="agha2004">{{cite journal|author=Gul Agha|author-link=Gul Agha (computer scientist)|author2=Prasanna Thati|url=http://formal.cs.uiuc.edu/papers/ATactors_festschrift.pdf|archive-url=https://web.archive.org/web/20040420064252/http://formal.cs.uiuc.edu/papers/ATactors_festschrift.pdf|url-status=dead|archive-date=2004-04-20|title=An Algebraic Theory of Actors and Its Application to a Simple Object-Based Language|publisher=From OO to FM (Dahl Festschrift) LNCS 2635|year=2004}}</ref> |
* Several different actor algebras<ref name="gaspari1997">{{cite book|author=Mauro Gaspari|title=Formal Methods for Open Object-Based Distributed Systems|pages=3–18|author2=Gianluigi Zavattaro|chapter=An Algebra of Actors|version=Technical Report UBLCS-97-4|publisher=University of Bologna|date=May 1997|chapter-url=https://link.springer.com/content/pdf/10.1007/978-0-387-35562-7_2.pdf|doi=10.1007/978-0-387-35562-7_2|isbn=978-1-4757-5266-3|access-date=2019-04-08|archive-date=2018-07-26|archive-url=https://web.archive.org/web/20180726193514/https://link.springer.com/content/pdf/10.1007%2F978-0-387-35562-7_2.pdf|url-status=live}}</ref><ref name="gaspari1999">{{cite journal|author= M. Gaspari|author2=G. Zavattaro|title=An Algebra of Actors |publisher=Formal Methods for Open Object Based Systems |year=1999}}</ref><ref name="agha2004">{{cite journal|author=Gul Agha|author-link=Gul Agha (computer scientist)|author2=Prasanna Thati|url=http://formal.cs.uiuc.edu/papers/ATactors_festschrift.pdf|archive-url=https://web.archive.org/web/20040420064252/http://formal.cs.uiuc.edu/papers/ATactors_festschrift.pdf|url-status=dead|archive-date=2004-04-20|title=An Algebraic Theory of Actors and Its Application to a Simple Object-Based Language|publisher=From OO to FM (Dahl Festschrift) LNCS 2635|year=2004}}</ref> |
||
* [[Linear logic]]<ref name="darlington1994">{{cite journal|author=John Darlington|author2=Y. K. Guo|title=Formalizing Actors in Linear Logic|publisher=International Conference on Object-Oriented Information Systems|year=1994}}</ref> |
* [[Linear logic]]<ref name="darlington1994">{{cite journal|author=John Darlington|author2=Y. K. Guo|title=Formalizing Actors in Linear Logic|publisher=International Conference on Object-Oriented Information Systems|year=1994}}</ref> |
||
==Applications== |
==Applications== |
||
The actor model can be used as a framework for modeling, understanding, and reasoning about a wide range of [[concurrent systems]].<ref>{{Cite web|title=What is the Actor Model & When Should You Use it?|url=https://mattferderer.com/|access-date=2021-08-25|website=Matt Ferderer|language=en}}</ref> For example: |
The actor model can be used as a framework for modeling, understanding, and reasoning about a wide range of [[concurrent systems]].<ref>{{Cite web|title=What is the Actor Model & When Should You Use it?|url=https://mattferderer.com/|access-date=2021-08-25|website=Matt Ferderer|language=en|archive-date=2021-08-25|archive-url=https://web.archive.org/web/20210825180156/https://mattferderer.com/|url-status=live}}</ref> For example: |
||
* Electronic mail ([[email]]) can be modeled as an actor system. Accounts are modeled as actors and [[email address]]es as actor addresses. |
* Electronic mail ([[email]]) can be modeled as an actor system. Accounts are modeled as actors and [[email address]]es as actor addresses. |
||
* [[Web service]]s can be modeled with Simple Object Access Protocol ([[SOAP]]) endpoints modeled as actor addresses. |
* [[Web service]]s can be modeled as actors with Simple Object Access Protocol ([[SOAP]]) endpoints modeled as actor addresses. |
||
* Objects with [[Lock (computer science)|lock]]s (''e.g.'', as in [[Java (programming language)|Java]] and [[C Sharp (programming language)|C#]]) can be modeled as a ''serializer'', provided that their implementations are such that messages can continually arrive (perhaps by being stored in an internal [[Queue (abstract data type)|queue]]). A serializer is an important kind of actor defined by the property that it is continually available to the arrival of new messages; every message sent to a serializer is guaranteed to arrive.<ref>{{Cite web|last=Cheung|first=Leo|date=2017-07-25|title=Why Akka and the actor model shine for IoT applications|url=https://www.infoworld.com/article/3209728/why-akka-and-the-actor-model-shine-for-iot-applications.html|access-date=2021-08-25|website=InfoWorld|language=en}}</ref> |
* Objects with [[Lock (computer science)|lock]]s (''e.g.'', as in [[Java (programming language)|Java]] and [[C Sharp (programming language)|C#]]) can be modeled as a ''serializer'', provided that their implementations are such that messages can continually arrive (perhaps by being stored in an internal [[Queue (abstract data type)|queue]]). A serializer is an important kind of actor defined by the property that it is continually available to the arrival of new messages; every message sent to a serializer is guaranteed to arrive.<ref>{{Cite web|last=Cheung|first=Leo|date=2017-07-25|title=Why Akka and the actor model shine for IoT applications|url=https://www.infoworld.com/article/3209728/why-akka-and-the-actor-model-shine-for-iot-applications.html|access-date=2021-08-25|website=InfoWorld|language=en|archive-date=2021-08-25|archive-url=https://web.archive.org/web/20210825181648/https://www.infoworld.com/article/3209728/why-akka-and-the-actor-model-shine-for-iot-applications.html|url-status=live}}</ref> |
||
* Testing and Test Control Notation ([[TTCN]]), both TTCN-2 and [[TTCN-3]], follows actor model rather closely. In TTCN actor is a test component: either parallel test component (PTC) or main test component (MTC). Test components can send and receive messages to and from remote partners (peer test components or test system interface), the latter being identified by its address. Each test component has a behaviour tree bound to it; test components run in parallel and can be dynamically created by parent test components. Built-in language constructs allow the definition of actions to be taken when an expected message is received from the internal message queue, like sending a message to another peer entity or creating new test components. |
* Testing and Test Control Notation ([[TTCN]]), both TTCN-2 and [[TTCN-3]], follows actor model rather closely. In TTCN actor is a test component: either parallel test component (PTC) or main test component (MTC). Test components can send and receive messages to and from remote partners (peer test components or test system interface), the latter being identified by its address. Each test component has a behaviour tree bound to it; test components run in parallel and can be dynamically created by parent test components. Built-in language constructs allow the definition of actions to be taken when an expected message is received from the internal message queue, like sending a message to another peer entity or creating new test components. |
||
Line 56: | Line 57: | ||
Arguably, the first concurrent programs were [[interrupt handler]]s. During the course of its normal operation a computer needed to be able to receive information from outside (characters from a keyboard, packets from a network, ''etc''). So when the information arrived the execution of the computer was ''interrupted'' and special code (called an interrupt handler) was called to put the information in a [[data buffer]] where it could be subsequently retrieved. |
Arguably, the first concurrent programs were [[interrupt handler]]s. During the course of its normal operation a computer needed to be able to receive information from outside (characters from a keyboard, packets from a network, ''etc''). So when the information arrived the execution of the computer was ''interrupted'' and special code (called an interrupt handler) was called to put the information in a [[data buffer]] where it could be subsequently retrieved. |
||
In the early 1960s, interrupts began to be used to simulate the concurrent execution of several programs on one processor.<ref>{{cite book |last=Hansen |first=Per Brinch |author-link=Per Brinch Hansen |title=The Origins of Concurrent Programming: From Semaphores to Remote Procedure Calls |isbn=978-0-387-95401-1 |publisher=Springer |year=2002}}</ref> Having concurrency 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. [[Edsger Dijkstra]] developed [[Semaphore (programming)|semaphores]] and later, between 1971 and 1973,<ref>{{cite journal |last=Hansen |first=Per Brinch |author-link=Per Brinch Hansen |date=1996 |title=Monitors and Concurrent Pascal: A Personal History |journal=Communications of the ACM |pages=121–172}}</ref> [[Tony Hoare]]<ref>{{cite journal |last=Hoare |first=Tony |author-link=Tony Hoare |date=October 1974 |title=Monitors: An Operating System Structuring Concept |journal=Communications of the ACM |volume=17 |issue=10 |pages=549–557|doi=10.1145/355620.361161 |s2cid=1005769 }}</ref> and [[Per Brinch Hansen]]<ref>{{cite book |last=Hansen |first=Per Brinch |author-link=Per Brinch Hansen |date=July 1973 |title=Operating System Principles |publisher=Prentice-Hall}}</ref> developed [[Monitor (synchronization)|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 later accomplished by the [[Serialization|serializer]] construct ([Hewitt and Atkinson 1977, 1979] and [Atkinson 1980]). |
In the early 1960s, interrupts began to be used to simulate the concurrent execution of several programs on one processor.<ref>{{cite book |last=Hansen |first=Per Brinch |author-link=Per Brinch Hansen |title=The Origins of Concurrent Programming: From Semaphores to Remote Procedure Calls |isbn=978-0-387-95401-1 |publisher=Springer |year=2002}}</ref> Having concurrency 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. [[Edsger Dijkstra]] developed [[Semaphore (programming)|semaphores]] and later, between 1971 and 1973,<ref>{{cite journal |last=Hansen |first=Per Brinch |author-link=Per Brinch Hansen |date=1996 |title=Monitors and Concurrent Pascal: A Personal History |journal=Communications of the ACM |pages=121–172}}</ref> [[Tony Hoare]]<ref>{{cite journal |last=Hoare |first=Tony |author-link=Tony Hoare |date=October 1974 |title=Monitors: An Operating System Structuring Concept |journal=Communications of the ACM |volume=17 |issue=10 |pages=549–557|doi=10.1145/355620.361161 |s2cid=1005769 |doi-access=free }}</ref> and [[Per Brinch Hansen]]<ref>{{cite book |last=Hansen |first=Per Brinch |author-link=Per Brinch Hansen |date=July 1973 |title=Operating System Principles |publisher=Prentice-Hall}}</ref> developed [[Monitor (synchronization)|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 later accomplished by the [[Serialization|serializer]] construct ([Hewitt and Atkinson 1977, 1979] and [Atkinson 1980]). |
||
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'' (later generalized in [McCarthy and Hayes 1969] and [Dijkstra 1976] see [[Actor model early history#Event orderings versus global state|Event orderings versus global state]]). 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 machine]]s and push down [[stack machine]]s, including their [[Nondeterministic finite automaton|nondeterministic]] versions. Such nondeterministic automata have the property of [[unbounded nondeterminism|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. |
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'' (later generalized in [McCarthy and Hayes 1969] and [Dijkstra 1976] see [[Actor model early history#Event orderings versus global state|Event orderings versus global state]]). 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 machine]]s and push down [[stack machine]]s, including their [[Nondeterministic finite automaton|nondeterministic]] versions. Such nondeterministic automata have the property of [[unbounded nondeterminism|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. |
||
Line 85: | Line 86: | ||
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. |
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 <code>M1</code>, an actor can designate the behavior to be used to process the next message, and then in fact begin processing another message <code>M2</code> before it has finished processing <code>M1</code>. 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. |
For more example, actors are allowed to pipeline the processing of messages. What this means is that in the course of processing a message <code>M1</code>, an actor can designate the behavior to be used to process the next message, and then in fact begin processing another message <code>M2</code> before it has finished processing <code>M1</code>. 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. |
||
===Locality=== |
===Locality=== |
||
Line 100: | Line 101: | ||
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. |
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, |
Behaviors also freed the actor model from implementation details, ''e.g.'', the Smalltalk-72 token stream interpreter. However, the efficient implementation of systems described by the actor model require ''extensive'' optimization. See [[Actor model implementation]] for details. |
||
=== Modeling other concurrency systems === |
=== Modeling other concurrency systems === |
||
Other concurrency systems (''e.g.'', [[process calculi]]) can be modeled in the actor model using a [[two-phase commit protocol]].<ref>Frederick Knabe. [https://www.researchgate.net/profile/Frederick_Knabe/publication/2823488_A_Distributed_Protocol_for_Channel-Based_Communication_with_Choice/links/00463536b853ab72ef000000.pdf A Distributed Protocol for Channel-Based Communication with Choice PARLE 1992].</ref> |
Other concurrency systems (''e.g.'', [[process calculi]]) can be modeled in the actor model using a [[two-phase commit protocol]].<ref>Frederick Knabe. [https://www.researchgate.net/profile/Frederick_Knabe/publication/2823488_A_Distributed_Protocol_for_Channel-Based_Communication_with_Choice/links/00463536b853ab72ef000000.pdf A Distributed Protocol for Channel-Based Communication with Choice PARLE 1992] {{Webarchive|url=https://web.archive.org/web/20170831084514/https://www.researchgate.net/profile/Frederick_Knabe/publication/2823488_A_Distributed_Protocol_for_Channel-Based_Communication_with_Choice/links/00463536b853ab72ef000000.pdf |date=2017-08-31 }}.</ref> |
||
=== Computational Representation Theorem === |
=== Computational Representation Theorem === |
||
Line 156: | Line 157: | ||
===Practice=== |
===Practice=== |
||
The actor model has had extensive influence on commercial practice. For example, Twitter has used actors for scalability.<ref>{{cite web|url=https://waimingmok.wordpress.com/2009/06/27/how-twitter-is-scaling/ |title=How Twitter Is Scaling « Waiming Mok's Blog |publisher=Waimingmok.wordpress.com |date=2009-06-27 |access-date=2012-12-02}}</ref> Also, Microsoft has used the actor model in the development of its Asynchronous Agents Library.<ref>"[https://msdn.microsoft.com/magazine/623b6c0f-c229-4fcd-8a9d-a5ef24c60db9 Actor-Based Programming with the Asynchronous Agents Library]" MSDN September 2010.</ref> There are many other actor libraries listed in the actor libraries and frameworks section below. |
The actor model has had extensive influence on commercial practice. For example, Twitter has used actors for scalability.<ref>{{cite web |url=https://waimingmok.wordpress.com/2009/06/27/how-twitter-is-scaling/ |title=How Twitter Is Scaling « Waiming Mok's Blog |publisher=Waimingmok.wordpress.com |date=2009-06-27 |access-date=2012-12-02 |archive-date=2021-02-05 |archive-url=https://web.archive.org/web/20210205000818/https://waimingmok.wordpress.com/2009/06/27/how-twitter-is-scaling/ |url-status=live }}</ref> Also, Microsoft has used the actor model in the development of its Asynchronous Agents Library.<ref>"[https://msdn.microsoft.com/magazine/623b6c0f-c229-4fcd-8a9d-a5ef24c60db9 Actor-Based Programming with the Asynchronous Agents Library] {{Webarchive|url=https://web.archive.org/web/20170831090637/https://msdn.microsoft.com/magazine/623b6c0f-c229-4fcd-8a9d-a5ef24c60db9 |date=2017-08-31 }}" MSDN September 2010.</ref> There are many other actor libraries listed in the actor libraries and frameworks section below. |
||
==Addressed issues== |
==Addressed issues== |
||
Line 184: | Line 185: | ||
|hdl = 1721.1/6351 |
|hdl = 1721.1/6351 |
||
}}</ref> |
}}</ref> |
||
*Acttalk<ref>Jean-Pierre Briot. [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.2797 Acttalk: A framework for object-oriented concurrent programming-design and experience 2nd France-Japan workshop. 1999.]</ref> |
*Acttalk<ref>Jean-Pierre Briot. [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.2797 Acttalk: A framework for object-oriented concurrent programming-design and experience 2nd France-Japan workshop. 1999.] {{Webarchive|url=https://web.archive.org/web/20180628015504/http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.2797 |date=2018-06-28 }}</ref> |
||
*Ani<ref>Ken Kahn. [https://dspace.mit.edu/bitstream/handle/1721.1/41979/AI_WP_145.pdf?sequence=1 A Computational Theory of Animation] MIT EECS Doctoral Dissertation. August 1979.</ref> |
*Ani<ref>Ken Kahn. [https://dspace.mit.edu/bitstream/handle/1721.1/41979/AI_WP_145.pdf?sequence=1 A Computational Theory of Animation] {{Webarchive|url=https://web.archive.org/web/20170818200257/https://dspace.mit.edu/bitstream/handle/1721.1/41979/AI_WP_145.pdf?sequence=1 |date=2017-08-18 }} MIT EECS Doctoral Dissertation. August 1979.</ref> |
||
*Cantor<ref>William Athas and Nanette Boden [http://resolver.caltech.edu/CaltechAUTHORS:20160420-155432546 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.</ref> |
*Cantor<ref>William Athas and Nanette Boden [http://resolver.caltech.edu/CaltechAUTHORS:20160420-155432546 Cantor: An Actor Programming System for Scientific Computing] {{Webarchive|url=https://web.archive.org/web/20190408011012/http://resolver.caltech.edu/CaltechAUTHORS:20160420-155432546 |date=2019-04-08 }} in Proceedings of the NSF Workshop on Object-Based Concurrent Programming. 1988. Special Issue of SIGPLAN Notices.</ref> |
||
*Rosette<ref>Darrell Woelk. [https://web.archive.org/web/20170831083730/https://pdfs.semanticscholar.org/e0f3/874399101a0f3b29ec389b8f92b515e373f8.pdf Developing InfoSleuth Agents Using Rosette: An Actor Based Language] Proceedings of the CIKM '95 Workshop on Intelligent Information Agents. 1995.</ref> |
*Rosette<ref>Darrell Woelk. [https://web.archive.org/web/20170831083730/https://pdfs.semanticscholar.org/e0f3/874399101a0f3b29ec389b8f92b515e373f8.pdf Developing InfoSleuth Agents Using Rosette: An Actor Based Language] Proceedings of the CIKM '95 Workshop on Intelligent Information Agents. 1995.</ref> |
||
Line 194: | Line 195: | ||
* [[Actor-Based Concurrent Language|ABCL]] |
* [[Actor-Based Concurrent Language|ABCL]] |
||
* [[AmbientTalk]]<ref>Dedecker J., Van Cutsem T., Mostinckx S., D'Hondt T., De Meuter W. Ambient-oriented Programming in AmbientTalk. In "Proceedings of the 20th European Conference on Object-Oriented Programming (ECOOP), Dave Thomas (Ed.), Lecture Notes in Computer Science Vol. 4067, pp. 230-254, Springer-Verlag.", 2006</ref> |
* [[AmbientTalk]]<ref>Dedecker J., Van Cutsem T., Mostinckx S., D'Hondt T., De Meuter W. Ambient-oriented Programming in AmbientTalk. In "Proceedings of the 20th European Conference on Object-Oriented Programming (ECOOP), Dave Thomas (Ed.), Lecture Notes in Computer Science Vol. 4067, pp. 230-254, Springer-Verlag.", 2006</ref> |
||
* [[Axum (programming language)|Axum]]<ref>{{cite web|author=Darryl K. Taft |url=http://www.eweek.com/c/a/Application-Development/Microsoft-Cooking-Up-New-Parallel-Programming-Language-Axum-868670/ |title=Microsoft Cooking Up New Parallel Programming Language |publisher=Eweek.com |date=2009-04-17 |access-date=2012-12-02}}</ref> |
* [[Axum (programming language)|Axum]]<ref>{{cite web |author=Darryl K. Taft |url=http://www.eweek.com/c/a/Application-Development/Microsoft-Cooking-Up-New-Parallel-Programming-Language-Axum-868670/ |archive-url=https://archive.today/20120729171744/http://www.eweek.com/c/a/Application-Development/Microsoft-Cooking-Up-New-Parallel-Programming-Language-Axum-868670/ |url-status=dead |archive-date=July 29, 2012 |title=Microsoft Cooking Up New Parallel Programming Language |publisher=Eweek.com |date=2009-04-17 |access-date=2012-12-02 }}</ref> |
||
* [[CAL Actor Language]] |
* [[CAL Actor Language]] |
||
* [[D (programming language)|D]] |
* [[D (programming language)|D]] |
||
Line 202: | Line 203: | ||
* [[Erlang (programming language)|Erlang]] |
* [[Erlang (programming language)|Erlang]] |
||
* [[Fantom (programming language)|Fantom]] |
* [[Fantom (programming language)|Fantom]] |
||
* Humus<ref>{{cite web|url=http://www.dalnefre.com/wp/humus/ |title=Humus |publisher=Dalnefre.com |access-date=2012-12-02}}</ref> |
* Humus<ref>{{cite web |url=http://www.dalnefre.com/wp/humus/ |title=Humus |publisher=Dalnefre.com |access-date=2012-12-02 |archive-date=2021-02-07 |archive-url=https://web.archive.org/web/20210207122820/http://www.dalnefre.com/wp/humus/ |url-status=live }}</ref> |
||
* [[Io (programming language)|Io]] |
* [[Io (programming language)|Io]] |
||
* [[LFE (programming language)|LFE]] |
* [[LFE (programming language)|LFE]] |
||
* Encore<ref>{{cite journal| author=Brandauer, Stephan| title=Parallel objects for multicores: A glimpse at the parallel language encore. |journal=Formal Methods for Multicore Programming.|publisher=Springer International Publishing|date=2015 |pages=1–56|display-authors=etal}}</ref> |
* Encore<ref>{{cite journal| author=Brandauer, Stephan| title=Parallel objects for multicores: A glimpse at the parallel language encore. |journal=Formal Methods for Multicore Programming.|publisher=Springer International Publishing|date=2015 |pages=1–56|display-authors=etal}}</ref> |
||
* Pony<ref>{{cite web|url=http://www.ponylang.org|title=The Pony Language}}</ref><ref>{{cite book| chapter=Deny capabilities for safe, fast actors| doi=10.1145/2824815.2824816| title=Proceedings of the 5th International Workshop on Programming Based on Actors, Agents, and Decentralized Control - AGERE! 2015| pages=1–12| year=2015| last1=Clebsch| first1=Sylvan| last2=Drossopoulou| first2=Sophia| last3=Blessing| first3=Sebastian| last4=McNeil| first4=Andy| isbn=9781450339018| s2cid=415745}} by Sylvan Clebsch, Sophia Drossopoulou, Sebastian Blessing, Andy McNeil</ref> |
* [[Pony (programming language)|Pony]]<ref>{{cite web|url=http://www.ponylang.org/|title=The Pony Language|access-date=2016-03-21|archive-date=2018-09-04|archive-url=https://web.archive.org/web/20180904223053/https://www.ponylang.org/|url-status=live}}</ref><ref>{{cite book| chapter=Deny capabilities for safe, fast actors| doi=10.1145/2824815.2824816| title=Proceedings of the 5th International Workshop on Programming Based on Actors, Agents, and Decentralized Control - AGERE! 2015| pages=1–12| year=2015| last1=Clebsch| first1=Sylvan| last2=Drossopoulou| first2=Sophia| last3=Blessing| first3=Sebastian| last4=McNeil| first4=Andy| isbn=9781450339018| s2cid=415745}} by Sylvan Clebsch, Sophia Drossopoulou, Sebastian Blessing, Andy McNeil</ref> |
||
* [[Ptolemy Project]] |
* [[Ptolemy Project]] |
||
* [[P (programming language)|P]]<ref>{{cite web|url=https://github.com/p-org/P|title=The P Language|website=[[GitHub]] |
* [[P (programming language)|P]]<ref>{{cite web|url=https://github.com/p-org/P|title=The P Language|website=[[GitHub]]|date=2019-03-08|access-date=2017-02-01|archive-date=2021-01-15|archive-url=https://web.archive.org/web/20210115123320/https://github.com/p-org/p|url-status=live}}</ref> |
||
* P#<ref>{{cite web|url=https://github.com/p-org/PSharp|title=The P# Language|website=[[GitHub]] |
* P#<ref>{{cite web|url=https://github.com/p-org/PSharp|title=The P# Language|website=[[GitHub]]|date=2019-03-12|access-date=2017-02-01|archive-date=2021-03-23|archive-url=https://web.archive.org/web/20210323114539/https://github.com/p-org/PSharp|url-status=live}}</ref> |
||
* [[Rebeca Modeling Language]] |
* [[Rebeca Modeling Language]] |
||
* [[Reia (programming language)|Reia]] |
* [[Reia (programming language)|Reia]] |
||
* [[Ruby (programming language)|Ruby]]<ref>{{cite web|url=https://docs.ruby-lang.org/en/3.0/Ractor.html |title=class Ractor |publisher=Ruby-lang.org |access-date=2022-03-02}}</ref> |
* [[Ruby (programming language)|Ruby]]<ref>{{cite web |url=https://docs.ruby-lang.org/en/3.0/Ractor.html |title=class Ractor |publisher=Ruby-lang.org |access-date=2022-03-02 |archive-date=2022-03-02 |archive-url=https://web.archive.org/web/20220302211050/https://docs.ruby-lang.org/en/3.0/Ractor.html |url-status=live }}</ref> |
||
* SALSA<ref>{{cite journal |
* SALSA<ref>{{cite journal |
||
| author = Carlos Varela and Gul Agha |
| author = Carlos Varela and Gul Agha |
||
Line 222: | Line 223: | ||
| author = Philipp Haller and Martin Odersky |
| author = Philipp Haller and Martin Odersky |
||
| title = Event-Based Programming without Inversion of Control |
| title = Event-Based Programming without Inversion of Control |
||
|date=September 2006 |
| date = September 2006 |
||
| publisher = Proc. JMLC 2006 |
| publisher = Proc. JMLC 2006 |
||
| url = http://lampwww.epfl.ch/~odersky/papers/jmlc06.pdf |
| url = http://lampwww.epfl.ch/~odersky/papers/jmlc06.pdf |
||
| access-date = 2007-04-05 |
|||
| archive-date = 2020-11-09 |
|||
| archive-url = https://web.archive.org/web/20201109005527/http://lampwww.epfl.ch/~odersky/papers/jmlc06.pdf |
|||
| url-status = live |
|||
}}</ref><ref>{{cite journal |
}}</ref><ref>{{cite journal |
||
| author = Philipp Haller and Martin Odersky |
| author = Philipp Haller and Martin Odersky |
||
Line 239: | Line 244: | ||
|title=Swift Language Guide - Concurrency |
|title=Swift Language Guide - Concurrency |
||
|url=https://docs.swift.org/swift-book/LanguageGuide/Concurrency.html#Actors |
|url=https://docs.swift.org/swift-book/LanguageGuide/Concurrency.html#Actors |
||
|access-date=11 March 2022 |
|access-date=11 March 2022 |
||
|archive-date=1 March 2022 |
|||
|archive-url=https://web.archive.org/web/20220301074208/https://docs.swift.org/swift-book/LanguageGuide/Concurrency.html#Actors |
|||
|url-status=live |
|||
}}</ref> |
}}</ref> |
||
* [[TNSDL]] |
* [[TNSDL]] |
||
Line 255: | Line 263: | ||
! [[Software license|License]] |
! [[Software license|License]] |
||
! Languages |
! Languages |
||
|- |
|||
| [https://github.com/otavia-projects/otavia Otavia] |
|||
| {{Active|style=font-size:smaller}} |
|||
| 2024-01-02 |
|||
| [[Apache License|Apache 2.0]] |
|||
| Scala |
|||
|- |
|||
|[https://github.com/gfiford/abstractor/ Abstractor] |
|||
| {{Active|style=font-size:smaller}} |
|||
| 2024-03-04 |
|||
| [[Apache License|Apache 2.0]] |
|||
| Java |
|||
|- |
|- |
||
| [http://xcraft.ch Xcraft Goblins] |
| [http://xcraft.ch Xcraft Goblins] |
||
Line 265: | Line 285: | ||
| [https://github.com/reacted-io/reacted ReActed] |
| [https://github.com/reacted-io/reacted ReActed] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| |
| 2022-11-30 |
||
| [[Apache License|Apache 2.0]] |
| [[Apache License|Apache 2.0]] |
||
| Java |
| Java |
||
Line 271: | Line 291: | ||
| [https://github.com/DavidBM/acteur-rs Acteur] |
| [https://github.com/DavidBM/acteur-rs Acteur] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2020-04-16<ref>{{cite web|url=https://crates.io/crates/acteur/0.9.1 |title= |
| 2020-04-16<ref>{{cite web |url=https://crates.io/crates/acteur/0.9.1 |title=acteur - 0.9.1· David Bonet · Crates.io |publisher=crates.io |access-date=2020-04-16 |archive-date=2021-02-05 |archive-url=https://web.archive.org/web/20210205000304/https://crates.io/crates/acteur/0.9.1 |url-status=live }}</ref> |
||
|[[Apache License|Apache-2.0]] / [[MIT License|MIT]] |
|[[Apache License|Apache-2.0]] / [[MIT License|MIT]] |
||
| Rust |
| Rust |
||
Line 277: | Line 297: | ||
| [https://github.com/bastion-rs/bastion Bastion] |[https://github.com/bastion-rs/bastion Bastion] |
| [https://github.com/bastion-rs/bastion Bastion] |[https://github.com/bastion-rs/bastion Bastion] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
|2020-08-12<ref>{{Cite web|url=https://crates.io/crates/bastion|title=Bastion on Crates.io|last=Bulut|first=Mahmut|date=2019-12-15|website=Crates.io|access-date=2019-12-15}}</ref> |
|2020-08-12<ref>{{Cite web|url=https://crates.io/crates/bastion|title=Bastion on Crates.io|last=Bulut|first=Mahmut|date=2019-12-15|website=Crates.io|access-date=2019-12-15|archive-date=2021-02-05|archive-url=https://web.archive.org/web/20210205004405/https://crates.io/crates/bastion|url-status=live}}</ref> |
||
|[[MIT License|Apache-2.0 / MIT]] |
|[[MIT License|Apache-2.0 / MIT]] |
||
|Rust |
|Rust |
||
Line 283: | Line 303: | ||
| [https://github.com/actix/actix Actix] |
| [https://github.com/actix/actix Actix] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2020-09-11<ref>{{cite web|title=actix - 0.10.0· Rob Ede · Crates.io|url=https://crates.io/crates/actix/0.10.0|access-date=2021-02-28|publisher=crates.io}}</ref> |
| 2020-09-11<ref>{{cite web|title=actix - 0.10.0· Rob Ede · Crates.io|url=https://crates.io/crates/actix/0.10.0|access-date=2021-02-28|publisher=crates.io|archive-date=2021-05-14|archive-url=https://web.archive.org/web/20210514071652/https://crates.io/crates/actix/0.10.0|url-status=live}}</ref> |
||
| [[MIT License|MIT]] |
| [[MIT License|MIT]] |
||
| Rust |
| Rust |
||
Line 307: | Line 327: | ||
| [https://github.com/zakgof/actr Actr] |
| [https://github.com/zakgof/actr Actr] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2019-04-09<ref>{{cite web|url=https://github.com/zakgof/actr/releases |title=Releases · zakgof/actr · GitHub |publisher=Github.com |access-date=2019-04-16}}</ref> |
| 2019-04-09<ref>{{cite web |url=https://github.com/zakgof/actr/releases |title=Releases · zakgof/actr · GitHub |publisher=Github.com |access-date=2019-04-16 |archive-date=2020-10-26 |archive-url=https://web.archive.org/web/20201026142401/https://github.com/zakgof/actr/releases |url-status=live }}</ref> |
||
| [[Apache License|Apache 2.0]] |
| [[Apache License|Apache 2.0]] |
||
| Java |
| Java |
||
Line 325: | Line 345: | ||
| [[Akka (toolkit)]] |
| [[Akka (toolkit)]] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| |
| 2022-09-06<ref>{{cite web|url=https://akka.io/blog/news/2022/09/06/akka-2.6.20-released|title=Akka 2.6.20 Released · Akka|publisher=Akka|date=2022-09-06|access-date=2022-09-24|archive-date=2022-09-24|archive-url=https://web.archive.org/web/20220924184226/https://akka.io/blog/news/2022/09/06/akka-2.6.20-released|url-status=live}}</ref> |
||
| Commercial<ref>{{cite web | url=https://www.lightbend.com/akka/license-faq | title=Akka License FAQ | @lightbend }}</ref> ([[Apache License|Apache 2.0]] up to 2.6. |
| Commercial<ref>{{cite web | url=https://www.lightbend.com/akka/license-faq | title=Akka License FAQ | @lightbend | access-date=2022-09-24 | archive-date=2022-09-22 | archive-url=https://web.archive.org/web/20220922095902/https://www.lightbend.com/akka/license-faq | url-status=live }}</ref> (from 2.7.0, [[Apache License|Apache 2.0]] up to 2.6.20) |
||
| Java and Scala |
| Java and Scala |
||
|- |
|- |
||
| [http://getakka.net Akka.NET] |
| [http://getakka.net Akka.NET] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2020-08-20<ref>Akka.NET v1.4.10 Stable Release {{Citation|title=GitHub - akkadotnet/akka.net: Port of Akka actors for .NET.|date=2020-10-01|url=https://github.com/akkadotnet/akka.net|publisher=Akka.NET|access-date=2020-10-01}}</ref> |
| 2020-08-20<ref>Akka.NET v1.4.10 Stable Release {{Citation|title=GitHub - akkadotnet/akka.net: Port of Akka actors for .NET.|date=2020-10-01|url=https://github.com/akkadotnet/akka.net|publisher=Akka.NET|access-date=2020-10-01|archive-date=2021-02-24|archive-url=https://web.archive.org/web/20210224183816/https://github.com/akkadotnet/akka.net|url-status=live}}</ref> |
||
| [[Apache License|Apache 2.0]] |
| [[Apache License|Apache 2.0]] |
||
| .NET |
| .NET |
||
|- |
|||
| [https://pekko.apache.org/ Apache Pekko ] |
|||
| {{Active|style=font-size:smaller}} |
|||
| 2023-07-26<ref>{{Citation|title=Apache Pekko (Graduated)|url=https://incubator.apache.org/projects/pekko.html|publisher=Apache Software Foundation}}</ref> |
|||
| [[Apache License|Apache 2.0]] |
|||
| Java and Scala |
|||
|- |
|||
| [https://dapr.io/ Dapr] |
|||
| {{Active|style=font-size:smaller}} |
|||
| 2019-10-16 |
|||
| [[Apache License|Apache 2.0]] |
|||
| Java, .NET Core, Go, Javascript, Python, Rust and C++ |
|||
|- |
|- |
||
| [https://github.com/ddobric/dotnetactors DOTNETACTORS] |
| [https://github.com/ddobric/dotnetactors DOTNETACTORS] |
||
Line 371: | Line 403: | ||
| Java |
| Java |
||
|- |
|- |
||
| [http://kilim.malhar.net/ Kilim]<ref>{{cite conference|last=Srinivasan|first=Sriram |author2=Alan Mycroft |title=Kilim: Isolation-Typed Actors for Java |url=http://www.malhar.net/sriram/kilim/kilim_ecoop08.pdf|book-title=European Conference on Object Oriented Programming ECOOP 2008 |year=2008 | |
| [http://kilim.malhar.net/ Kilim]<ref>{{cite conference |last=Srinivasan |first=Sriram |author2=Alan Mycroft |title=Kilim: Isolation-Typed Actors for Java |url=http://www.malhar.net/sriram/kilim/kilim_ecoop08.pdf |book-title=European Conference on Object Oriented Programming ECOOP 2008 |year=2008 |location=Cyprus |access-date=2016-02-25 |archive-date=2020-10-28 |archive-url=https://web.archive.org/web/20201028145553/https://www.malhar.net/sriram/kilim/kilim_ecoop08.pdf |url-status=live }}</ref> |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2018-11-09<ref>{{cite web|url=https://github.com/kilim/kilim/releases|title=Releases · kilim/kilim · GitHub |
| 2018-11-09<ref>{{cite web|url=https://github.com/kilim/kilim/releases|title=Releases · kilim/kilim · GitHub|publisher=Github.com|access-date=2019-06-03|archive-date=2020-10-16|archive-url=https://web.archive.org/web/20201016013355/https://github.com/kilim/kilim/releases|url-status=live}}</ref> |
||
| [[MIT License|MIT]] |
| [[MIT License|MIT]] |
||
| Java |
| Java |
||
Line 389: | Line 421: | ||
| Objective-C |
| Objective-C |
||
|- |
|- |
||
| [https://haskell-distributed.github.com/wiki.html Cloud Haskell] |
| [https://archive.today/20130615053932/http://haskell-distributed.github.com/wiki.html Cloud Haskell] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| |
| 2024-04-30<ref>{{cite web |title=Hackage: The Haskell Package Repository |url=https://hackage.haskell.org/package/distributed-process-0.7.6 |website=Hackage |access-date=1 May 2024}}</ref> |
||
| [[BSD]] |
| [[BSD]] |
||
| Haskell |
| Haskell |
||
Line 397: | Line 429: | ||
| [http://cloudi.org CloudI] |
| [http://cloudi.org CloudI] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| |
| 2023-10-27<ref>{{cite web |url=https://sourceforge.net/p/cloudi/activity/ |title=CloudI: A Cloud at the lowest level · Activity |publisher=sourceforge.net |access-date=2024-01-03}}</ref> |
||
|[[MIT License|MIT]] |
|[[MIT License|MIT]] |
||
| ATS, C/C++, Elixir/Erlang/LFE, Go, Haskell, Java, Javascript, OCaml, Perl, PHP, Python, Ruby |
| ATS, C/C++, Elixir/Erlang/LFE, Go, Haskell, Java, Javascript, OCaml, Perl, PHP, Python, Ruby, Rust |
||
|- |
|- |
||
| [https://wiki.gnome.org/Projects/Clutter Clutter] |
| [https://wiki.gnome.org/Projects/Clutter Clutter] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2017-05-12<ref>{{cite web|url=https://gitlab.gnome.org/GNOME/clutter/tags |title=Tags · GNOME/clutter · GitLab|publisher=gitlab.gnome.org |access-date=2019-06-03}}</ref> |
| 2017-05-12<ref>{{cite web |url=https://gitlab.gnome.org/GNOME/clutter/tags |title=Tags · GNOME/clutter · GitLab |publisher=gitlab.gnome.org |access-date=2019-06-03 |archive-date=2019-06-03 |archive-url=https://web.archive.org/web/20190603183830/https://gitlab.gnome.org/GNOME/clutter/tags |url-status=live }}</ref> |
||
| [[LGPL| LGPL 2.1]] |
| [[LGPL| LGPL 2.1]] |
||
| C, C++ (cluttermm), Python (pyclutter), Perl (perl-Clutter) |
| C, C++ (cluttermm), Python (pyclutter), Perl (perl-Clutter) |
||
Line 413: | Line 445: | ||
| .NET |
| .NET |
||
|- |
|- |
||
| [https://nact.io/ Nact] |
| [https://nact.io/ Nact] {{Webarchive|url=https://web.archive.org/web/20210205004409/https://nact.io/ |date=2021-02-05 }} |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2018-06-06<ref>{{cite web|url=https://github.com/ncthbrt/nact/releases|title=Releases · ncthbrt/nact · GitHub|website=[[GitHub]] |
| 2018-06-06<ref>{{cite web|url=https://github.com/ncthbrt/nact/releases|title=Releases · ncthbrt/nact · GitHub|website=[[GitHub]]|access-date=2019-06-03|archive-date=2020-11-27|archive-url=https://web.archive.org/web/20201127021215/https://github.com/ncthbrt/nact/releases|url-status=live}}</ref> |
||
| [[Apache License|Apache 2.0]] |
| [[Apache License|Apache 2.0]] |
||
| JavaScript/ReasonML |
| JavaScript/ReasonML |
||
Line 421: | Line 453: | ||
| [https://code.google.com/p/retlang/ Retlang] |
| [https://code.google.com/p/retlang/ Retlang] |
||
| {{no|Inactive|style=font-size:smaller}} |
| {{no|Inactive|style=font-size:smaller}} |
||
| 2011-05-18<ref>{{cite web|url=https://code.google.com/p/retlang/source/list |title=Changes - retlang - Message based concurrency in .NET - Google Project Hosting |access-date=2016-02-25}}</ref> |
| 2011-05-18<ref>{{cite web |url=https://code.google.com/p/retlang/source/list |title=Changes - retlang - Message based concurrency in .NET - Google Project Hosting |access-date=2016-02-25 |archive-date=2015-11-24 |archive-url=https://web.archive.org/web/20151124094146/http://code.google.com/p/retlang/source/list |url-status=live }}</ref> |
||
| [[BSD License|New BSD]] |
| [[BSD License|New BSD]] |
||
| .NET |
| .NET |
||
Line 433: | Line 465: | ||
| [https://code.google.com/p/jetlang/ Jetlang] |
| [https://code.google.com/p/jetlang/ Jetlang] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2013-05-30<ref>{{cite web|url=https://code.google.com/p/jetlang/downloads/detail?name=jetlang-0.2.9-bin.zip&can=2&q= |title=jetlang-0.2.9-bin.zip - jetlang - jetlang-0.2.9-bin.zip - Message based concurrency for Java - Google Project Hosting |date=2012-02-14 |access-date=2016-02-25}}</ref> |
| 2013-05-30<ref>{{cite web |url=https://code.google.com/p/jetlang/downloads/detail?name=jetlang-0.2.9-bin.zip&can=2&q= |title=jetlang-0.2.9-bin.zip - jetlang - jetlang-0.2.9-bin.zip - Message based concurrency for Java - Google Project Hosting |date=2012-02-14 |access-date=2016-02-25 |archive-date=2016-01-14 |archive-url=https://web.archive.org/web/20160114205235/https://code.google.com/p/jetlang/downloads/detail?name=jetlang-0.2.9-bin.zip&can=2&q= |url-status=live }}</ref> |
||
| [[BSD License|New BSD]] |
| [[BSD License|New BSD]] |
||
| Java |
| Java |
||
Line 445: | Line 477: | ||
| [http://gpars.org/ GPars] |
| [http://gpars.org/ GPars] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2014-05-09<ref>{{cite web|url=https://github.com/GPars/GPars/releases |title=GPars Releases|publisher=GitHub |access-date=2016-02-25}}</ref> |
| 2014-05-09<ref>{{cite web |url=https://github.com/GPars/GPars/releases |title=GPars Releases |publisher=GitHub |access-date=2016-02-25 |archive-date=2020-09-04 |archive-url=https://web.archive.org/web/20200904211029/https://github.com/GPars/GPars/releases |url-status=live }}</ref> |
||
| [[Apache License|Apache 2.0]] |
| [[Apache License|Apache 2.0]] |
||
| Groovy |
| Groovy |
||
Line 451: | Line 483: | ||
| [https://www.oosmos.com/ OOSMOS] |
| [https://www.oosmos.com/ OOSMOS] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2019-05-09<ref>{{cite web|url=https://github.com/oosmos/oosmos/releases|title=Releases · oosmos/oosmos · GitHub|publisher=GitHub |
| 2019-05-09<ref>{{cite web|url=https://github.com/oosmos/oosmos/releases|title=Releases · oosmos/oosmos · GitHub|publisher=GitHub|access-date=2019-06-03|archive-date=2020-11-13|archive-url=https://web.archive.org/web/20201113052931/https://github.com/oosmos/oosmos/releases|url-status=live}}</ref> |
||
| [[GPL|GPL 2.0]] and commercial (dual licensing) |
| [[GPL|GPL 2.0]] and commercial (dual licensing) |
||
| C. C++ friendly |
| C. C++ friendly |
||
Line 499: | Line 531: | ||
| [http://pykka.readthedocs.org/en/latest/index.html Pykka] |
| [http://pykka.readthedocs.org/en/latest/index.html Pykka] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2019-05-07<ref>{{cite web|url=https://www.pykka.org/en/latest/changes/#v2-0-0-2019-05-07 |title=Changes – Pykka 2.0.0 documentation |publisher=pykka.org |access-date=2019-06-03}}</ref> |
| 2019-05-07<ref>{{cite web |url=https://www.pykka.org/en/latest/changes/#v2-0-0-2019-05-07 |title=Changes – Pykka 2.0.0 documentation |publisher=pykka.org |access-date=2019-06-03 |archive-date=2021-02-05 |archive-url=https://web.archive.org/web/20210205001043/https://www.pykka.org/en/latest/changes/#v2-0-0-2019-05-07 |url-status=live }}</ref> |
||
| [[Apache License|Apache 2.0]] |
| [[Apache License|Apache 2.0]] |
||
| Python |
| Python |
||
Line 510: | Line 542: | ||
|- |
|- |
||
| [https://web.archive.org/web/20140810090245/http://www.theron-library.com/ Theron] |
| [https://web.archive.org/web/20140810090245/http://www.theron-library.com/ Theron] |
||
| {{no|Inactive|style=font-size:smaller}}<ref>{{cite web|url=http://www.ashtonmason.net/theron/ |title=Theron – Ashton Mason |access-date=2018-08-29}}</ref> |
| {{no|Inactive|style=font-size:smaller}}<ref>{{cite web |url=http://www.ashtonmason.net/theron/ |title=Theron – Ashton Mason |access-date=2018-08-29 |archive-date=2019-03-31 |archive-url=https://web.archive.org/web/20190331023110/http://www.ashtonmason.net/theron/ |url-status=live }}</ref> |
||
| 2014-01-18<ref>{{cite web |url=http://www.theron-library.com/index.php?t=news |title=Theron - Version 6.00.02 released |publisher=Theron-library.com |access-date=2016-02-25 |archive-url=https://web.archive.org/web/20160316122155/http://www.theron-library.com/index.php?t=news |archive-date=2016-03-16 |url-status=dead}}</ref> |
| 2014-01-18<ref>{{cite web |url=http://www.theron-library.com/index.php?t=news |title=Theron - Version 6.00.02 released |publisher=Theron-library.com |access-date=2016-02-25 |archive-url=https://web.archive.org/web/20160316122155/http://www.theron-library.com/index.php?t=news |archive-date=2016-03-16 |url-status=dead}}</ref> |
||
| [[MIT License|MIT]]<ref>{{cite web |url=http://www.theron-library.com/index.php?t=page&p=license |title=Theron |publisher=Theron-library.com |access-date=2016-02-25 |archive-url=https://web.archive.org/web/20160304000109/http://www.theron-library.com/index.php?t=page&p=license |archive-date=2016-03-04 |url-status=dead}}</ref> |
| [[MIT License|MIT]]<ref>{{cite web |url=http://www.theron-library.com/index.php?t=page&p=license |title=Theron |publisher=Theron-library.com |access-date=2016-02-25 |archive-url=https://web.archive.org/web/20160304000109/http://www.theron-library.com/index.php?t=page&p=license |archive-date=2016-03-04 |url-status=dead}}</ref> |
||
Line 523: | Line 555: | ||
| [https://github.com/puniverse/quasar Quasar] |
| [https://github.com/puniverse/quasar Quasar] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2018-11-02<ref>{{cite web|url=https://github.com/puniverse/quasar/releases|title=Releases · puniverse/quasar · GitHub|website=[[GitHub]] |
| 2018-11-02<ref>{{cite web|url=https://github.com/puniverse/quasar/releases|title=Releases · puniverse/quasar · GitHub|website=[[GitHub]]|access-date=2019-06-03|archive-date=2020-12-15|archive-url=https://web.archive.org/web/20201215084827/https://github.com/puniverse/quasar/releases|url-status=live}}</ref> |
||
| [[LGPL]]/[[Eclipse Public License|Eclipse]] |
| [[LGPL]]/[[Eclipse Public License|Eclipse]] |
||
| Java |
| Java |
||
Line 535: | Line 567: | ||
| [https://code.google.com/p/actor-cpp/ Actor-CPP] |
| [https://code.google.com/p/actor-cpp/ Actor-CPP] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2012-03-10<ref>{{cite web|url=https://code.google.com/p/actor-cpp/source/list |title=Changes - actor-cpp - An implementation of the actor model for C++ - Google Project Hosting |access-date=2012-12-02}}</ref> |
| 2012-03-10<ref>{{cite web |url=https://code.google.com/p/actor-cpp/source/list |title=Changes - actor-cpp - An implementation of the actor model for C++ - Google Project Hosting |access-date=2012-12-02 |archive-date=2015-11-18 |archive-url=https://web.archive.org/web/20151118010906/http://code.google.com/p/actor-cpp/source/list |url-status=live }}</ref> |
||
| [[GPL|GPL 2.0]] |
| [[GPL|GPL 2.0]] |
||
| C++ |
| C++ |
||
Line 547: | Line 579: | ||
| [http://actor-framework.org/ C++ Actor Framework (CAF)] |
| [http://actor-framework.org/ C++ Actor Framework (CAF)] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2020-02-08<ref>{{cite web|url=https://github.com/actor-framework/actor-framework/releases |title=Releases · actor-framework/actor-framework · GitHub |publisher=Github.com |access-date=2020-03-07}}</ref> |
| 2020-02-08<ref>{{cite web |url=https://github.com/actor-framework/actor-framework/releases |title=Releases · actor-framework/actor-framework · GitHub |publisher=Github.com |access-date=2020-03-07 |archive-date=2021-03-26 |archive-url=https://web.archive.org/web/20210326101904/https://github.com/actor-framework/actor-framework/releases |url-status=live }}</ref> |
||
| [[Boost Software License|Boost Software License 1.0]] and [[BSD licenses|BSD 3-Clause]] |
| [[Boost Software License|Boost Software License 1.0]] and [[BSD licenses|BSD 3-Clause]] |
||
| C++11 |
| C++11 |
||
Line 553: | Line 585: | ||
| [https://github.com/celluloid/celluloid/ Celluloid] |
| [https://github.com/celluloid/celluloid/ Celluloid] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2018-12-20<ref>{{cite web|url=http://rubygems.org/gems/celluloid |title=celluloid | RubyGems.org | your community gem host |publisher=RubyGems.org |access-date=2019-06-03}}</ref> |
| 2018-12-20<ref>{{cite web |url=http://rubygems.org/gems/celluloid |title=celluloid | RubyGems.org | your community gem host |publisher=RubyGems.org |access-date=2019-06-03 |archive-date=2020-09-29 |archive-url=https://web.archive.org/web/20200929070522/https://rubygems.org/gems/celluloid |url-status=live }}</ref> |
||
| [[MIT License|MIT]] |
| [[MIT License|MIT]] |
||
| Ruby |
| Ruby |
||
Line 559: | Line 591: | ||
| [http://ni.com/actorframework LabVIEW Actor Framework] |
| [http://ni.com/actorframework LabVIEW Actor Framework] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2012-03-01<ref>{{cite web|url=https://decibel.ni.com/content/docs/DOC-18308 |title=Community: Actor Framework, LV 2011 revision (version 3.0.7) |publisher=Decibel.ni.com |date= |
| 2012-03-01<ref>{{cite web |url=https://decibel.ni.com/content/docs/DOC-18308 |title=Community: Actor Framework, LV 2011 revision (version 3.0.7) |publisher=Decibel.ni.com |date=2011-09-23 |access-date=2016-02-25 |archive-date=2016-10-13 |archive-url=https://web.archive.org/web/20161013085507/https://decibel.ni.com/content/docs/DOC-18308 |url-status=live }}</ref> |
||
| [http://www.ni.com/legal/license/ National Instruments SLA] |
| [http://www.ni.com/legal/license/ National Instruments SLA] |
||
| LabVIEW |
| LabVIEW |
||
Line 577: | Line 609: | ||
| [[QP (framework)|QP frameworks for real-time embedded systems]] |
| [[QP (framework)|QP frameworks for real-time embedded systems]] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2019-05-25<ref>{{cite web|url=https://sourceforge.net/projects/qpc/files/ |title=QP Real-Time Embedded Frameworks & Tools - Browse Files at |publisher=Sourceforge.net |access-date=2019-06-03}}</ref> |
| 2019-05-25<ref>{{cite web |url=https://sourceforge.net/projects/qpc/files/ |title=QP Real-Time Embedded Frameworks & Tools - Browse Files at |publisher=Sourceforge.net |access-date=2019-06-03 |archive-date=2021-02-24 |archive-url=https://web.archive.org/web/20210224154900/https://sourceforge.net/projects/qpc/files/ |url-status=live }}</ref> |
||
| [[GPL|GPL 2.0]] and commercial (dual licensing) |
| [[GPL|GPL 2.0]] and commercial (dual licensing) |
||
| C and C++ |
| C and C++ |
||
Line 587: | Line 619: | ||
| C++ |
| C++ |
||
|- |
|- |
||
| [https://bitbucket.org/sobjectizerteam/sobjectizer/ SObjectizer] |
| [https://bitbucket.org/sobjectizerteam/sobjectizer/ SObjectizer] {{Webarchive|url=https://web.archive.org/web/20200810185432/https://bitbucket.org/sobjectizerteam/sobjectizer/ |date=2020-08-10 }} |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2021-12-28<ref>{{cite web|url=https://github.com/Stiffstream/sobjectizer/releases |title=Releases · Stiffstream/sobjectizer · GitHub|publisher=GitHub |access-date=2022-05-11}}</ref> |
| 2021-12-28<ref>{{cite web |url=https://github.com/Stiffstream/sobjectizer/releases |title=Releases · Stiffstream/sobjectizer · GitHub |publisher=GitHub |access-date=2022-05-11 |archive-date=2020-10-19 |archive-url=https://web.archive.org/web/20201019174839/https://github.com/Stiffstream/sobjectizer/releases |url-status=live }}</ref> |
||
| [[BSD License|New BSD]] |
| [[BSD License|New BSD]] |
||
| C++17 |
| C++17 |
||
Line 595: | Line 627: | ||
| [https://github.com/basiliscos/cpp-rotor rotor] |
| [https://github.com/basiliscos/cpp-rotor rotor] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2022-04-23<ref>{{cite web|url=https://github.com/basiliscos/cpp-rotor/releases |title=Releases · basiliscos/cpp-rotor· GitHub|publisher=GitHub |access-date=2022-05-17}}</ref> |
| 2022-04-23<ref>{{cite web |url=https://github.com/basiliscos/cpp-rotor/releases |title=Releases · basiliscos/cpp-rotor· GitHub |publisher=GitHub |access-date=2022-05-17 |archive-date=2020-09-15 |archive-url=https://web.archive.org/web/20200915224347/https://github.com/basiliscos/cpp-rotor/releases |url-status=live }}</ref> |
||
| [[MIT License]] |
| [[MIT License]] |
||
| C++17 |
| C++17 |
||
Line 601: | Line 633: | ||
| [https://dotnet.github.io/orleans/ Orleans] |
| [https://dotnet.github.io/orleans/ Orleans] |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| |
| 2023-07-11<ref>{{cite web |url=https://github.com/dotnet/orleans/releases |title=Releases · dotnet/orleans · GitHub |publisher=GitHub |access-date=2022-09-21 |archive-date=2020-12-04 |archive-url=https://web.archive.org/web/20201204021228/https://github.com/dotnet/orleans/releases |url-status=live }}</ref> |
||
| [[MIT License]] |
| [[MIT License]] |
||
| C#/.NET |
| C#/.NET |
||
Line 627: | Line 659: | ||
| 2021-01-05 |
| 2021-01-05 |
||
| [[Free software license]] |
| [[Free software license]] |
||
| Go, C#, Python, JavaScript |
| Go, C#, Python, JavaScript, Kotlin |
||
|- |
|- |
||
| [https://www.functionaljava.org/ FunctionalJava] |
| [https://www.functionaljava.org/ FunctionalJava] {{Webarchive|url=https://web.archive.org/web/20210422085450/https://www.functionaljava.org/ |date=2021-04-22 }} |
||
| {{Active|style=font-size:smaller}} |
| {{Active|style=font-size:smaller}} |
||
| 2018-08-18<ref>{{cite web|url=https://github.com/functionaljava/functionaljava/releases |title=FunctionalJava releases |publisher=GitHub |access-date=2018-08-23}}</ref> |
| 2018-08-18<ref>{{cite web |url=https://github.com/functionaljava/functionaljava/releases |title=FunctionalJava releases |publisher=GitHub |access-date=2018-08-23 |archive-date=2021-01-15 |archive-url=https://web.archive.org/web/20210115210742/https://github.com/functionaljava/functionaljava/releases |url-status=live }}</ref> |
||
| [[BSD licenses|BSD 3-Clause]] |
| [[BSD licenses|BSD 3-Clause]] |
||
| Java |
| Java |
||
Line 649: | Line 681: | ||
|[https://github.com/vlingo/vlingo-actors VLINGO XOOM Actors] |
|[https://github.com/vlingo/vlingo-actors VLINGO XOOM Actors] |
||
|{{Active|style=font-size:smaller}} |
|{{Active|style=font-size:smaller}} |
||
| |
|2023-02-15 |
||
|[[Mozilla Public License|Mozilla Public License 2.0]] |
|[[Mozilla Public License|Mozilla Public License 2.0]] |
||
|Java, Kotlin, JVM languages, C# .NET |
|Java, Kotlin, JVM languages, C# .NET |
||
Line 670: | Line 702: | ||
|[[New BSD License]] |
|[[New BSD License]] |
||
|Python |
|Python |
||
|- |
|||
|[https://github.com/vladopajic/go-actor go-actor] |
|||
|{{Active|style=font-size:smaller}} |
|||
|2022-08-16 |
|||
|[[GPL 3.0]] |
|||
|Go |
|||
|- |
|||
|[https://github.com/mdbergmann/cl-gserver Sento] |
|||
|{{Active|style=font-size:smaller}} |
|||
|2022-11-21 |
|||
|[[Apache 2.0]] |
|||
|Common Lisp |
|||
|- |
|||
|[https://github.com/tarantx Tarant] |
|||
|{{Active|style=font-size:smaller}} |
|||
|2023-04-17 |
|||
|[[MIT License|MIT]] |
|||
|Typescript, Javascript |
|||
|} |
|} |
||
==See also== |
==See also== |
||
*[[Autonomous agent]] |
|||
* [[Data flow]] |
* [[Data flow]] |
||
* [[Gordon Pask]] |
* [[Gordon Pask]] |
||
Line 679: | Line 730: | ||
==References== |
==References== |
||
{{Reflist |
{{Reflist}} |
||
==Further reading== |
==Further reading== |
||
Line 685: | Line 736: | ||
*Gul Agha. '''[https://apps.dtic.mil/dtic/tr/fulltext/u2/a157917.pdf Actors: A Model of Concurrent Computation in Distributed Systems] {{Webarchive|url=https://web.archive.org/web/20201112004342/https://apps.dtic.mil/dtic/tr/fulltext/u2/a157917.pdf |date=2020-11-12 }}'''. MIT Press 1985. |
*Gul Agha. '''[https://apps.dtic.mil/dtic/tr/fulltext/u2/a157917.pdf Actors: A Model of Concurrent Computation in Distributed Systems] {{Webarchive|url=https://web.archive.org/web/20201112004342/https://apps.dtic.mil/dtic/tr/fulltext/u2/a157917.pdf |date=2020-11-12 }}'''. MIT Press 1985. |
||
*Paul Baran. '''On Distributed Communications Networks''' [[IEEE Transactions on Communications Systems]]. March 1964. |
*Paul Baran. '''On Distributed Communications Networks''' [[IEEE Transactions on Communications Systems]]. March 1964. |
||
*William A. Woods. '''[http://files.eric.ed.gov/fulltext/ED037733.pdf Transition network grammars for natural language analysis]''' CACM. 1970. |
*William A. Woods. '''[http://files.eric.ed.gov/fulltext/ED037733.pdf Transition network grammars for natural language analysis] {{Webarchive|url=https://web.archive.org/web/20170203134542/http://files.eric.ed.gov/fulltext/ED037733.pdf |date=2017-02-03 }}''' CACM. 1970. |
||
*Carl Hewitt. '''[https://www.ijcai.org/Proceedings/71/Papers/014%20A.pdf Procedural Embedding of Knowledge In Planner]''' IJCAI 1971. |
*Carl Hewitt. '''[https://www.ijcai.org/Proceedings/71/Papers/014%20A.pdf Procedural Embedding of Knowledge In Planner] {{Webarchive|url=https://web.archive.org/web/20210205001847/https://www.ijcai.org/Proceedings/71/Papers/014%20A.pdf |date=2021-02-05 }}''' IJCAI 1971. |
||
*G.M. Birtwistle, [[Ole-Johan Dahl]], B. Myhrhaug and [[Kristen Nygaard]]. '''SIMULA Begin''' Auerbach Publishers Inc, 1973. |
*G.M. Birtwistle, [[Ole-Johan Dahl]], B. Myhrhaug and [[Kristen Nygaard]]. '''SIMULA Begin''' Auerbach Publishers Inc, 1973. |
||
*Carl Hewitt, ''et al.'' '''[ |
*Carl Hewitt, ''et al.'' '''[https://dl.acm.org/doi/10.1145/512927.512942 Actor Induction and Meta-evaluation] {{Webarchive|url=https://web.archive.org/web/20221115060306/https://dl.acm.org/doi/10.1145/512927.512942 |date=2022-11-15 }}''' Conference Record of ACM Symposium on Principles of Programming Languages, January 1974. |
||
*Carl Hewitt, ''et https://link.springer.com/chapter/10.1007/3-540-06859- |
*Carl Hewitt, ''et al '''[https://link.springer.com/chapter/10.1007/3-540-06859-7_147 Behavioral Semantics of Nonrecursive Control Structure] {{Webarchive|url=https://web.archive.org/web/20180610081217/https://link.springer.com/chapter/10.1007/3-540-06859-7_147 |date=2018-06-10 }}''' Proceedings of Colloque sur la Programmation, April 1974. |
||
*Irene Greif and Carl Hewitt. '''[https://dspace.mit.edu/bitstream/handle/1721.1/41116/AI_WP_081.pdf?sequence=4&origin=publication_detail Actor Semantics of PLANNER-73]''' Conference Record of ACM Symposium on Principles of Programming Languages. January 1975. |
*Irene Greif and Carl Hewitt. '''[https://dspace.mit.edu/bitstream/handle/1721.1/41116/AI_WP_081.pdf?sequence=4&origin=publication_detail Actor Semantics of PLANNER-73] {{Webarchive|url=https://web.archive.org/web/20210205120636/https://dspace.mit.edu/bitstream/handle/1721.1/41116/AI_WP_081.pdf?sequence=4&origin=publication_detail |date=2021-02-05 }}''' Conference Record of ACM Symposium on Principles of Programming Languages. January 1975. |
||
*Carl Hewitt. '''[https://web.archive.org/web/20190307161903/http://pdfs.semanticscholar.org/fc65/4c70dece00b1e4bbb63453c6ff2c81c0893a.pdf How to Use What You Know]''' IJCAI. September, 1975. |
*Carl Hewitt. '''[https://web.archive.org/web/20190307161903/http://pdfs.semanticscholar.org/fc65/4c70dece00b1e4bbb63453c6ff2c81c0893a.pdf How to Use What You Know]''' IJCAI. September, 1975. |
||
*Alan Kay and Adele Goldberg. [ |
*Alan Kay and Adele Goldberg. [https://archive.org/details/TN_Smalltalk-72_Instruction_Manual_-_Xerox_1976_20171030_0631/page/n3/mode/2up '''Smalltalk-72 Instruction Manual'''] Xerox PARC Memo SSL-76-6. May 1976. |
||
*[[Edsger Dijkstra]]. '''A discipline of programming''' Prentice Hall. 1976. |
*[[Edsger Dijkstra]]. '''A discipline of programming''' Prentice Hall. 1976. |
||
*Carl Hewitt and Henry Baker '''[https://web.archive.org/web/20060919015756/http://www.lcs.mit.edu/publications/pubs/pdf/MIT-LCS-TR-194.pdf Actors and Continuous Functionals]''' Proceeding of IFIP Working Conference on Formal Description of Programming Concepts. August 1–5, 1977. |
*Carl Hewitt and Henry Baker '''[https://web.archive.org/web/20060919015756/http://www.lcs.mit.edu/publications/pubs/pdf/MIT-LCS-TR-194.pdf Actors and Continuous Functionals]''' Proceeding of IFIP Working Conference on Formal Description of Programming Concepts. August 1–5, 1977. |
||
*Carl Hewitt and Russ Atkinson. '''[http://portal.acm.org/citation.cfm?id=512975&coll=portal&dl=ACM Synchronization in Actor Systems]''' Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages. 1977 |
*Carl Hewitt and Russ Atkinson. '''[http://portal.acm.org/citation.cfm?id=512975&coll=portal&dl=ACM Synchronization in Actor Systems]''' Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages. 1977 |
||
*Carl Hewitt and Russ Atkinson. '''[https://web.archive.org/web/20170831085117/https://pdfs.semanticscholar.org/bd25/d3a1ed23c79ff09bccf91ce9affd3b399ebe.pdf Specification and Proof Techniques for Serializers]''' IEEE Journal on Software Engineering. January 1979. |
*Carl Hewitt and Russ Atkinson. '''[https://web.archive.org/web/20170831085117/https://pdfs.semanticscholar.org/bd25/d3a1ed23c79ff09bccf91ce9affd3b399ebe.pdf Specification and Proof Techniques for Serializers]''' IEEE Journal on Software Engineering. January 1979. |
||
*Ken Kahn. '''[https://dspace.mit.edu/bitstream/handle/1721.1/41979/AI_WP_145.pdf?sequence=1 A Computational Theory of Animation]''' MIT EECS Doctoral Dissertation. August 1979. |
*Ken Kahn. '''[https://dspace.mit.edu/bitstream/handle/1721.1/41979/AI_WP_145.pdf?sequence=1 A Computational Theory of Animation] {{Webarchive|url=https://web.archive.org/web/20170818200257/https://dspace.mit.edu/bitstream/handle/1721.1/41979/AI_WP_145.pdf?sequence=1 |date=2017-08-18 }}''' 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. |
*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 nondeterminism, concurrency, and communication''' Journal of Computer and System Sciences. December 1979. |
*[[Nissim Francez]], C.A.R. Hoare, Daniel Lehmann, and [[Willem-Paul de Roever]]. '''Semantics of nondeterminism, concurrency, and communication''' Journal of Computer and System Sciences. December 1979. |
||
Line 706: | Line 757: | ||
*Carl Hewitt and Peter de Jong. '''[https://web.archive.org/web/20170714021055/http://www.dtic.mil/get-tr-doc/pdf?AD=ADA133614 Analyzing the Roles of Descriptions and Actions in Open Systems]''' Proceedings of the National Conference on Artificial Intelligence. August 1983. |
*Carl Hewitt and Peter de Jong. '''[https://web.archive.org/web/20170714021055/http://www.dtic.mil/get-tr-doc/pdf?AD=ADA133614 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. |
*Carl Hewitt and Henry Lieberman. '''Design Issues in Parallel Architecture for Artificial Intelligence''' MIT AI memo 750. Nov. 1983. |
||
*[[C.A.R. Hoare]]. '''[http://www.usingcsp.com/ Communicating Sequential Processes]''' Prentice Hall. 1985. |
*[[C.A.R. Hoare]]. '''[http://www.usingcsp.com/ Communicating Sequential Processes] {{Webarchive|url=https://web.archive.org/web/20210201151713/http://usingcsp.com/ |date=2021-02-01 }}''' Prentice Hall. 1985. |
||
*Carl Hewitt. '''The Challenge of Open Systems''' Byte. April 1985. Reprinted in ''The foundation of artificial intelligence: a sourcebook'' Cambridge University Press. 1990. |
*Carl Hewitt. '''The Challenge of Open Systems''' Byte. April 1985. Reprinted in ''The foundation of artificial intelligence: a sourcebook'' Cambridge University Press. 1990. |
||
*Carl Manning. '''Traveler: the actor observatory''' ECOOP 1987. Also appears in [[Lecture Notes in Computer Science]], vol. 276. |
*Carl Manning. '''Traveler: the actor observatory''' ECOOP 1987. Also appears in [[Lecture Notes in Computer Science]], vol. 276. |
||
*William Athas and Charles Seitz '''[https://ieeexplore.ieee.org/abstract/document/73/ Multicomputers: message-passing concurrent computers]''' IEEE Computer August 1988. |
*William Athas and Charles Seitz '''[https://ieeexplore.ieee.org/abstract/document/73/ Multicomputers: message-passing concurrent computers] {{Webarchive|url=https://web.archive.org/web/20210205000300/https://ieeexplore.ieee.org/abstract/document/73/ |date=2021-02-05 }}''' 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. |
*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. '''[https://www.researchgate.net/profile/Jean-Pierre_Briot/publication/234812358_From_objects_to_Actors_Study_of_a_limited_symbiosis_in_Smalltalk-80/links/0c96053bd5ac8322b6000000.pdf From objects to actors: Study of a limited symbiosis in Smalltalk-80]''' Rapport de Recherche 88–58, RXF-LITP, Paris, France, September 1988 |
*Jean-Pierre Briot. '''[https://www.researchgate.net/profile/Jean-Pierre_Briot/publication/234812358_From_objects_to_Actors_Study_of_a_limited_symbiosis_in_Smalltalk-80/links/0c96053bd5ac8322b6000000.pdf From objects to actors: Study of a limited symbiosis in Smalltalk-80] {{Webarchive|url=https://web.archive.org/web/20201125071501/https://www.researchgate.net/profile/Jean-Pierre_Briot/publication/234812358_From_objects_to_Actors_Study_of_a_limited_symbiosis_in_Smalltalk-80/links/0c96053bd5ac8322b6000000.pdf |date=2020-11-25 }}''' Rapport de Recherche 88–58, RXF-LITP, Paris, France, September 1988 |
||
*William Dally and Wills, D. '''[https://link.springer.com/chapter/10.1007/3540512845_30 Universal mechanisms for concurrency]''' PARLE 1989. |
*William Dally and Wills, D. '''[https://link.springer.com/chapter/10.1007/3540512845_30 Universal mechanisms for concurrency] {{Webarchive|url=https://web.archive.org/web/20180618003814/https://link.springer.com/chapter/10.1007/3540512845_30 |date=2018-06-18 }}''' PARLE 1989. |
||
*W. Horwat, A. Chien, and W. Dally. '''[ |
*W. Horwat, A. Chien, and W. Dally. '''[https://apps.dtic.mil/sti/pdfs/ADA211882.pdf Experience with CST: Programming and Implementation] {{Webarchive|url=https://web.archive.org/web/20210514080722/https://apps.dtic.mil/sti/pdfs/ADA211882.pdf |date=2021-05-14 }}}''' PLDI. 1989. |
||
*Carl Hewitt. '''Towards Open Information Systems Semantics''' Proceedings of 10th International Workshop on Distributed Artificial Intelligence. October 23–27, 1990. Bandera, Texas. |
*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. |
*Akinori Yonezawa, Ed. '''ABCL: An Object-Oriented Concurrent System''' MIT Press. 1990. |
||
Line 720: | Line 771: | ||
*Carl Hewitt and Jeff Inman. '''[https://web.archive.org/web/20170831090048/https://pdfs.semanticscholar.org/7840/bbf6b2fceb014cd3e8eeb2bd81529c7b36b5.pdf DAI Betwixt and Between: From "Intelligent Agents" to Open Systems Science]''' IEEE Transactions on Systems, Man, and Cybernetics. Nov./Dec. 1991. |
*Carl Hewitt and Jeff Inman. '''[https://web.archive.org/web/20170831090048/https://pdfs.semanticscholar.org/7840/bbf6b2fceb014cd3e8eeb2bd81529c7b36b5.pdf DAI Betwixt and Between: From "Intelligent Agents" to Open Systems Science]''' IEEE Transactions on Systems, Man, and Cybernetics. Nov./Dec. 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 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. |
||
*William Dally, ''et al.'' '''[https://ieeexplore.ieee.org/abstract/document/127581/ The Message-Driven Processor: A Multicomputer Processing Node with Efficient Mechanisms]''' [[IEEE Micro]]. April 1992. |
*William Dally, ''et al.'' '''[https://ieeexplore.ieee.org/abstract/document/127581/ The Message-Driven Processor: A Multicomputer Processing Node with Efficient Mechanisms] {{Webarchive|url=https://web.archive.org/web/20210205001037/https://ieeexplore.ieee.org/abstract/document/127581/ |date=2021-02-05 }}''' [[IEEE Micro]]. April 1992. |
||
*S. Miriyala, G. Agha, and Y.Sami. '''[http://osl.cs.illinois.edu/media/papers/miriyala-1992-vlc-visualizing_actor_programs_using_predicate_transition_nets.pdf Visualizing actor programs using predicate transition nets]''' Journal of Visual Programming. 1992. |
*S. Miriyala, G. Agha, and Y.Sami. '''[http://osl.cs.illinois.edu/media/papers/miriyala-1992-vlc-visualizing_actor_programs_using_predicate_transition_nets.pdf Visualizing actor programs using predicate transition nets] {{Webarchive|url=https://web.archive.org/web/20201110134840/http://osl.cs.illinois.edu/media/papers/miriyala-1992-vlc-visualizing_actor_programs_using_predicate_transition_nets.pdf |date=2020-11-10 }}''' Journal of Visual Programming. 1992. |
||
*Carl Hewitt and Carl Manning. '''[https://web.archive.org/web/20170831125720/https://vvvvw.aaai.org/Papers/Workshops/1994/WS-94-04/WS94-04-008.pdf Negotiation Architecture for Large-Scale Crisis Management]''' AAAI-94 Workshop on Models of Conflict Management in Cooperative Problem Solving. Seattle, WA. Aug. 4, 1994. |
*Carl Hewitt and Carl Manning. '''[https://web.archive.org/web/20170831125720/https://vvvvw.aaai.org/Papers/Workshops/1994/WS-94-04/WS94-04-008.pdf Negotiation Architecture for Large-Scale Crisis Management]''' AAAI-94 Workshop on Models of Conflict Management in Cooperative Problem Solving. Seattle, WA. Aug. 4, 1994. |
||
*Carl Hewitt and Carl Manning. '''Synthetic Infrastructures for Multi-Agency Systems''' Proceedings of ICMAS '96. Kyoto, Japan. December 8–13, 1996. |
*Carl Hewitt and Carl Manning. '''Synthetic Infrastructures for Multi-Agency Systems''' Proceedings of ICMAS '96. Kyoto, Japan. December 8–13, 1996. |
||
*S. Frolund. '''Coordinating Distributed Objects: An Actor-Based Approach for Synchronization''' MIT Press. November 1996. |
*S. Frolund. '''Coordinating Distributed Objects: An Actor-Based Approach for Synchronization''' MIT Press. November 1996. |
||
*W. Kim. '''[https://www.researchgate.net/profile/Wooyoung_Kim2/publication/2308617_Thal_An_Actor_System_For_Efficient_And_Scalable_Concurrent_Computing/links/02e7e517614e73041a000000.pdf ThAL: An Actor System for Efficient and Scalable Concurrent Computing]''' PhD thesis. University of Illinois at Urbana Champaign. 1997. |
*W. Kim. '''[https://www.researchgate.net/profile/Wooyoung_Kim2/publication/2308617_Thal_An_Actor_System_For_Efficient_And_Scalable_Concurrent_Computing/links/02e7e517614e73041a000000.pdf ThAL: An Actor System for Efficient and Scalable Concurrent Computing] {{Webarchive|url=https://web.archive.org/web/20170831085055/https://www.researchgate.net/profile/Wooyoung_Kim2/publication/2308617_Thal_An_Actor_System_For_Efficient_And_Scalable_Concurrent_Computing/links/02e7e517614e73041a000000.pdf |date=2017-08-31 }}''' PhD thesis. University of Illinois at Urbana Champaign. 1997. |
||
*Jean-Pierre Briot. [https://web.archive.org/web/20030427222407/http://www.ifs.uni-linz.ac.at/~ecoop/cd/papers/ec89/ec890109.pdf '''Acttalk: A framework for object-oriented concurrent programming-design and experience'''] 2nd France-Japan workshop. 1999. |
*Jean-Pierre Briot. [https://web.archive.org/web/20030427222407/http://www.ifs.uni-linz.ac.at/~ecoop/cd/papers/ec89/ec890109.pdf '''Acttalk: A framework for object-oriented concurrent programming-design and experience'''] 2nd France-Japan workshop. 1999. |
||
*N. Jamali, P. Thati, and G. Agha. '''[https://www.researchgate.net/profile/Gul_Agha/publication/3420461_An_Actor-Based_Architecture_for_Customizing_and_Controlling_Agent_Ensembles/links/55aeb2ed08aed9b7dcdda586.pdf An actor based architecture for customizing and controlling agent ensembles]''' IEEE Intelligent Systems. 14(2). 1999. |
*N. Jamali, P. Thati, and G. Agha. '''[https://www.researchgate.net/profile/Gul_Agha/publication/3420461_An_Actor-Based_Architecture_for_Customizing_and_Controlling_Agent_Ensembles/links/55aeb2ed08aed9b7dcdda586.pdf An actor based architecture for customizing and controlling agent ensembles] {{Webarchive|url=https://web.archive.org/web/20201125071501/https://www.researchgate.net/profile/Gul_Agha/publication/3420461_An_Actor-Based_Architecture_for_Customizing_and_Controlling_Agent_Ensembles/links/55aeb2ed08aed9b7dcdda586.pdf |date=2020-11-25 }}''' IEEE Intelligent Systems. 14(2). 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. |
*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. |
||
*M. Astley, D. Sturman, and G. Agha. '''[http://osl.cs.illinois.edu/media/papers/astley-2001-cacm-customizable_middleware_for_modular_distributed_software.pdf Customizable middleware for modular distributed software]''' CACM. 44(5) 2001. |
*M. Astley, D. Sturman, and G. Agha. '''[http://osl.cs.illinois.edu/media/papers/astley-2001-cacm-customizable_middleware_for_modular_distributed_software.pdf Customizable middleware for modular distributed software] {{Webarchive|url=https://web.archive.org/web/20170831083740/http://osl.cs.illinois.edu/media/papers/astley-2001-cacm-customizable_middleware_for_modular_distributed_software.pdf |date=2017-08-31 }}''' CACM. 44(5) 2001. |
||
*Edward Lee, S. Neuendorffer, and M. Wirthlin. [http://ptolemy.eecs.berkeley.edu/papers/02/actorOrientedDesign/newFinal.pdf '''Actor-oriented design of embedded hardware and software systems'''] ''[[Journal of Circuits, Systems, and Computers]]''. 2002. |
*Edward Lee, S. Neuendorffer, and M. Wirthlin. [http://ptolemy.eecs.berkeley.edu/papers/02/actorOrientedDesign/newFinal.pdf '''Actor-oriented design of embedded hardware and software systems'''] {{Webarchive|url=https://web.archive.org/web/20161020063715/http://ptolemy.eecs.berkeley.edu/papers/02/actorOrientedDesign/newFinal.pdf |date=2016-10-20 }} ''[[Journal of Circuits, Systems, and Computers]]''. 2002. |
||
*P. Thati, R. Ziaei, and G. Agha. '''A Theory of May Testing for Actors''' Formal Methods for Open Object-based Distributed Systems. March 2002. |
*P. Thati, R. Ziaei, and G. Agha. '''A Theory of May Testing for Actors''' Formal Methods for Open Object-based Distributed Systems. March 2002. |
||
*P. Thati, R. Ziaei, and G. Agha. '''A theory of may testing for asynchronous calculi with locality and no name matching''' Algebraic Methodology and Software Technology. Springer Verlag. September 2002. LNCS 2422. |
*P. Thati, R. Ziaei, and G. Agha. '''A theory of may testing for asynchronous calculi with locality and no name matching''' Algebraic Methodology and Software Technology. Springer Verlag. September 2002. LNCS 2422. |
||
*Stephen Neuendorffer. [http://www.eecs.berkeley.edu/Pubs/TechRpts/2005/ERL-05-1.pdf '''Actor-Oriented Metaprogramming'''] PhD Thesis. University of California, Berkeley. December, 2004 |
*Stephen Neuendorffer. [http://www.eecs.berkeley.edu/Pubs/TechRpts/2005/ERL-05-1.pdf '''Actor-Oriented Metaprogramming'''] {{Webarchive|url=https://web.archive.org/web/20200925073835/http://www.eecs.berkeley.edu/Pubs/TechRpts/2005/ERL-05-1.pdf |date=2020-09-25 }} PhD Thesis. University of California, Berkeley. December, 2004 |
||
*Carl Hewitt (2006a) '''[https://web.archive.org/web/20171210124010/https://vvvvw.aaai.org/Papers/Symposia/Spring/2006/SS-06-08/SS06-08-003.pdf The repeated demise of logic programming and why it will be reincarnated]''' What Went Wrong and Why: Lessons from AI Research and Applications. Technical Report SS-06-08. AAAI Press. March 2006. |
*Carl Hewitt (2006a) '''[https://web.archive.org/web/20171210124010/https://vvvvw.aaai.org/Papers/Symposia/Spring/2006/SS-06-08/SS06-08-003.pdf The repeated demise of logic programming and why it will be reincarnated]''' What Went Wrong and Why: Lessons from AI Research and Applications. Technical Report SS-06-08. AAAI Press. March 2006. |
||
*Carl Hewitt (2006b) [http://www.pcs.usp.br/~coin-aamas06/10_commitment-43_16pages.pdf ''What is Commitment? Physical, Organizational, and Social''] COIN@AAMAS. April 27, 2006b. |
*Carl Hewitt (2006b) [http://www.pcs.usp.br/~coin-aamas06/10_commitment-43_16pages.pdf ''What is Commitment? Physical, Organizational, and Social''] {{Webarchive|url=https://web.archive.org/web/20210211011938/http://www2.pcs.usp.br/~coin-aamas06/10_commitment-43_16pages.pdf |date=2021-02-11 }} COIN@AAMAS. April 27, 2006b. |
||
*Carl Hewitt (2007a) '''What is Commitment? Physical, Organizational, and Social (Revised)''' Pablo Noriega .et al. editors. LNAI 4386. Springer-Verlag. 2007. |
*Carl Hewitt (2007a) '''What is Commitment? Physical, Organizational, and Social (Revised)''' Pablo Noriega .et al. editors. LNAI 4386. Springer-Verlag. 2007. |
||
*Carl Hewitt (2007b) '''[https://www.researchgate.net/profile/Bob_Wielinga/publication/221456241_Towards_a_Framework_for_Agent_Coordination_and_Reorganization_AgentCoRe/links/0fcfd508a9cd76ca47000000.pdf#page=105 Large-scale Organizational Computing requires Unstratified Paraconsistency and Reflection]''' COIN@AAMAS'07. |
*Carl Hewitt (2007b) '''[https://www.researchgate.net/profile/Bob_Wielinga/publication/221456241_Towards_a_Framework_for_Agent_Coordination_and_Reorganization_AgentCoRe/links/0fcfd508a9cd76ca47000000.pdf#page=105 Large-scale Organizational Computing requires Unstratified Paraconsistency and Reflection] {{Webarchive|url=https://web.archive.org/web/20201125071524/https://www.researchgate.net/profile/Bob_Wielinga/publication/221456241_Towards_a_Framework_for_Agent_Coordination_and_Reorganization_AgentCoRe/links/0fcfd508a9cd76ca47000000.pdf#page=105 |date=2020-11-25 }}''' COIN@AAMAS'07. |
||
*D. Charousset, T. C. Schmidt, R. Hiesgen and M. Wählisch. [https://dx.doi.org/10.1145/2541329.2541336 ''Native actors: a scalable software platform for distributed, heterogeneous environments''] in AGERE! '13 Proceedings of the 2013 workshop on Programming based on actors, agents, and decentralized control. |
*D. Charousset, T. C. Schmidt, R. Hiesgen and M. Wählisch. [https://dx.doi.org/10.1145/2541329.2541336 ''Native actors: a scalable software platform for distributed, heterogeneous environments''] in AGERE! '13 Proceedings of the 2013 workshop on Programming based on actors, agents, and decentralized control. |
||
{{Refend}} |
{{Refend}} |
||
Line 743: | Line 794: | ||
== External links == |
== External links == |
||
* [http://channel9.msdn.com/Shows/Going+Deep/Hewitt-Meijer-and-Szyperski-The-Actor-Model-everything-you-wanted-to-know-but-were-afraid-to-ask Hewitt, Meijer and Szyperski: The Actor Model (everything you wanted to know, but were afraid to ask)] Microsoft Channel 9. April 9, 2012. {{YouTube |id=7erJ1DV_Tlo}} |
* [http://channel9.msdn.com/Shows/Going+Deep/Hewitt-Meijer-and-Szyperski-The-Actor-Model-everything-you-wanted-to-know-but-were-afraid-to-ask Hewitt, Meijer and Szyperski: The Actor Model (everything you wanted to know, but were afraid to ask)] Microsoft Channel 9. April 9, 2012. {{YouTube |id=7erJ1DV_Tlo}} |
||
* [http://functionaljava.org/ Functional Java] – a Java library that includes an implementation of concurrent actors with code examples in standard Java and Java 7 BGGA style. |
* [http://functionaljava.org/ Functional Java] {{Webarchive|url=https://web.archive.org/web/20110709025649/http://functionaljava.org/ |date=2011-07-09 }} – a Java library that includes an implementation of concurrent actors with code examples in standard Java and Java 7 BGGA style. |
||
* [https://web.archive.org/web/20090124154231/http://osl.cs.uiuc.edu/af/ ActorFoundry] – a Java-based library for actor programming. The familiar Java syntax, an ant build file and a bunch of example make the entry barrier very low. |
* [https://web.archive.org/web/20090124154231/http://osl.cs.uiuc.edu/af/ ActorFoundry] – a Java-based library for actor programming. The familiar Java syntax, an ant build file and a bunch of example make the entry barrier very low. |
||
* [http://tristan.aubrey-jones.com/code/?project=third_year_project&dir=/ ActiveJava] – a prototype Java language extension for actor programming. |
* [http://tristan.aubrey-jones.com/code/?project=third_year_project&dir=/ ActiveJava] – a prototype Java language extension for actor programming. |
||
Line 750: | Line 801: | ||
* [http://msdn.microsoft.com/en-us/library/dd492627.aspx Asynchronous Agents Library] – Microsoft actor library for Visual C++. "The Agents Library is a C++ template library that promotes an actor-based programming model and in-process message passing for coarse-grained dataflow and pipelining tasks. " |
* [http://msdn.microsoft.com/en-us/library/dd492627.aspx Asynchronous Agents Library] – Microsoft actor library for Visual C++. "The Agents Library is a C++ template library that promotes an actor-based programming model and in-process message passing for coarse-grained dataflow and pipelining tasks. " |
||
* [https://github.com/lightful/syscpp/ ActorThread in C++11] – base template providing the gist of the actor model over naked threads in standard C++11 |
* [https://github.com/lightful/syscpp/ ActorThread in C++11] – base template providing the gist of the actor model over naked threads in standard C++11 |
||
{{Programming paradigms navbox}} |
|||
[[Category:Actor model (computer science)| ]] |
[[Category:Actor model (computer science)| ]] |
The actor modelincomputer science is a mathematical modelofconcurrent computation that treats an actor as the basic building block of concurrent computation. In response to a message it receives, an actor can: make local decisions, create more actors, send more messages, and determine how to respond to the next message received. Actors may modify their own private state, but can only affect each other indirectly through messaging (removing the need for lock-based synchronization).
The actor model originated in 1973.[1] It has been used both as a framework for a theoretical understandingofcomputation and as the theoretical basis for several practical implementationsofconcurrent systems. The relationship of the model to other work is discussed in actor model and process calculi.
According to Carl Hewitt, unlike previous models of computation, the actor model was inspired by physics, including general relativity and quantum mechanics.[citation needed] It was also influenced by the programming languages Lisp, Simula, early versions of Smalltalk, capability-based systems, and packet switching. Its development was "motivated by the prospect of highly parallel computing machines consisting of dozens, hundreds, or even thousands of independent microprocessors, each with its own local memory and communications processor, communicating via a high-performance communications network."[2] Since that time, the advent of massive concurrency through multi-core and manycore computer architectures has revived interest in the actor model.
Following Hewitt, Bishop, and Steiger's 1973 publication, Irene Greif developed an operational semantics for the actor model as part of her doctoral research.[3] Two years later, Henry Baker and Hewitt published a set of axiomatic laws for actor systems.[4][5] Other major milestones include William Clinger's 1981 dissertation introducing a denotational semantics based on power domains[2] and Gul Agha's 1985 dissertation which further developed a transition-based semantic model complementary to Clinger's.[6] This resulted in the full development of actor model theory.
Major software implementation work was done by Russ Atkinson, Giuseppe Attardi, Henry Baker, Gerry Barber, Peter Bishop, Peter de Jong, Ken Kahn, Henry Lieberman, Carl Manning, Tom Reinhardt, Richard Steiger and Dan Theriault in the Message Passing Semantics Group at Massachusetts Institute of Technology (MIT). Research groups led by Chuck Seitz at California Institute of Technology (Caltech) and Bill Dally at MIT constructed computer architectures that further developed the message passing in the model. See Actor model implementation.
Research on the actor model has been carried out at California Institute of Technology, Kyoto University Tokoro Laboratory, Microelectronics and Computer Technology Corporation (MCC), MIT Artificial Intelligence Laboratory, SRI, Stanford University, University of Illinois at Urbana–Champaign,[7] Pierre and Marie Curie University (University of Paris 6), University of Pisa, University of Tokyo Yonezawa Laboratory, Centrum Wiskunde & Informatica (CWI) and elsewhere.
The actor model adopts the philosophy that everything is an actor. This is similar to the everything is an object philosophy used by some object-oriented programming languages.
An actor is a computational entity that, in response to a message it receives, can concurrently:
There is no assumed sequence to the above actions and they could be carried out in parallel.
Decoupling the sender from communications sent was a fundamental advance of the actor model enabling asynchronous communication and control structures as patterns of passing messages.[8]
Recipients of messages are identified by address, sometimes called "mailing address". Thus an actor can only communicate with actors whose addresses it has. It can obtain those from a message it receives, or if the address is for an actor it has itself created.
The actor model is characterized by inherent concurrency of computation within and among actors, dynamic creation of actors, inclusion of actor addresses in messages, and interaction only through direct asynchronous message passing with no restriction on message arrival order.
Over the years, several different formal systems have been developed which permit reasoning about systems in the actor model. These include:
There are also formalisms that are not fully faithful to the actor model in that they do not formalize the guaranteed delivery of messages including the following (See Attempts to relate actor semantics to algebra and linear logic):
The actor model can be used as a framework for modeling, understanding, and reasoning about a wide range of concurrent systems.[15] For example:
The actor model is about the semantics of message passing.
Arguably, the first concurrent programs were interrupt handlers. During the course of its normal operation a computer needed to be able to receive information from outside (characters from a keyboard, packets from a network, etc). So when the information arrived the execution of the computer was interrupted and special code (called an interrupt handler) was called to put the information in a data buffer where it could be subsequently retrieved.
In the early 1960s, interrupts began to be used to simulate the concurrent execution of several programs on one processor.[17] Having concurrency 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. Edsger Dijkstra developed semaphores and later, between 1971 and 1973,[18] Tony Hoare[19] and Per Brinch Hansen[20] 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 later accomplished by the serializer construct ([Hewitt and Atkinson 1977, 1979] and [Atkinson 1980]).
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 (later generalized in [McCarthy and Hayes 1969] and [Dijkstra 1976] see Event orderings versus global state). 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.
Edsger Dijkstra further developed the nondeterministic global state approach. Dijkstra's model gave rise to a controversy concerning unbounded nondeterminism (also called unbounded indeterminacy), 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 (electronics)).[21] Arbiters are used in computers to deal with the circumstance that computer clocks operate asynchronously with respect to 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.
The actor model features unbounded nondeterminism which was captured in a mathematical model by Will Clinger using domain theory.[2] In the actor model, there is no global state.[dubious – discuss]
Messages in the actor model are not necessarily buffered. This was a sharp break with previous approaches to models of concurrent computation. The lack of buffering caused a great deal of misunderstanding at the time of the development of the actor model and is still a controversial issue. Some researchers argued that the messages are buffered in the "ether" or the "environment". Also, messages in the actor model are simply sent (like packetsinIP); there is no requirement for a synchronous handshake with the recipient.
A natural development of the actor model was to allow addresses in messages. 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.
For example, an actor might need to send a message to a recipient actor from which it later expects to receive a response, but the response will actually be handled by a third actor component that has been configured to receive and handle the response (for example, a different actor implementing the observer pattern). The original actor could accomplish this by sending a communication that includes the message it wishes to send, along with the address of the third actor that will handle the response. This third actor that will handle the response is called the resumption (sometimes also called a continuationorstack frame). When the recipient actor is ready to send a response, it sends the response message to the resumption actor address that was included in the original communication.
So, the ability of actors to create new actors with which they can exchange communications, along with the ability to include the addresses of other actors in messages, gives actors the ability to create and participate in arbitrarily variable topological relationships with one another, much as the objects in Simula and other object-oriented languages may also be relationally composed into variable topologies of message-exchanging objects.
As opposed to the previous approach based on composing sequential processes, the actor model was developed as an inherently concurrent model. In the actor model sequentiality was a special case that derived from concurrent computation as explained in actor model theory.
This section needs additional citations for verification. Please help improve this articlebyadding citations to reliable sources in this section. Unsourced material may be challenged and removed. (March 2012) (Learn how and when to remove this message)
|
Hewitt argued against adding the requirement that messages must arrive in the order in which they are sent to the actor. 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 later X
sent another message M2
toY
, there is no requirement that M1
arrives at Y
before M2
.
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 more example, actors are allowed to pipeline the processing of messages. What this means is that in the course of processing a message 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.
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, and addresses for actors that it creates while processing the message. (But see Synthesizing addresses of actors.)
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 and placed in other locations.
The idea of composing actor systems into larger ones is an important aspect of modularity that was developed in Gul Agha's doctoral dissertation,[6] developed later by Gul Agha, Ian Mason, Scott Smith, and Carolyn Talcott.[9]
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, the efficient implementation of systems described by the actor model require extensive optimization. See Actor model implementation for details.
Other concurrency systems (e.g., process calculi) can be modeled in the actor model using a two-phase commit protocol.[22]
There is a Computational Representation Theorem in the actor model for systems which are closed in the sense that they do not receive communications from outside. The mathematical denotation denoted by a closed system is constructed from an initial behavior
and a behavior-approximating function
These obtain increasingly better approximations and construct a denotation (meaning) for
as follows [Hewitt 2008; Clinger 1981]:
In this way, can be mathematically characterized in terms of all its possible behaviors (including those involving unbounded nondeterminism). Although
is not an implementation of
, it can be used to prove a generalization of the Church-Turing-Rosser-Kleene thesis [Kleene 1943]:
A consequence of the above theorem is that a finite actor can nondeterministically respond with an uncountable[clarify] number of different outputs.
This section needs additional citations for verification. Please help improve this articlebyadding citations to reliable sources in this section. Unsourced material may be challenged and removed. (March 2012) (Learn how and when to remove this message)
|
One of the key motivations for the development of the actor model was to understand and deal with the control structure issues that arose in development of the Planner programming language.[citation needed] Once the actor model was initially defined, an important challenge was to understand the power of the model relative to Robert Kowalski's thesis that "computation can be subsumed by deduction". Hewitt argued that Kowalski's thesis turned out to be false for the concurrent computation in the actor model (see Indeterminacy in concurrent computation).
Nevertheless, attempts were made to extend logic programming to concurrent computation. However, Hewitt and Agha [1991] claimed that the resulting systems were not deductive in the following sense: computational steps of the concurrent logic programming systems do not follow deductively from previous steps (see Indeterminacy in concurrent computation). Recently, logic programming has been integrated into the actor model in a way that maintains logical semantics.[21]
Migration in the actor model is the ability of actors to change locations. E.g., in his dissertation, Aki Yonezawa modeled a post office that customer actors could enter, change locations within while operating, and exit. An actor that can migrate can be modeled by having a location actor that changes when the actor migrates. However the faithfulness of this modeling is controversial and the subject of research.[citation needed]
This section needs additional citations for verification. Please help improve this articlebyadding citations to reliable sources in this section. Unsourced material may be challenged and removed. (August 2021) (Learn how and when to remove this message)
|
The security of actors can be protected in the following ways:
This section needs additional citations for verification. Please help improve this articlebyadding citations to reliable sources in this section. Unsourced material may be challenged and removed. (March 2012) (Learn how and when to remove this message)
|
A delicate point in the actor model is the ability to synthesize the address of an actor. In some cases security can be used to prevent the synthesis of addresses (see Security). However, if an actor address is simply a bit string then clearly it can be synthesized although it may be difficult or even infeasible to guess the address of an actor if the bit strings are long enough. SOAP uses a URL for the address of an endpoint where an actor can be reached. Since a URL is a character string, it can clearly be synthesized although encryption can make it virtually impossible to guess.
Synthesizing the addresses of actors is usually modeled using mapping. The idea is to use an actor system to perform the mapping to the actual actor addresses. For example, on a computer the memory structure of the computer can be modeled as an actor system that does the mapping. In the case of SOAP addresses, it's modeling the DNS and the rest of the URL mapping.
Robin Milner's initial published work on concurrency[23] was also notable in that it was not based on composing sequential processes. His work differed from the actor model because it was based on a fixed number of processes of fixed topology communicating numbers and strings using synchronous communication. The original communicating sequential processes (CSP) model[24] published by Tony Hoare differed from the actor model because it was based on the parallel composition of a fixed number of sequential processes connected in a fixed topology, and communicating using synchronous message-passing based on process names (see Actor model and process calculi history). Later versions of CSP abandoned communication based on process names in favor of anonymous communication via channels, an approach also used in Milner's work on the calculus of communicating systems and the π-calculus.
These early models by Milner and Hoare both had the property of bounded nondeterminism. Modern, theoretical CSP ([Hoare 1985] and [Roscoe 2005]) explicitly provides unbounded nondeterminism.
Petri nets and their extensions (e.g., coloured Petri nets) are like actors in that they are based on asynchronous message passing and unbounded nondeterminism, while they are like early CSP in that they define fixed topologies of elementary processing steps (transitions) and message repositories (places).
The actor model has been influential on both theory development and practical software development.
The actor model has influenced the development of the π-calculus and subsequent process calculi. In his Turing lecture, Robin Milner wrote:[25]
Now, the pure lambda-calculus is built with just two kinds of thing: terms and variables. Can we achieve the same economy for a process calculus? Carl Hewitt, with his actors model, responded to this challenge long ago; he declared that a value, an operator on values, and a process should all be the same kind of thing: an actor.
This goal impressed me, because it implies the homogeneity and completeness of expression ... But it was long before I could see how to attain the goal in terms of an algebraic calculus...
So, in the spirit of Hewitt, our first step is to demand that all things denoted by terms or accessed by names—values, registers, operators, processes, objects—are all of the same kind of thing; they should all be processes.
The actor model has had extensive influence on commercial practice. For example, Twitter has used actors for scalability.[26] Also, Microsoft has used the actor model in the development of its Asynchronous Agents Library.[27] There are many other actor libraries listed in the actor libraries and frameworks section below.
According to Hewitt [2006], the actor model addresses issues in computer and communications architecture, concurrent programming languages, and Web services including the following:
Many of the ideas introduced in the actor model are now also finding application in multi-agent systems for these same reasons [Hewitt 2006b 2007b]. The key difference is that agent systems (in most definitions) impose extra constraints upon the actors, typically requiring that they make use of commitments and goals.
A number of different programming languages employ the actor model or some variation of it. These languages include:
Actor libraries or frameworks have also been implemented to permit actor-style programming in languages that don't have actors built-in. Some of these frameworks are:
Name | Status | Latest release | License | Languages |
---|---|---|---|---|
Otavia | Active | 2024-01-02 | Apache 2.0 | Scala |
Abstractor | Active | 2024-03-04 | Apache 2.0 | Java |
Xcraft Goblins | Active | 2022-08-30 | MIT | JavaScript |
ReActed | Active | 2022-11-30 | Apache 2.0 | Java |
Acteur | Active | 2020-04-16[47] | Apache-2.0 / MIT | Rust |
Bastion | Active | 2020-08-12[48] | Apache-2.0 / MIT | Rust |
Actix | Active | 2020-09-11[49] | MIT | Rust |
Aojet | Active | 2016-10-17 | MIT | Swift |
Actor | Active | 2017-03-09 | MIT | Java |
Actor4j | Active | 2020-01-31 | Apache 2.0 | Java |
Actr | Active | 2019-04-09[50] | Apache 2.0 | Java |
Vert.x | Active | 2018-02-13 | Apache 2.0 | Java, Groovy, Javascript, Ruby, Scala, Kotlin, Ceylon |
ActorFx | Inactive | 2013-11-13 | Apache 2.0 | .NET |
Akka (toolkit) | Active | 2022-09-06[51] | Commercial[52] (from 2.7.0, Apache 2.0 up to 2.6.20) | Java and Scala |
Akka.NET | Active | 2020-08-20[53] | Apache 2.0 | .NET |
Apache Pekko | Active | 2023-07-26[54] | Apache 2.0 | Java and Scala |
Dapr | Active | 2019-10-16 | Apache 2.0 | Java, .NET Core, Go, Javascript, Python, Rust and C++ |
DOTNETACTORS | Active | 2021-06-14 | MIT | .NET, C#, Azure Service Bus |
Remact.Net | Inactive | 2016-06-26 | MIT | .NET, Javascript |
Ateji PX | Inactive | ? | ? | Java |
czmq | Active | 2016-11-10 | MPL-2 | C |
F# MailboxProcessor | Active | same as F# (built-in core library) | Apache License | F# |
Korus | Active | 2010-02-04 | GPL 3 | Java |
Kilim[55] | Active | 2018-11-09[56] | MIT | Java |
ActorFoundry (based on Kilim) | Inactive | 2008-12-28 | ? | Java |
ActorKit | Active | 2011-09-13[57] | BSD | Objective-C |
Cloud Haskell | Active | 2024-04-30[58] | BSD | Haskell |
CloudI | Active | 2023-10-27[59] | MIT | ATS, C/C++, Elixir/Erlang/LFE, Go, Haskell, Java, Javascript, OCaml, Perl, PHP, Python, Ruby, Rust |
Clutter | Active | 2017-05-12[60] | LGPL 2.1 | C, C++ (cluttermm), Python (pyclutter), Perl (perl-Clutter) |
NAct | Inactive | 2012-02-28 | LGPL 3.0 | .NET |
Nact Archived 2021-02-05 at the Wayback Machine | Active | 2018-06-06[61] | Apache 2.0 | JavaScript/ReasonML |
Retlang | Inactive | 2011-05-18[62] | New BSD | .NET |
JActor | Inactive | 2013-01-22 | LGPL | Java |
Jetlang | Active | 2013-05-30[63] | New BSD | Java |
Haskell-Actor | Active? | 2008 | New BSD | Haskell |
GPars | Active | 2014-05-09[64] | Apache 2.0 | Groovy |
OOSMOS | Active | 2019-05-09[65] | GPL 2.0 and commercial (dual licensing) | C. C++ friendly |
Panini | Active | 2014-05-22 | MPL 1.1 | Programming Language by itself |
PARLEY | Active? | 2007-22-07 | GPL 2.1 | Python |
Peernetic | Active | 2007-06-29 | LGPL 3.0 | Java |
Picos | Active | 2020-02-04 | MIT | KRL |
PostSharp | Active | 2014-09-24 | Commercial / Freemium | .NET |
Pulsar | Active | 2016-07-09[66] | New BSD | Python |
Pulsar | Active | 2016-02-18[67] | LGPL/Eclipse | Clojure |
Pykka | Active | 2019-05-07[68] | Apache 2.0 | Python |
Termite Scheme | Active? | 2009-05-21 | LGPL | Scheme (Gambit implementation) |
Theron | Inactive[69] | 2014-01-18[70] | MIT[71] | C++ |
Thespian | Active | 2020-03-10 | MIT | Python |
Quasar | Active | 2018-11-02[72] | LGPL/Eclipse | Java |
Libactor | Active? | 2009 | GPL 2.0 | C |
Actor-CPP | Active | 2012-03-10[73] | GPL 2.0 | C++ |
S4 | Inactive | 2012-07-31[74] | Apache 2.0 | Java |
C++ Actor Framework (CAF) | Active | 2020-02-08[75] | Boost Software License 1.0 and BSD 3-Clause | C++11 |
Celluloid | Active | 2018-12-20[76] | MIT | Ruby |
LabVIEW Actor Framework | Active | 2012-03-01[77] | National Instruments SLA | LabVIEW |
LabVIEW Messenger Library | Active | 2021-05-24 | BSD | LabVIEW |
Orbit | Active | 2019-05-28[78] | New BSD | Java |
QP frameworks for real-time embedded systems | Active | 2019-05-25[79] | GPL 2.0 and commercial (dual licensing) | C and C++ |
libprocess | Active | 2013-06-19 | Apache 2.0 | C++ |
SObjectizer Archived 2020-08-10 at the Wayback Machine | Active | 2021-12-28[80] | New BSD | C++17 |
rotor | Active | 2022-04-23[81] | MIT License | C++17 |
Orleans | Active | 2023-07-11[82] | MIT License | C#/.NET |
Skynet | Active | 2020-12-10 | MIT License | C/Lua |
Reactors.IO | Active | 2016-06-14 | BSD License | Java/Scala |
libagents | Active | 2020-03-08 | Free software license | C++11 |
Proto.Actor | Active | 2021-01-05 | Free software license | Go, C#, Python, JavaScript, Kotlin |
FunctionalJava Archived 2021-04-22 at the Wayback Machine | Active | 2018-08-18[83] | BSD 3-Clause | Java |
Riker | Active | 2019-01-04 | MIT License | Rust |
Comedy | Active | 2019-03-09 | EPL 1.0 | JavaScript |
VLINGO XOOM Actors | Active | 2023-02-15 | Mozilla Public License 2.0 | Java, Kotlin, JVM languages, C# .NET |
wasmCloud | Active | 2021-03-23 | Apache 2.0 | WebAssembly (Rust, TinyGo, Zig, AssemblyScript) |
ray | Active | 2020-08-27 | Apache 2.0 | Python |
cell | Active | 2012-08-02 | New BSD License | Python |
go-actor | Active | 2022-08-16 | GPL 3.0 | Go |
Sento | Active | 2022-11-21 | Apache 2.0 | Common Lisp |
Tarant | Active | 2023-04-17 | MIT | Typescript, Javascript |
{{cite journal}}
: Cite journal requires |journal=
(help)
{{cite journal}}
: Cite journal requires |journal=
(help)
{{cite journal}}
: Cite journal requires |journal=
(help)
{{cite journal}}
: Cite journal requires |journal=
(help)
{{cite journal}}
: Cite journal requires |journal=
(help)
{{cite journal}}
: Cite journal requires |journal=
(help)
{{cite journal}}
: Cite journal requires |journal=
(help)
{{cite journal}}
: Cite journal requires |journal=
(help)
{{cite journal}}
: Cite journal requires |journal=
(help)
{{cite journal}}
: Cite journal requires |journal=
(help)
{{cite journal}}
: Cite journal requires |journal=
(help)
{{cite journal}}
: Cite journal requires |journal=
(help)
{{cite journal}}
: Cite journal requires |journal=
(help)