The actor *(paradigm) is a *(term) for modelling computation with _(concurrent) (possibly transparently-_(distributed)) entities, the actors, that communicate with asynchronous messages. Actors may update their behaviour depending on the messages they receive.

<h2>Systems implementing Actors</h2>

Development systems integrating the Actor paradigm: _(FramerD), _(Erlang), _(E).

Other experimental systems integrating the Actor paradigm: _(JoCaml), _(ABCL), _(Tube).

You can write software in actor-oriented style in about any language that allows to do or simulate concurrent programming, but the result will be somewhat painful, especially so when the underlying implementation restricts the number of actors (e.g. practical limitation of some ten thousands of threads in Java systems and "native" system threads system), so you either live by such drastic limitations, end up reimplementing all the infrastructure, or only make a half-baked use of the model.

<h2>History of the Actor Paradigm</h2>

<!-- See the pioneering works by Carl Hewitt, the developments by his successor Gul Agha -->

See the works by Carl Hewitt, _(Henry Baker), Henry Lieberman, Will Clinger, Gul Agha and others while at MIT, or by other fine people like _("Akinori Yonezawa"|A. Yonezawa). Actors have been rediscovered twenty years later by formal-methods people, yielding the very cleanly formalized _(join calculus). They have also been rediscovered by the industry, and a nice language that robustly implements the actor model is _(Erlang).

<span class="comment">Actors are the real thing of which _(object-oriented) programming is the caricature. Actors are what Alan Kay had in mind but couldn't initially achieve when inventing the Object Oriented paradigm. When people say that OOP is based on an "intuitive" modelling of the world as objects in interaction, the intuition they invoke is the Actor model, but their actual OO model is a less-expressive version where only one object is active at a time, with a linear flow of control: Objects are crippled actors deprived of independent activity. Retrofitting concurrency in an existing Object-Oriented system can help express the Actor paradigm, but it requires more than the superficial addition of threads to unleash the real thing.
-- _(Fare)
</span>

Other names for models equivalent to the Actor Paradigm: "Concurrency Oriented Programming" (term used within the _(Erlang) community), "_(Join calculus)" (formal model implemented in JoCaml), etc.

<strong>Note</strong>: sometimes Actors are inappropriately called _(Agent)s (term often used when Actors are instantiated remotely, or are "mobile agents"); an _(Agent|Agents) could be implemented using or not the Actor paradigm, but in any case the two _(term)s are distinct.

<ul class="links"><h4>People involved</h4>
<li>Carl Hewitt's _("Home Page"|http://www.ai.mit.edu/people/hewitt/hewitt.html)
<li>Henry Lieberman's _("Home Page"|http://lieber.www.media.mit.edu/people/lieber/)
<li>William D. Clinger's CCS _("Home Page"|http://www.ccs.neu.edu/home/will/)
<li>Gul Agha's _("Open System Laboratory"|http://osl.cs.uiuc.edu/)
</ul>