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
Tweet

More Decks by Juan Gomez

Other Decks in Technology

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