Nearly all commercial software today is built on an imperative/sequential
model (FORTRAN, COBOL, C, Java, ...) and has notorious difficulties managing
concurrency. See "Threads Considered Harmful" (
http://radar.oreilly.com/archives/2007/01/threads_conside.html) and "The
Problem with Threads" (
http://www.eecs.berkeley.edu/Pubs/TechRpts/2006/EECS-2006-1.html) for
details.
The best-known alternative has been the functional model (LISP, Scheme, ML,
Haskell, ...) which has difficulties handling non-determinism and stateful
behavior.
Around the same time that FORTRAN and LISP were developed, another model,
the ACTOR model, was proposed. Hewitt's "Viewing Control Structures as
Patterns of Passing Messages" started the ball rolling, Agha's "ACTORS: A
Model of Concurrent Computation in Distributed Systems" captures the model
in it's fully developed form. Both are included in the links at ERights.org(
http://www.erights.org/history/actors.html). I've found "An Algebraic
Theory of Actors and its Application to a Simple Object-Based Language" at (
http://formal.cs.uiuc.edu/papers/ATactors_festschrift.ps) to be an excellent
(brief) introduction to the key concepts.
Unlike the imperative and functional models, the actor model has not had
much success in popular implementation. The most visible example that
claims roots in the actor model is Erlang, although it's no more pure
actor-model than LISP is pure functional. It appears that the actor model,
in its pure form, provides an ideal model for safe implementation of
massively concurrent systems. If that is the case, then why don't we have
well-developed actor-based languages? What fatal flaw in the model am I
missing?
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
http://redfish.com/pipermail/friam_redfish.com/attachments/20080110/a12fd99d/attachment.html
Locked
