Intro to Functional Reactive Programming (Droidcon MTL 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() and reduce() 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 more straightforward, declarative fashion; making your life as an Android developer a lot easier.

Transcript

1. Functional Reactive Programming Juan Gomez
2. Intro Who am I? • Mobile Engineer at Netflix • Previously at Eventbrite and OneLouder Apps • Android & Python Developer
3. Agenda • Brief introduction to Rx and why we want to use it. • Observables and useful operators to transform Observables. • Brief introduction to RxAndroid.
4. 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
5. 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.
6. Functional Reactive Programming in Java aObservable.map(x -> x*x) //Square .reduce((a, b) -> a+b) //Sum .subscribe(x -> println(x)); //Show
7. Why Functional Reactive Programming • Writing concurrent programs correctly is difficult. • You can transform & compose asynchronous operations. • High-level abstractions • Standard error handling
8. Rx Family • C#: Rx.NET • JavaScript: RxJS • RxJava (Java, Scala, Groovy, Clojure, Kotlin) • Ruby: Rx.rb • Python: RxPY • More at: http://reactivex.io/
9. RxJava • It’s a JVM implementation of Reactive Extensions • Extends Observer pattern to support data/event and compose operators in abstract. • Started at Netflix • Supports Java 6+ & Android 2.3+ • Java 8 lambda support
10. Observables event Iterable (pull) Observable (push) retrieve data T next() onNext(T) discover error throws Exception onError(Exception) complete !hasNext() onCompleted() It’s like the GoF Observer++
11. Push vs Pull
12. Observer Pattern on Android
13. Android using RFP
15. 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); } });
16. Retrolambda Retrolambda lets you take advantage of Java 8 features like lambda expressions and method references on Java 7 or lower. • Retrolambda • https://github.com/orfjackal/retrolambda • Gradle plugin • https://github.com/evant/gradle-retrolambda
17. RxJava using Retrolambda aObservable.filter(n -> n % 2 == 0) .map(n -> n * n) .subscribe(System.out::println);
18. Creating an Observable
19. 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); } });
20. Creating an Observable List<String> aList = ...; Observable<String> ob = Observable.from(aList);
21. Creating an Observable Observable<List<String>> ob = Observable.just(aList); Observable<String> ob2 = Observable.just("Some String");
22. Creating an Observable • repeat( ) • range( ) • interval( ) • timer( ) • empty( ) • error( ) • More at: https://github.com/ReactiveX/RxJava/wiki/Creating- Observables
23. Transforming Observables
24. 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
25. Transforming Observables
26. Transforming Observables 1 2 2 3 3 3 Observable.range(1, 3) .flatMap(x -> Observable.just(x).repeat(x)) .subscribe(System.out::println);
27. Filtering Observables
28. Filtering Observables 0 2 4 6 8 Observable.range(0, 10) .filter(x -> (x % 2) == 0) .subscribe(System.out::println);
29. Filtering Observables • distinct( ) • first( ) • take( ) • skip( ) • elementAt( ) • sample( ) • more... • More at: https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables
30. Aggregate Operators
31. Aggregate Operators 3628800 Observable.range(1, 10) .reduce((a, b) -> a*b) .subscribe(System.out::println);
32. Combining Observables
33. 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);
34. Threading • 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
35. 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
36. 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.
37. RxAndroid • Android specific bindings for RxJava. • https://github.com/ReactiveX/RxAndroid • Scheduler on main UI thread or a given Android Handler thread. • AndroidSchedulers • HandlerThreadScheduler • Reactive components for common Android use cases and UI widgets • AndroidObservable • ViewObservable
38. Android Example /* API */ Observable<String> getFromServer(String key); Observable<String> getFromDB(String key); /* Code */ ViewObservable.clicks(btnClick) .map(x -> "myid") .observeOn(Schedulers.io()) .flatMap(this::getFromDB) .flatMap(this::getFromServer) .observeOn(AndroidSchedulers.mainThread()) .subscribe(x -> Toast.makeText(context, x, LENGTH_LONG).show());
39. Summary • Embrace Reactive and Functional Thinking • Manipulating Streams of Data simplifies who we think (and build) our programs. • RxJava is a powerful tool to improve your Android Code
40. Useful links • https://github.com/ReactiveX/RxJava/wiki/ • https://github.com/ReactiveX/RxAndroid • http://reactivex.io/documentation/operators.html • http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/ • https://gist.github.com/staltz/868e7e9bc2a7b8c1f754
41. Thank You! Twitter: @_juandg Email: jgomez@netflix.com Lanyrd: lanyrd.com/profile/juandg/