Functional Reactive Programming in Java, by Juan Gomez (Droidcon NYC 2015)

This talk will be an introduction to the ideas behind functional reactive programming and how you can move away from traditional synchronous state management with variables to asynchronous streams of data instead. You will learn how Rx (Reactive Extensions) Observables simplify concurrent code and let you write asynchronous, message based Android apps, in ways that are more elegant and a bit less error prone than traditional Android mechanisms.

We will also take a look at some Higher-order functions such as map(), flatmap(), filter(), zip() and reduce() as well as some other Rx operators that enable you to write simple, expressive and concise code to process Observables and solve problems in many common Android scenarios. These powerful yet easy to use abstractions will let you write asynchronous code in a very straightforward, declarative fashion; making the task of writing great Android apps a lot easier.

Transcript

1. Intro to Functional Reactive Programming Juan Gomez
2. • "Original FRP" refers to denotational and continuous-time functional programming using behaviors and events. • Rx is reactive programming combined with functional programming techniques. • Great post about the name controversy by André Staltz https://medium.com/@andrestaltz/why-i-cannot-say-frp- but-i-just-did-d5ffaa23973b Wait, you mean Reactive Programming?
3. Agenda • Brief introduction to Rx and why we want to use it. • Observables and useful operators to transform Observables. • Intermediate concepts around RxJava
4. What Is Functional Reactive Programming? • A style of programming based on two key ideas: continuous time-varying behaviors, and event-based reactivity. • Popularized by Erik Meijer when he created the Rx library for .NET while at Microsoft.
5. What are Reactive Extensions? • It’s a library that allows you to use FRP in many Programming Language • Allows you to represent asynchronous data streams with “Observables” • And to parameterize the concurrency in those asynchronous data streams using “Schedulers”.
6. What are Reactive Extensions? • Abstracts away concerns about things like: ✦ low-level threading ✦ synchronization ✦ thread-safety ✦ concurrent data structures.
7. Rx Family • C#: Rx.NET • JavaScript: RxJS • RxJava (Java, Scala, Groovy, Clojure, Kotlin) • Ruby: Rx.rb • Python: RxPY • More at: http://reactivex.io/
8. Why Functional Reactive Programming • Writing concurrent programs correctly is difficult. • You can transform & compose asynchronous operations. • High-level abstractions • Standard error handling
9. Multithreading is hard! This is a lesson I seem to learn every few years: multithreading is hard.
 Once you think you now understand it and are an expert, you are heading soon to another painful lesson that multithreading is hard. Dianne Hackborn April 2012
10. Push vs Pull
11. Observables event Iterable (pull) Observable (push) retrieve data T next() onNext(T) discover error throws Exception onError(Exception) complete !hasNext() onCompleted() Using the concept of “duality” we can derive the Observable type from an Iterable
12. onNext, onCompleted, onError An Observer implements a subset of the following methods: • onNext: We call this method whenever the Observable emits an item. • onError: Call this method to indicate that the Observable has failed and will not make further calls to onNext or onCompleted. • onCompleted: Call this method after you have called onNext for the final time and if we have not encountered any errors.
13. The “Subscribe” method
14. No Magic! • “Make the Magic go away” By Uncle Bob Martin: http://blog.8thlight.com/uncle-bob/2015/08/06/let- the-magic-die.html • Write a primitive Rx framework in JavaScript: http://reactivex.io/learnrx/
15. RxJava • It’s a JVM implementation of Reactive Extensions • Started at Netflix but now Open Sourced • Supports Java 6+ & Android 2.3+ • Java 8 lambda support
16. RxJava on Java 7 aObservable.filter(new Func1<Integer, Boolean>() { public Boolean call(Integer n) { return n % 2 == 0; } }) .map(new Func1<Integer, Integer>() { public Integer call(Integer n) { return n * n; } }) .subscribe(new Action1<Integer>() { public void call(Integer n) { System.out.println(n); } });
17. Retrolambda Retrolambda lets you take advantage of Java 8 features like lambda expressions, method references and try-with-resources statements on Java 7, 6 or 5. • Retrolambda • https://github.com/orfjackal/retrolambda • Gradle plugin • https://github.com/evant/gradle-retrolambda
18. RxJava using Retrolambda aObservable.filter(n -> n % 2 == 0) .map(n -> n * n) .subscribe(System.out::println);
19. Taken from https://gist.github.com/staltz/868e7e9bc2a7b8c1f754 by André Staltz
20. Operators in RxJava aObservable.map(x -> x*x) //Square .reduce((a, b) -> a+b) //Sum .subscribe(x -> println(x)); //Show
21. Marble diagrams Check out http://rxmarbles.com
22. Creating an Observable
23. Creating an Observable List<String> aList = ...; ob = Observable.create(subscriber -> { try { for (String s : aList) { if (subscriber.isUnsubscribed()) return; subscriber.onNext(s); } subscriber.onCompleted(); } catch (Exception e) { subscriber.onError(e); } });
24. Creating an Observable List<String> aList = ...; Observable<String> ob = Observable.from(aList);
25. Creating an Observable Observable<List<String>> ob = Observable.just(aList); Observable<String> ob2 = Observable.just("Some String");
26. Creating an Observable • repeat( ) • range( ) • interval( ) • timer( ) • empty( ) • error( ) • More at: https://github.com/ReactiveX/RxJava/wiki/Creating- Observables
27. Transforming Observables
28. Transforming Observables Observable.range(0, 5) .map(x -> toBinaryString(x*x)) .subscribe(s -> println(s), err -> err.printStackTrace(), () -> println("done")); 0 1 100 1001 10000 done
29. Transforming Observables
30. Transforming Observables 1 2 2 3 3 3 Observable.range(1, 3) .flatMap(x -> Observable.just(x).repeat(x)) .subscribe(System.out::println);
31. Filtering Observables
32. Filtering Observables 0 2 4 6 8 Observable.range(0, 10) .filter(x -> (x % 2) == 0) .subscribe(System.out::println);
33. Filtering Observables • distinct( ) • first( ) • take( ) • skip( ) • elementAt( ) • sample( ) • more... • More at: https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables
34. Aggregate Operators
35. Aggregate Operators 3628800 Observable.range(1, 10) .reduce((a, b) -> a*b) .subscribe(System.out::println);
36. Combining Observables
37. Combining Observables a_A b_B c_C Observable<String> lower = Observable.from(new String[]{"a", "b", "c"}); Observable<String> upper = Observable.from(new String[]{"A", "B", "C"}); Observable.zip(lower, upper, Pair::create) .map(pair -> pair.first +"_" +pair.second) .subscribe(System.out::println);
38. Schedulers • observeOn • specify on which Scheduler a Subscriber should observe the Observable • subscribeOn • specify which Scheduler an Observable should use when its subscription is invoked • https://github.com/ReactiveX/RxJava/wiki/ Scheduler
39. Backpressure • Backpressure is the situation in which an Observable is emitting items more rapidly than an operator or subscriber can consume them. • RxJava offers a variety of strategies like throttling with which you can exercise flow control in order to alleviate the problems caused by backpressure. • https://github.com/ReactiveX/RxJava/wiki/Backpressure
40. Hot and Cold Observables • A “cold” Observable waits to start emitting items until an observer subscribes, and so an observer can “observe” the whole sequence. • A “hot” Observable may begins emitting items as soon as it is created.
41. RxAndroid • Android specific bindings for RxJava. • https://github.com/ReactiveX/RxAndroid • Scheduler on main UI thread or a given Android Handler thread. • AndroidSchedulers • HandlerScheduler
42. RxAndroid
43. Summary • Embrace Reactive and Functional Thinking • Manipulating Streams of data simplifies how you think (and build) your apps. • RxJava is a powerful tool to improve your Android Code
44. Useful links • Grokking RxJava by Dan Lew: http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/ • Introduction to Reactive Programming by André Staltz https://gist.github.com/staltz/868e7e9bc2a7b8c1f754 • Guide to Rx Operators: http://reactivex.io/documentation/operators.html • RxJava docs: https://github.com/ReactiveX/RxJava/wiki/
45. We’re hiring! Senior Software Engineer - Android http://nflx.io/android-job Many more at: http://netflix.com/jobs
46. Thank You! Twitter: @_juandg Email: jgomez@netflix.com Lanyrd: lanyrd.com/profile/juandg/