Actor Model and Concurrent Processing in Elixir vs. Clojure and Ruby with Xiang Ji & Nathan Hessler

In this episode of Elixir Wizards, Xiang Ji and Nathan Hessler join hosts Sundi Myint and Owen Bickford to compare actor model implementation in Elixir, Ruby, and Clojure.

In Elixir, the actor model is core to how the BEAM VM works, with lightweight processes communicating asynchronously via message passing. GenServers provide a common abstraction for building actors, handling messages, and maintaining internal state. In Ruby, the actor model is represented through Ractors, which currently map to OS threads.

They discuss what we can learn by comparing models, understanding tradeoffs between VMs, languages, and concurrency primitives, and how this knowledge can help us choose the best tools for a project.

Topics discussed in this episode:

• Difference between actor model and shared memory concurrency
• Isolation of actor state and communication via message passing
• BEAM VM design for high concurrency via lightweight processes
• GenServers as common abstraction for building stateful actors
• GenServer callbacks for message handling and state updates
• Agents as similar process abstraction to GenServers
• Shared state utilities like ETS for inter-process communication
• Global Interpreter Lock in older Ruby VMs
• Ractors as initial actor implementation in Ruby mapping to threads
• Planned improvements to Ruby concurrency in 3.3
• Akka implementation of actor model on JVM using thread scheduling
• Limitations of shared memory concurrency on JVM
• Project Loom bringing lightweight processes to JVM
• Building GenServer behavior in Ruby using metaprogramming
• CSP model of communication using channels in Clojure
• Differences between BEAM scheduler and thread-based VMs
• Comparing Elixir to academic languages like Haskell
• Remote and theScore are hiring!

Links mentioned in this episode:

theScore is hiring! https://www.thescore.com/
Remote is also hiring! https://remote.com/
Comparing the Actor Model and CSP with Elixir and Clojure Blog Post by Xiang Ji
Comparing the Actor model & CSP concurrency with Elixir & Clojure Xiang Ji at ElixirConf EU 2022
Clojure Programming Language https://clojure.org/
Akka https://akka.io/
Go Programming Language https://github.com/golang/go
Proto Actor for Golang https://proto.actor/
RabbitMQ Open-Source Message Broker Software  https://github.com/rabbitmq
JVM Project Loom https://github.com/openjdk/loom
Ractor for Ruby  https://docs.ruby-lang.org/en/master/ractor_md.html
Seven Concurrency Models in Seven Weeks: When Threads Unravel by Paul Butcher
Seven Languages in Seven Weeks by Bruce A. Tate
GenServer https://hexdocs.pm/elixir/1.12/GenServer.html
ets https://www.erlang.org/doc/man/ets.html
Elixir in Action by Saša Jurić
Redis https://github.com/redis/redis
Designing for Scalability with Erlang/OTP by Francesco Cesarini & Steve Vinoski
Discord Blog: Using Rust to Scale Elixir for 11 Million Concurrent Users
Xiang's website https://xiangji.me/
Feeling Good: The New Mood Therapy by David D. Burns

Special Guests: Nathan Hessler and Xiang Ji.