Ruby is a wonderful language for rapid development, it is easy to learn, we have wonderful frameworks, an active and dynamic community. But when it comes to concurrency Ruby is plagued with problems, controversies and urban legends. A lot of people would know about green threads in Ruby, GIL and its inherent limitations. But that it only one part of the big picture. Ruby offers much more than threads to helps us with concurrency. This presentation explores other options of writing highly concurrent applications in Ruby and options available in it. We cover topics ranging from Actor like message passing concurrency in Ruby, dataflow concurrency of how we can coordinate across different threads, Event driven methods, coroutine based concurrency which never blocks ;) and finally Software Transactional Memory. We look at lots of code, some serious looking yet colorful performance graphs comparisons, and conditions at which each of these forms are concurrency are effective and ineffective.

1. Paradigms of Concurrency

2. Why is this important?

3. Or for geeks to relate...

5. Without right abstractions...

6. So what do we have in hand?
● Threads – The Java hangover
● Fibers – Red headed cousin of threads
● Actors – Stylish but effective
● Reactor – He will do all the work...
● Dataflow – The forgotten one..
● STM – Remember ATM
● The Nirvana

7. A folk definition of insanity is to do the
same thing over and over again and to
expect the results to be different. By this
definition, we in fact require that
programmers of multithreaded systems
be insane
- The Problem with Threads
Edward Lee

8. Threading in Ruby
Concurrency is a myth Ruby -
@igvita

10. Fibers
● New kid in the block from Ruby 1.9
● Green threads with cooperatively
scheduler
● Can give up CPU control to other fiber
when needed.
● Based on Coroutines – Like python
generators but can yield to other
coroutines
● Think NeverBlock...

11. Nginx vs Apache Death Match

12. EventMachine – Reactor
Pattern

13. EventMachine
● Based on python Twisted
● Reactor sits in the middle
● IOC pattern – Not many get used to it
● Defer long running process
● Support for lot of protocols and very
active development
● Try my em-couchdb :)
(http://github.com/saivenkat/em-
couchdb)

14. Actors -Stylishly passing
messages

15. Actors
● Message passing concurrency
● No first class support in Ruby
● Revactor is good but we had problems
with it
● If Jruby, lots of Java Actor framework
available like Jetlang.
● Jruby + Jetlang - http://bit.ly/ahXh6j

16. Transactions – We are safe

17. Software Transactional
Memory
● Similar to database transactions but
inmemory (ACIDXX)
● Unfortunately again no first class
support
● STM library by MentalGuy -
http://bit.ly/c7Mxah
● In Jruby harness clojure's infrastructure
– Ruby objects as refs.
http://bit.ly/d6vpuP

18. Multi Process

19. Coordination

20. Coordination
● How do we coordinate independent
units of execution?
● Dataflow – Forgotten paradigm
● Other methods – May be a big heavy
weight suitable when multi processing
● Tuplespace, Queues (RabbitMq or
beanstalk)

21. Nirvana

22. Nirvana
● Polyglotism – Let the languages which
excel in concurrency do the job
● Make Ruby talk with Clojure, Erlang,
Haskell, node.js...
● Lots of ways. VM level support, external
infrastructure.

23. Sai Venkat
github.com/saivenkat
@sai_venkat
http://developer-in-test.blogspot.com
HariKrishnan
github.com/harikrishnan83
@harikrishnan83
http://harikrishnan83.wordpress.com

24. All images used are attributed to the
awesome guys who took them..
Please don't sue us :D