5 ms·

Actors: A Model of Concurrent Computation [pdf] (1985)

138 points by kioku 8mo ago

esafak 8mo ago
A more legible version: https://dspace.mit.edu/handle/1721.1/6952 https://dspace.mit.edu/handle/1721.1/6952 https://en.wikipedia.org/wiki/Gul_Agha_(computer_scientist) https://en.wikipedia.org/wiki/Gul_Agha_(computer_scientist)
- pedroza_alex 8mo ago
  The first link returns a 403.
  - c0balt 8mo ago
    Both seem to be accessible from Germany. Maybe a geoblock?
jeanlucas 8mo ago
Missing: (1985)
michaelsbradley 8mo ago
May be of interest: Pony Language is designed from the ground up to support the Actor model. https://www.ponylang.io/ https://www.ponylang.io/
- yvdriess 8mo ago
  Mandatory mention of notable actor languages: - Erlang and Elexir - E - AmbientTalk
- teleforce 8mo ago
  D language is also supporting actor model in the standard library for its concurrent, parallel and distributed programming [1]. [1] D (programming language): https://en.wikipedia.org/wiki/D_(programming_language) https://en.wikipedia.org/wiki/D_(programming_language)
- throwaway17_17 8mo ago
  Is Pony still an actively developed language? I remember watching several talks while they brought the language up to release, and read several of the accompanying papers. However, I thought with the primary corporate sponsor dropping the language it had gone basically EOL. Which was a pretty large bummer as I was very interested to see how the reference capability model of permissions and control worked at large scale for concurrency control and management (as well as its potential application to other domains).
  - dismalaf 8mo ago
    It is still developed, although it feels a bit like it was mostly "done" 10 years ago. https://github.com/ponylang/ponyc https://github.com/ponylang/ponyc Quite a few recent commits and their blog/X account mentioned their LSP now being bundled with the language... https://www.ponylang.io/blog/2026/02/last-week-in-pony---february-1-2026/ https://www.ponylang.io/blog/2026/02/last-week-in-pony---feb... Dunno, now it feels like the "hot" thing is either manual memory languages like Zig, Odin an Rust or languages with novel type systems like Lean, Koka, Idris, etc... GC'd "systems" languages like Nim, Crystal, Pony, Go, etc... all seem kind of old fashioned now.
    - blandflakes 8mo ago
      Go seems to have some enduring affection and popularity for new projects and companies. I recently felt like a lot of the recent shift was less about GC and more about runtime characteristics (static binaries, lean resource consumption, lack of an in-your-face virtual machine). It never felt like Nim, Pony, or Crystal were ever that popular that a diminished hype cycle registered as something thematic to me (not that I really intend to disagree with your perspective here).
kibwen 8mo ago
Please change the title to the original, "Actors: A Model Of Concurrent Computation In Distributed Systems". I'm not normally a stickler for HN's rule about title preservation, but in this case the "in distributed systems" part is crucial, because IMO the urge to use both the actor model (and its relative, CSP) in non-distributed systems solely in order to achieve concurrency has been a massive boondoggle and a huge dead end. Which is to say, if you're within a single process, what you want is structured concurrency ( https://vorpus.org/blog/notes-on-structured-concurrency-or-go-statement-considered-harmful/ https://vorpus.org/blog/notes-on-structured-concurrency-or-g... ), not the unstructured concurrency that is inherent to a distributed system.
- galaxyLogic 8mo ago
  > both the actor model (and its relative, CSP) in non-distributed systems solely in order to achieve concurrency has been a massive boondoggle and a huge dead end. Why is that so?
  - lmm 8mo ago
    Well, lots of people have tried it and spent a lot of money on it and don't seem to have derived any benefit from doing so.
    - ianbutler 8mo ago
      Except Akka in Java and for the entirety of Erlang and its children Elixir and Gleam. You obviously can scale those to multiple systems, but they provide a lot of benefit in local single process scenarios too imo. Things like data pipelines, and games etc etc.
      - lmm 8mo ago
        I've worked on a number of systems that used Akka in a non-distributed way and it was always an overengineered approach that made the system more complex for no benefit.
deleted 8mo ago
[deleted]
rubenvanwyk 8mo ago
I think Microsoft Orleans, Erlang OTP and Scala Play are probably most famous examples in use today.
- keithnz 8mo ago
  I would think Akka in Java world is more famous than orleans
  - lmm 8mo ago
    That's probably what they meant by "Scala Play".
  - viccis 8mo ago
    Akka's not open source anymore so people tend to look at similar or competing systems like Scala Play.
    - jen20 8mo ago
      Apache Pekko is an open-source fork of Akka from before their licensing changes.
- BatteryMountain 8mo ago
  Orleans is pretty cool! The project has matured nicely over the years (been something like 10 years?) and they have some research papers attached to it if you like reading up on the details. The nuget stats indicate a healthy amount of downloads too, more than one might expect. One of the single most important things I've done in my career was going down the Actor Model -framework rabbit hole about 8 or 9 years ago, read a bunch of books on the topic, that contained a ton of hidden philosophy, amazing reasoning, conversations about real-time vs eventual consistency, Two-Generals-Problem - just a ton of enriching stuff, ways to think about data flows, the direction of the flow, immutability, event-logged systems and on and on. At the time CQS/CQRS was making heavy waves and everyone tried to implement DDD & Event-based (and/or service busses - tons of nasty queues...) and Actor Model (and F# for that matter) was such clean fresh breath of air from all the Enterprise complexity. Would highly recommend going this path for anyone with time on their hands, its time well spent. I still call on that knowledge frequently even when doing OOP.
charles_f 8mo ago
Actor model is one of these things that really seduces me on paper, but my only exposure to it was in my consulting career, and that was to help migrate away from it. The use case seemed particularly adapted (integration of a bunch of remote devices with spotty connection), but it was practically a nightmare to debug... which was a problem since it was buggy. To be fair, the problem was probably that particular implementation, but I'm wondering if there's any successful rollout of that model at any significant scale out there.
- melting_snow 8mo ago
  I was in a team that built a bigger telco project for machine to machine communication, using akka actors. It was okayish, the only thing that I hated was how the whole pattern spread through the whole code base
dependency_2x 8mo ago
It doesn't feel 1985. Feels very 2015. Really good insights. Remembering the hardware they had back then too, and ~14 years before Google took off.
dzonga 8mo ago
> It is generally believed that the next generation of computers will involve massively parallel architectures. To this day - we have only taken advantage of parallel architectures in GPUs - a lot of software still runs on single CPU threads. most programming languages- are made optimized for single threads - yeah we might have threads, virtual threads, fibers etc - but how many people are using those on a daily basis?
- throwaway17_17 8mo ago
  I will be glad to be wrong about, but… I was under the impression that parallel and concurrent code was the dominant paradigm for programming tasks currently going in most of the semi-mainstream domains. I am certainly willing to concede that I could just be in a bubble that thinks about and designs for concurrency and parallelism as a first class concern, but it doesn’t seem that way. I mean one of the large features/touted benefits for Rust is the single mutable XOR multiple immutable semantics explicitly to assist with problems in parallel/concurrent code, all of the OTP languages are built on top of a ridiculously parallel and distributed first ‘VM’. It strikes me as peculiar that these types of languages and ecosystems would be so, apparently, popular if the primary use case of ‘safe’/resilient parallel/concurrent code was not a large concern.
pancsta 8mo ago
> It captures the nondeterminism in the order of delivery of communications. The Subsequent transition captures fairness arising from the guarantee of delivery. We provide a denotational semantics for our minimal actor language in terms of the transition relations. Juicy paper, not to mention the declassification. It really reminds me of asyncmachine.dev which has actors, relations, transitions, and embraces non-determinism.

138 points by kioku 8mo ago

A more legible version: https://dspace.mit.edu/handle/1721.1/6952 https://dspace.mit.edu/handle/1721.1/6952 https://en.wikipedia.org/wiki/Gul_Agha_(computer_scientist) https://en.wikipedia.org/wiki/Gul_Agha_(computer_scientist)

pedroza_alex 8mo ago
The first link returns a 403.
- c0balt 8mo ago
  Both seem to be accessible from Germany. Maybe a geoblock?

jeanlucas 8mo ago

Missing: (1985)

michaelsbradley 8mo ago

May be of interest: Pony Language is designed from the ground up to support the Actor model. https://www.ponylang.io/ https://www.ponylang.io/

yvdriess 8mo ago
Mandatory mention of notable actor languages: - Erlang and Elexir - E - AmbientTalk
teleforce 8mo ago
D language is also supporting actor model in the standard library for its concurrent, parallel and distributed programming [1]. [1] D (programming language): https://en.wikipedia.org/wiki/D_(programming_language) https://en.wikipedia.org/wiki/D_(programming_language)
throwaway17_17 8mo ago
Is Pony still an actively developed language? I remember watching several talks while they brought the language up to release, and read several of the accompanying papers. However, I thought with the primary corporate sponsor dropping the language it had gone basically EOL. Which was a pretty large bummer as I was very interested to see how the reference capability model of permissions and control worked at large scale for concurrency control and management (as well as its potential application to other domains).
- dismalaf 8mo ago
  It is still developed, although it feels a bit like it was mostly "done" 10 years ago. https://github.com/ponylang/ponyc https://github.com/ponylang/ponyc Quite a few recent commits and their blog/X account mentioned their LSP now being bundled with the language... https://www.ponylang.io/blog/2026/02/last-week-in-pony---february-1-2026/ https://www.ponylang.io/blog/2026/02/last-week-in-pony---feb... Dunno, now it feels like the "hot" thing is either manual memory languages like Zig, Odin an Rust or languages with novel type systems like Lean, Koka, Idris, etc... GC'd "systems" languages like Nim, Crystal, Pony, Go, etc... all seem kind of old fashioned now.
  - blandflakes 8mo ago
    Go seems to have some enduring affection and popularity for new projects and companies. I recently felt like a lot of the recent shift was less about GC and more about runtime characteristics (static binaries, lean resource consumption, lack of an in-your-face virtual machine). It never felt like Nim, Pony, or Crystal were ever that popular that a diminished hype cycle registered as something thematic to me (not that I really intend to disagree with your perspective here).

kibwen 8mo ago

Please change the title to the original, "Actors: A Model Of Concurrent Computation In Distributed Systems". I'm not normally a stickler for HN's rule about title preservation, but in this case the "in distributed systems" part is crucial, because IMO the urge to use both the actor model (and its relative, CSP) in non-distributed systems solely in order to achieve concurrency has been a massive boondoggle and a huge dead end. Which is to say, if you're within a single process, what you want is structured concurrency ( https://vorpus.org/blog/notes-on-structured-concurrency-or-go-statement-considered-harmful/ https://vorpus.org/blog/notes-on-structured-concurrency-or-g... ), not the unstructured concurrency that is inherent to a distributed system.

galaxyLogic 8mo ago
> both the actor model (and its relative, CSP) in non-distributed systems solely in order to achieve concurrency has been a massive boondoggle and a huge dead end. Why is that so?
- lmm 8mo ago
  Well, lots of people have tried it and spent a lot of money on it and don't seem to have derived any benefit from doing so.
  - ianbutler 8mo ago
    Except Akka in Java and for the entirety of Erlang and its children Elixir and Gleam. You obviously can scale those to multiple systems, but they provide a lot of benefit in local single process scenarios too imo. Things like data pipelines, and games etc etc.
    - lmm 8mo ago
      I've worked on a number of systems that used Akka in a non-distributed way and it was always an overengineered approach that made the system more complex for no benefit.

deleted 8mo ago

[deleted]

rubenvanwyk 8mo ago

I think Microsoft Orleans, Erlang OTP and Scala Play are probably most famous examples in use today.

keithnz 8mo ago
I would think Akka in Java world is more famous than orleans
- lmm 8mo ago
  That's probably what they meant by "Scala Play".
- viccis 8mo ago
  Akka's not open source anymore so people tend to look at similar or competing systems like Scala Play.
  - jen20 8mo ago
    Apache Pekko is an open-source fork of Akka from before their licensing changes.
BatteryMountain 8mo ago
Orleans is pretty cool! The project has matured nicely over the years (been something like 10 years?) and they have some research papers attached to it if you like reading up on the details. The nuget stats indicate a healthy amount of downloads too, more than one might expect. One of the single most important things I've done in my career was going down the Actor Model -framework rabbit hole about 8 or 9 years ago, read a bunch of books on the topic, that contained a ton of hidden philosophy, amazing reasoning, conversations about real-time vs eventual consistency, Two-Generals-Problem - just a ton of enriching stuff, ways to think about data flows, the direction of the flow, immutability, event-logged systems and on and on. At the time CQS/CQRS was making heavy waves and everyone tried to implement DDD & Event-based (and/or service busses - tons of nasty queues...) and Actor Model (and F# for that matter) was such clean fresh breath of air from all the Enterprise complexity. Would highly recommend going this path for anyone with time on their hands, its time well spent. I still call on that knowledge frequently even when doing OOP.

charles_f 8mo ago

Actor model is one of these things that really seduces me on paper, but my only exposure to it was in my consulting career, and that was to help migrate away from it. The use case seemed particularly adapted (integration of a bunch of remote devices with spotty connection), but it was practically a nightmare to debug... which was a problem since it was buggy. To be fair, the problem was probably that particular implementation, but I'm wondering if there's any successful rollout of that model at any significant scale out there.

melting_snow 8mo ago
I was in a team that built a bigger telco project for machine to machine communication, using akka actors. It was okayish, the only thing that I hated was how the whole pattern spread through the whole code base

dependency_2x 8mo ago

It doesn't feel 1985. Feels very 2015. Really good insights. Remembering the hardware they had back then too, and ~14 years before Google took off.

dzonga 8mo ago

> It is generally believed that the next generation of computers will involve massively parallel architectures. To this day - we have only taken advantage of parallel architectures in GPUs - a lot of software still runs on single CPU threads. most programming languages- are made optimized for single threads - yeah we might have threads, virtual threads, fibers etc - but how many people are using those on a daily basis?

throwaway17_17 8mo ago
I will be glad to be wrong about, but… I was under the impression that parallel and concurrent code was the dominant paradigm for programming tasks currently going in most of the semi-mainstream domains. I am certainly willing to concede that I could just be in a bubble that thinks about and designs for concurrency and parallelism as a first class concern, but it doesn’t seem that way. I mean one of the large features/touted benefits for Rust is the single mutable XOR multiple immutable semantics explicitly to assist with problems in parallel/concurrent code, all of the OTP languages are built on top of a ridiculously parallel and distributed first ‘VM’. It strikes me as peculiar that these types of languages and ecosystems would be so, apparently, popular if the primary use case of ‘safe’/resilient parallel/concurrent code was not a large concern.

pancsta 8mo ago

> It captures the nondeterminism in the order of delivery of communications. The Subsequent transition captures fairness arising from the guarantee of delivery. We provide a denotational semantics for our minimal actor language in terms of the transition relations. Juicy paper, not to mention the declassification. It really reminds me of asyncmachine.dev which has actors, relations, transitions, and embraces non-determinism.