This document introduces Jobim, an actor library for Clojure that enables building distributed, concurrent applications. It describes actors as named channels that receive and send messages. Jobim provides protocols for messaging, coordination, and serialization that can be extended with plugins. It also includes behaviors like supervisor, server, and finite state machine patterns to help reuse distributed logic. The library aims to integrate well with Clojure while providing solutions for distribution challenges like coordination and serialization.

1. Jobim: an Actors
Library for the Clojure
Programming Language
Antonio Garrote
María N. Moreno García

2. Clojure
• New Lisp dialect
• Hosted: JVM, CLR
• Focus on concurrency: (STM, Agents,
futures, fork-join, java.util.concurrent.*)

3. Distributed concurrent
applications in Clojure?
“Given the diversity, sophistication, maturity,
interoperability,robustness etc of these options, it's
unlikely I'm going to fiddle around with some
language-specific solution.”
Rich Hickey

4. Distributed applications
on the JVM
• JINI
• Java Spaces
• JMS
• Terracota
• RabbitMQ
• ZeroMQ
• Gearman

5. Problems
• Different computational models
• Hard to port code from one solution to
other
• Friction with Clojure semantics

6. Extending Clojure
• Computational model?
• Suitable notation?
• Underlying implementation?

8. Computational Model

9. Actors: components
• Named channel (PID) PID
• Message box MBox
Execution
Context
• Execution context
Computation based on the exchange of messages

10. Actors: mobile
processes
PID3 PID1
Execution Execution
MBox MBox
Context Context
Msg
PID3 PID3
PID2
Execution
MBox
Context

11. Notation

12. Actors: minimal
interface
(def *pid* (spawn f))
(is (= *pid* (self)))
(send! *pid* msg)
(def msg (receive *pid*))

13. Selective Reception
(let [p (promise)
pid (spawn
#(let [a (receive odd?)
b (receive even?)]
(deliver p [a b])))]
(send! pid 2)
(send! pid 1)
(is (= @p [1 2])))

14. Implementation

15. Message Box
• Lamina - Z. Tellman (https://github.com/
ztellman/lamina)
• Transforms Clojure sequences into event-
driven channels
• Synchronous and asynchronous interface

16. PIDs/Channel Names
• Plain Java strings: easy to exchange
• Globally unique identifiers for actors across
all the nodes in a Jobim cluster
• Generated by Jobim’s runtime
• GUID node + process counter

17. Execution context
• Threaded actors:
- Java thread per actor
- End of thread execution, releases
resources
- Threaded actors do not scale (~2000
threads per node max.)

18. Execution context
• Evented actors (Scala):
- Actors context = closure + callback
functions
- Small number of reactor threads execute
all the evented threads

19. (spawn
#(loop []
(let [[from msg] (receive)]
Threaded (send! from msg)
(recur))))
(spawn-evented
#(react-loop []
(react [[from msg]]
Evented (send! from msg)
(react-recur))))

20. react-loop
Callbacks+Contexts queues
Events
listen-once
Reactor1 ... ReactorN publish
react-recur
Multiplexer
react-future
Messages
thread- publish
handler
pool

21. Distribution

22. 3 problems
Messaging Coordination Serialization

23. Modular solution
Protocols: jobim.services.*
Messaging Coordination Serialization
Plugins

24. Coordination
• Name service
• Membership groups: presence
• Distributed agreement: 2PC protocol

25. Coordination
• Apache ZooKeeper plugin
- Light-weight
- Scalable
- Small set of primitives to build
sophisticated coordination protocols

26. Coordination: name
service - group
membership
(nodes)
(resolve-node-name node-name)
(register-name name *pid*)
(def *pid* (resolve-name name))

27. Coordination: 2PC -
group membership
(link *pid1* *pid2*)
Signal

28. Messaging
• TCP plugin: Netty, Z.Tellman’s Aleph
[https://github.com/ztellman/aleph]
• RabbitMQ plugin
• ZeroMQ plugin

29. Serialization
• Java Serialization plugin
• JSON plugin
• Kryo serialization library plugin (Yahoo S4)

30. Behaviours

31. Reusing distributed
components?
• Encapsulate distributed patterns
• Hide message passing logic
• Building blocks for larger distributed
systems
• Built using Clojure protocols
• Threaded and evented versions

32. Behaviours
• Supervisor
• Generic Server
• FSM
• Event Manager / Event Handler
• Generic TCP server

33. ;; FSM Lock type
(def-fsm Lock
(init [this code] [:locked {:so-far [] :code code}])
(next-transition [this state-name state-data message]
(let [[topic _] message]
(condp = [state-name topic]
[:locked :button] handle-button
[:open :lock] handle-lock
action-ignore)))
(handle-info [this current-state current-data message]
(do
(cond-match
[[?from :state] message] (send! from current-state))
(action-next-state current-state current-data))))

34. Demo

35. Future work
• Benchmarking + Performance
• Packaging / deployment / managing of
distributed apps
• Missing functionality

36. Code+deps
• https://github.com/antoniogarrote/jobim
[jobim-core "0.1.2-SNAPSHOT"]
[jobim-rabbitmq "0.1.1-SNAPSHOT"]
[jobim-zeromq "0.1.1-SNAPSHOT"] *