1. Reactive Programming
using RxJava & Akka Actors
Thomas Lockney (@tlockney)
PDXScala
June 14, 2014

2. What is reactive
programming?

3. Reactive programming is…
● A programming paradigm
● About data-flow
● Not really anything new

4. Reactive programming is...
● Event-driven
● Scalable
● Resilient
● Responsive
(the definition via the manifesto, anyway)

5. Reorganizing our thoughts a bit...
● Think in terms of discrete events
● Code in terms of behaviors
○ reacting to events
● The system state changes over time based
on the flow of events

6. A brief digression...
Amdahl’s law (paraphrased):
The maximum increase in speed of a program
is limited by the sequential portions of the code.

7. A brief digression...
Amdahl’s law (paraphrased):
If you have a program that runs for 4 hours, but
1 hour of runtime is necessarily serial, your
program will have at most a 4x speedup with
parallelization.

8. Amdahl’s law

9. The thing about Amdahl’s law
This is death by a thousand cuts.
Every line of code is subject to this rule!

10. Some principles...
● Keep your data immutable
● Share nothing
● Blocking is bad!

11. Another brief digression...

12. ● Immutable data structures
● Referential transparency
● First-class functions
… this gives you ...
Once you have:

13. Functional Programming

14. well...
Functional Programming
in the small

15. RxJava
“a library for composing asynchronous and
event-based programs using observable
sequences for the Java VM”

16. My translation:
RxJava
A library for composing behaviors
applied to event streams.
note: when I say behaviors, think
referentially-transparent functions.

17. Marble Diagrams

18. Observable
● The “dual” of Iterable
● Or an Observer for sequences
● Somewhat similar to a Future
○ but, again, supports sequences

19. Observable
Basic mechanics
● onNext()
● onError()
● onComplete()

20. Functional Composition
● map()
● flatMap()
● filter()

21. map()

22. flatMap()

23. filter()

24. Creating Observables
● Observable.from(...), Observable.just(...),
Observable.range(...), etc.
● Implement the Observable interface
○ explicit calls to onNext(), onError(), onComplete()

25. Observer & Subscriber
Observer
● interface for handling Observables onNext,
onError, onComplete
Subscriber
● represents a subscription to an observable

26. Demo time!

27. RxJava is Reactive
● event-based (data-flows)
● scalable*
● resilient* (???)
● responsive* (???)
* - requires some additional work on your end
??? - the story here is not entirely clear or potentially even available in current releases

28. Akka
& the actor model

29. Actors (the Actor model)
Defined by three traits
● a behavior (reacts to events)
● an state model
● send/receive (immutable) messages

30. Actors
● messages are processed sequentially
● multiple actors can be working at the same
time
● actors are not threads
● an actor can block (but should avoid it)
● no shared state

31. Actor System
● actors interact
● actors exist together within an actor system
● the system defines the outermost bounds

32. Akka
● Scala-based actor model toolkit
● Provides a lot of extras
● We won’t be talking about those

33. Akka
● Supervisors
○ provide exception handling
○ “let it crash”
○ orthogonal to actor behavior
● Location transparency
○ abstracts the idea of “where” an actor lives

34. Akka
● Mailboxes
● Routing
○ e.g., round-robin, smallest mailbox, etc.
● Dispatching
○ essentially how to allocate thread resources

35. Demo time!

36. Akka is Reactive
● event-based
● resilient/fault-tolerant
● easily scalable*
● responsive*
* - requires some additional work on your end

37. Reactive Streams

38. Reactive Streams
… I wish I had time … ;~)