goodboy / tractor

A distributed, structured concurrent runtime for Python (and friends)
GNU Affero General Public License v3.0
271 stars 12 forks source link

An "actor model" eh? #18

Open goodboy opened 6 years ago

goodboy commented 6 years ago

This is a discussion thread to dig into the theory surrounding how this project is (like) an actor model system and how it is or isn't compatible with structured concurrency.

BEFORE YOU THINK OR READ ANYTHING ELSE.

Watch this vid by the original author of the theory if you think you know what an actor model is or does, or looks like: https://www.youtube.com/watch?v=7erJ1DV_Tlo

Hint: it's a computational model not an API.

A bunch of stuff that should probably be referenced in the docs and aluded to more formally in the implementation (if that's what we're after?):

Reference implementations in other languages and frameworks:

goodboy commented 5 years ago

I've noticed many opinionated pronouncements about what does and does not constitute a true actor model:

After digging it seems to me that the theoretical core of an "actor model" is mostly well defined however in practise what does constitute being an actor model or system is somewhat flexible and less-stringent then many of the personal opinions on it (which seem to weigh one particular implementation or framework more when really the whole model is conceptual and implementation details are expected to vary).

Some resources to back this up include:

The main distinguishing theoretical features of what constitutes adhering to the model seems to be rooted in 2 main concepts:

  1. the details of how message passing is conducted
    • only one message is handled at a time
    • channels are not a requirement
    • there is no guaranteed arrival order
  2. whether or not unbounded nondeterminism is something that can be implemented and subsequently how the system is designed to handle this dilemma
goodboy commented 5 years ago

Another blog with some interesting posts: http://www.dalnefre.com/wp/

goodboy commented 4 years ago

Notes on how CSP vs. Actor systems mostly has to do with asynchronous-ness and naming: https://en.wikipedia.org/wiki/Communicating_sequential_processes#Comparison_with_the_actor_model

goodboy commented 4 years ago

As a reminder to self, I would like to have a "formal stuff" spiel in the docs going over the comparison and supposed incompatibilities of tractor + SC. By almost all measures tractor is an actor model without having exposed some of the traditional apis/behaviour (message loops around channels, unbounded channels, names in every message) and still fulfills the core behaviors necessary for processes to be classified as "actors" (async message processing, inherent concurrency and parallelism, named based discovery, variable topology, async handshaking, async spawning, async "behaviors" used to handle each message, no assurance of message arrival order, locality, etc.).

One of the key points I'd like to make is just because we aren't enforcing "everything is an actor" (especially where it makes no sense) it doesn't mean you can't classify the system as actor based because, really each process running a trio scheduler does fulfill 99% of the properties of a traditional actor even if they don't look like it from the outside.

Some TODO:

goodboy commented 3 years ago

Some further inside from an existing systems perspective:

goodboy commented 3 years ago

rando link from @salotz on The wide world of almost-actors: comparing the Pony to BEAM languages: https://www.youtube.com/watch?v=_0m0_qtfzLs&t=1s

goodboy commented 3 years ago

cute summary: https://gist.github.com/rbishop/9082539

gc-ss commented 3 years ago

I think it's important to note (from the video) that messages have:

The atmost once could be pretty complex to implement as it's easier to sent messages multiple times than atmost once - because then you could loose/drop messages

goodboy commented 3 years ago

@gc-ss

no guaranteed arrival order

this is incompatible with TCP

cannot get lost and

this is incompatible with the notion of UND in real systems

can arrive atmost once although they can arrive after a large time

Also incompat with TCP retransmission afaik.

I'm not sure any of those are strict requirements. Maybe you can point to where you think that is asserted?

goodboy commented 3 years ago

The rant task is codified in #210.