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.

Transcript

1. Intro to Functional
   Reactive Programming
   Juan Gomez
   

   View Slide

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?
   

   View Slide

3. Agenda
   • Brief introduction to Rx
   and why we want to
   use it.
   • Observables and useful
   operators to transform
   Observables.
   • Intermediate concepts
   around RxJava
   

   View Slide

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.
   

   View Slide

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”.
   

   View Slide

6. What are Reactive
   Extensions?
   • Abstracts away concerns about things like:
   ✦ low-level threading
   ✦ synchronization
   ✦ thread-safety
   ✦ concurrent data structures.
   

   View Slide

7. Rx Family
   • C#: Rx.NET
   • JavaScript: RxJS
   • RxJava (Java, Scala, Groovy, Clojure, Kotlin)
   • Ruby: Rx.rb
   • Python: RxPY
   • More at: http://reactivex.io/
   

   View Slide

8. Why Functional Reactive
   Programming
   • Writing concurrent programs correctly is difficult.
   • You can transform & compose asynchronous
   operations.
   • High-level abstractions
   • Standard error handling
   

   View Slide

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
   

   View Slide

10. Push vs Pull
    

    View Slide

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
    

    View Slide

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.
    

    View Slide

13. The “Subscribe” method
    

    View Slide

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/
    

    View Slide

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
    

    View Slide

16. RxJava on Java 7
    aObservable.filter(new Func1() {
    public Boolean call(Integer n) {
    return n % 2 == 0;
    }
    })
    .map(new Func1() {
    public Integer call(Integer n) {
    return n * n;
    }
    })
    .subscribe(new Action1() {
    public void call(Integer n) {
    System.out.println(n);
    }
    });
    

    View Slide

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
    

    View Slide

18. RxJava using Retrolambda
    aObservable.filter(n -> n % 2 == 0)
    .map(n -> n * n)
    .subscribe(System.out::println);
    

    View Slide

19. Taken from https://gist.github.com/staltz/868e7e9bc2a7b8c1f754 by André Staltz
    

    View Slide

20. Operators in RxJava
    aObservable.map(x -> x*x) //Square
    .reduce((a, b) -> a+b) //Sum
    .subscribe(x -> println(x)); //Show
    

    View Slide

21. Marble diagrams
    Check out http://rxmarbles.com
    

    View Slide

22. Creating an Observable
    

    View Slide

23. Creating an Observable
    List 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);
    }
    });
    

    View Slide

24. Creating an Observable
    List aList = ...;
    Observable ob = Observable.from(aList);
    

    View Slide

25. Creating an Observable
    Observable> ob = Observable.just(aList);
    Observable ob2 = Observable.just("Some String");
    

    View Slide

26. Creating an Observable
    • repeat( )
    • range( )
    • interval( )
    • timer( )
    • empty( )
    • error( )
    • More at: https://github.com/ReactiveX/RxJava/wiki/Creating-
    Observables
    

    View Slide

27. Transforming Observables
    

    View Slide

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
    

    View Slide

29. Transforming Observables
    

    View Slide

30. Transforming Observables
    1
    2
    2
    3
    3
    3
    Observable.range(1, 3)
    .flatMap(x -> Observable.just(x).repeat(x))
    .subscribe(System.out::println);
    

    View Slide

31. Filtering Observables
    

    View Slide

32. Filtering Observables
    0
    2
    4
    6
    8
    Observable.range(0, 10)
    .filter(x -> (x % 2) == 0)
    .subscribe(System.out::println);
    

    View Slide

33. Filtering Observables
    • distinct( )
    • first( )
    • take( )
    • skip( )
    • elementAt( )
    • sample( )
    • more...
    • More at: https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables
    

    View Slide

34. Aggregate Operators
    

    View Slide

35. Aggregate Operators
    3628800
    Observable.range(1, 10)
    .reduce((a, b) -> a*b)
    .subscribe(System.out::println);
    

    View Slide

36. Combining Observables
    

    View Slide

37. Combining Observables
    a_A
    b_B
    c_C
    Observable lower =
    Observable.from(new String[]{"a", "b", "c"});
    Observable upper =
    Observable.from(new String[]{"A", "B", "C"});
    Observable.zip(lower, upper, Pair::create)
    .map(pair -> pair.first +"_" +pair.second)
    .subscribe(System.out::println);
    

    View Slide

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
    

    View Slide

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
    

    View Slide

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.
    

    View Slide

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
    

    View Slide

42. RxAndroid
    

    View Slide

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
    

    View Slide

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/
    

    View Slide

45. We’re hiring!
    Senior Software
    Engineer - Android
    http://nflx.io/android-job
    Many more at:
    http://netflix.com/jobs
    

    View Slide

46. Thank You!
    Twitter: @_juandg
    Email: jgomez@netflix.com
    Lanyrd: lanyrd.com/profile/juandg/
    

    View Slide