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

1fa9cb8c7997c8c4d3d251fb5e41f749?s=47 Realm
October 07, 2015

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.

1fa9cb8c7997c8c4d3d251fb5e41f749?s=128

Realm

October 07, 2015
Tweet

Transcript

  1. 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?
  2. 3.

    Agenda • Brief introduction to Rx and why we want

    to use it. • Observables and useful operators to transform Observables. • Intermediate concepts around RxJava
  3. 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.
  4. 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”.
  5. 6.

    What are Reactive Extensions? • Abstracts away concerns about things

    like: ✦ low-level threading ✦ synchronization ✦ thread-safety ✦ concurrent data structures.
  6. 7.

    Rx Family • C#: Rx.NET • JavaScript: RxJS • RxJava

    (Java, Scala, Groovy, Clojure, Kotlin) • Ruby: Rx.rb • Python: RxPY • More at: http://reactivex.io/
  7. 8.

    Why Functional Reactive Programming • Writing concurrent programs correctly is

    difficult. • You can transform & compose asynchronous operations. • High-level abstractions • Standard error handling
  8. 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
  9. 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
  10. 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.
  11. 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/
  12. 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
  13. 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); } });
  14. 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
  15. 18.

    RxJava using Retrolambda aObservable.filter(n -> n % 2 == 0)

    .map(n -> n * n) .subscribe(System.out::println);
  16. 20.

    Operators in RxJava aObservable.map(x -> x*x) //Square .reduce((a, b) ->

    a+b) //Sum .subscribe(x -> println(x)); //Show
  17. 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); } });
  18. 26.

    Creating an Observable • repeat( ) • range( ) •

    interval( ) • timer( ) • empty( ) • error( ) • More at: https://github.com/ReactiveX/RxJava/wiki/Creating- Observables
  19. 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
  20. 30.

    Transforming Observables 1 2 2 3 3 3 Observable.range(1, 3)

    .flatMap(x -> Observable.just(x).repeat(x)) .subscribe(System.out::println);
  21. 32.

    Filtering Observables 0 2 4 6 8 Observable.range(0, 10) .filter(x

    -> (x % 2) == 0) .subscribe(System.out::println);
  22. 33.

    Filtering Observables • distinct( ) • first( ) • take(

    ) • skip( ) • elementAt( ) • sample( ) • more... • More at: https://github.com/ReactiveX/RxJava/wiki/Filtering-Observables
  23. 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);
  24. 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
  25. 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
  26. 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.
  27. 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
  28. 42.
  29. 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
  30. 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/