Celluloid & Co
Object Oriented Concurrency in Ruby

is Ruby object oriented?

From objects ...

I'm sorry that I long ago coined the
term "objects" for this topic because
it gets many people to focus on the
lesser idea.

The big idea is "messaging" --
that is what the kernel of Smalltalk/Squeak
is all about.

-- Alan Kay

... to concurrency

Erlang might be the only object oriented
language because the 3 tenets of object
oriented programming are that it's based
on message passing, that you have isolation
between objects and have polymorphism.

-- Joe Armstrong

is Ruby object oriented?

• Message passing? Kind of...
• Isolation? Nope.
• At least we have polymorphism!

Celluloid

• Each Ruby object is a unit of concurrency, called actor or cell.
• It is running in its own thread.
• Methods are called through transparent thread-safe queues called mailboxes.

Concurrent Duck

class Duck
  include Celluloid
  def quack
    "Quaaaaaack!"
  end
end

>> d = Duck.new
 => #<Celluloid::ActorProxy(Duck:0x5260)>
>> d.quack
 => "Quaaaaaack!"

Concurrent Duck (cont.)

class SlowDuck
  include Celluloid
  def quack
    sleep 10
    "Quaaaaaack!"
  end
end

>> d = SlowDuck.new
 => #<Celluloid::ActorProxy(Duck:0x5458)>
>> d.quack
 ...
 => "Quaaaaaack!"

Asynchronous method call

>> d = SlowDuck.new
 => #<Celluloid::ActorProxy(Duck:0x5458)>
>> d.async.quack
 => nil

• Caller does not block anymore...
• How to get our hands on the return value?

Futures!

>> d = SlowDuck.new
 => #<Celluloid::ActorProxy(Duck:0x5458)>
>> q = d.future.quack
>> q.value # Blocking call
 => "Quaaaaaack!"

Links

class Duckling
  include Celluloid
  def quack
    raise RuntimeError, "Oops!"
  end
end

Links (cont.)

class ParentDuck
  include Celluloid
  def initialize
    @baby = Duckling.new_link
  end

  def quack
    @baby.async.quack
  end
end

Links (cont.)

>> p = ParentDuck.new
>> p.quack
  ...
  E, [...] ERROR -- : Duckling crashed!
  ...
  E, [...] ERROR -- : ParentDuck crashed!

Supervisors

class Farmyard < Celluloid::SupervisionGroup
  pool SlowDuck, as: :duck_family, size: 5
end

>> Farmyard.run!
>> f = (0..7).to_a.map { |n|
  Celluloid::Actor[:duck_family].future.quack }
>> f.map(&:value)
 => ["Quaaaaaack!", "Quaaaaaack!", "Quaaaaaack!",
     "Quaaaaaack!", "Quaaaaaack!", "Quaaaaaack!",
     "Quaaaaaack!", "Quaaaaaack!"]

Execution modes

• Exclusive as in Erlang and Akka
• Pipeline as in ATOM (default)

DCell

• Celluloid + ZeroMQ
• You basically get Erlang OTP in Ruby

Celluloid::IO

• Celluloid actors cannot respond to incoming messages during a blocking I/O operation.
• Creating an actor for each incoming connection might be expensive.

Evented actor

class DuckServer
  include Celluloid::IO
  finalizer :shutdown

  def initialize
    @server = TCPServer.new('localhost', 3000)
    async.run
  end

  def shutdown
    @server.close if @server
  end

Evented actor (cont.)

  def run
    loop { async.handle_connection @server.accept }
  end

  def handle_connection(socket)
    loop do
      socket.readpartial(4096)
      socket.puts "Quaaaaaack!"
    end
  rescue EOFError
    socket.close
  end
end

Evented actor (cont.)

>> s = DuckServer.new

References

• Celluloid
• DCell
• Celluloid::ZMQ
• Celluloid::IO
• Erlang
• Akka
• ATOM