Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Intro to Functional Reactive Programming (Droidcon NYC 2015)

Intro to Functional Reactive Programming (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.


Juan Gomez

August 28, 2015


  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 =

  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/