Slides from NYCJava talk on Intro To Functional Programming with RxJava. Sample project: https://github.com/digitalbuddha/RxStarter

1. +
Reactive
Programming
With RxJava
Mike Nakhimovich
Mnakhimovich@gmail.com
Feb. 23, 2015

2. +
Tonight’s Agenda
■What is Reactive
■Learn By Example
■Walkthrough sample app

3. + What is
Reactive?

4. +
Reactive Programming
■“Reactive Programming is
programming with
asynchronous data streams.”
(Andre Staltz)
■Data Stream: a sequence of
values

5. +
What does this mean?
■Programming Model based on the
principle of push rather than pull
■Values are emitted when ready,
not when asked for in a non-
blocking manner
■Allows for actions to be performed
in parallel, rather than in serial
■ie: shopping in person vs online

6. +
Functional Reactive
Programming
■Takes reactive
programming to the next
level
■Applying functions to the
data stream
■Ex. Map, Filter, Zip, Take

7. + Reactive
Extensions

8. +
ReactiveX
■Collection of helpful functions that
let you do reactive programming
■ReactiveX exists in more than 10
languages (JavaScript, .Net,
Objective-C, etc.)
■RxJava is the Java
implementation of ReactiveX
■Ported by Netflix team

9. +
Building Blocks of RxJava
■ Observable: source of data stream (sender)
■ Observer: listens for emitted values
(receiver)
■ The Observer subscribes (listens) to the
Observable
■ Observers react to whatever item or
sequence of items the Observable emits
■ Many observers can subscribe to the same
observable

10. +
Observable Observer Pattern
■Allows for Concurrent Operations:
the observer does not need to
block while waiting for the
observable to emit values
■Observer waits to receive values
when the observable is ready to
emit them
■Based on push rather than pull

11. + From Iterable
To Observable

12. +
Before Observables
■No easy way to perform asynchronous
operations if you needed multiple items
■Observables fill the gap as the ideal
way to access asynchronous
sequences of multiple items

13. +
Iterable vs. Observable
Interface
■Observable is the
asynchronous/push dual to the
synchronous pull iterable

14. +
Observables are…
■ Composable: Easily chained together or
combined
■ Flexible: Can be used to emit:
■ A scalar value (network result)
■ Sequence (items in a list)
■ Infinite streams (weather sensor)
■ Free from callback hell: Easy to transform
one asynchronous stream into another

15. +
Iterable Architecture
■ Before Reactive
1. Call a method
2. Wait for result
3. Store the return value from that method in a
variable
4. Use that variable and its new value to do
something useful

16. +
Observable Architecture
■ The flow goes like this:
1. Define an Observer that specifies what to
do with each emitted value
2. Call a method that returns an Observable
3. Subscribe the Observer to the Observable.
This tells the Observable that it has a
subscriber waiting to receive values when
they’re available.

17. +
In RxJava…
■ The Subscribe method connects an
Observer to an Observable
■ Once you Subscribe, no need to block the
thread
■ Values will come to your Observer when they
are ready

18. +
The Observer

19. +
Observer Interface
■ OnNext
■ onError
■ onCompleted

20. +
onNext
■ Observable calls this method whenever the
Observable emits an item.
■ This method can be called any number of
times (zero to many)
■ Always followed by onError or onComplete
(but not both)

21. +
onError
■ Observable calls this method to indicate
that it has failed to generate the expected
data or has encountered some other error
■ This stops the Observable and it won’t
make further calls.
■ Takes as its parameter an indication of
what caused the error

22. +
onComplete
■ Observable calls this method after it has
called onNext for the final time and it has not
encountered any errors.
■ A call to onComplete ends the subscription.

23. +
Why RxJava?
■Schedulers that make threading a
breeze
■Operators that let you transform,
combine, manipulate, and work
with the sequence of items emitted
by Observables

24. +
Threading Shouldn’t be Hard

25. +
Schedulers
■ Schedulers are used to manage and control
concurrency
■ observeOn: thread observable is executed on
■ subscribeOn: thread subscribe is executed on
api.users()
.observeOn(AndroidSchedulers.mainThr
ead())
.subscribeOn(Schedulers.io());

26. +
Available Schedulers

27. +
Let’s see some example

28. +
Consuming Observables

29. +
Consuming Observables

30. +
doOn Operators
■ Note: if only passing on onNext action (without a doOnError) to
the subscribe method OnErrorNotImplementedException will
be thrown if an error occurs

31. +
Explicitly Creating Observables
■ You can make an endless Observable by never
calling subscriber.onCompleted()

32. +
From async to sync
Lifesaver during testing
synchronously test asynchronous data
streams

33. +
Need a List?
■Be careful with long/infinite streams

34. +
Combining Observables

35. +
Map and Flatmap

36. +
Map

37. +
Map

38. +
Transform One Observable into
Another
1. Create on observable from a click event
2. Use flatMap to change that Observable to
another Observable
3. Subscribe to the result of the second
Observable (will emit 3 users)

39. +
map vs. flatMap
map flatMap
When you transform to
a value
When you transform to
an observable

40. +
Filtering Observables

41. +
Filter

42. +
Filter

43. +
Debounce/Throttle

44. +
Debounce/Throttle
▪ No more sending multiple requests when a
user clicks too many times.

45. +
Error Recovery

46. +
Recovering from Errors
■ Return a different value in an error case

47. +
Sample app
walkthrough
https://github.com/Betterment/DaggerStart
er

48. +
How we use Rx
■ Treat all data as immutable singleton Observable
Stores that know how to self-update and are backed
on disk
■ Since we treat data as a stream, we can return 1 or
more results for each subscription (if a cached value
is available)
■ We can cross subscribe one Store to another
■ RxJava lets us transform and combine data on any
thread and subscribe to updates for related
values/collections

49. +
Next to Explore
■Cold vs Hot Observables
■Subjects
■Creating Custom Operators

50. +
Sources/Addl Reading
■Offical Wiki
https://github.com/ReactiveX/RxJava/wiki
■Mastering Observables
http://docs.couchbase.com/developer/java-
2.0/observables.html
■Intro To Functional Reactive Programming
https://gist.github.com/staltz/868e7e9bc2a7b8c1f754

51. +
Questions?