Reactive programming: origins & ecosystem. Jonas Chapuis, Ph.D.

Size: px

Start display at page:

Download "Reactive programming: origins & ecosystem. Jonas Chapuis, Ph.D."

Rose Fisher
5 years ago
Views:

1 Reactive programming: origins & ecosystem Jonas Chapuis, Ph.D.

2 Timeline Functional Reactive Animation (Fran Library, Haskell) Rx 1.0 for.net, Erik Meijer & team at Microsoft Elm language Rx for Java, Netflix Reactive streams standard Rx on all platforms & many other libraries today

3 Reactive programming ecosystem Standardization group Rx.NET 4.0 Flows API.NET RxJava 2.0 Monix (scala) JVM hack RxJS 5.0 Cycle.js Project reactor PHP Web/JS dart streams Kafka Streams

4 ReactiveX (Rx) Everyday at the office functional reactive programming Integrates in imperative languages Strong support for error handling & testing Platforms C# Java JavaScript Scala C++ Python Ruby Swift

5 Origin of FRP Functional Reactive Animation ( 97), Conal Elliott & Paul Hudak Domain-specific language (DSL) for describing animations Vectorized description of movement sampling is done at rendering time (e.g. 60 images/second)

6 Behaviors: continuous values over time f(time) -> value waggle = cos (pi * time) wiggle = sin (pi * time) orbitandlater = orbit `over` later 1 orbit where orbit = movexy wiggle waggle jake patorbitscharlotte = stretch wiggle charlotte `over` movexy wiggle waggle pat Source: Fran library tutorial

7 Even in 3D! spiralturn = turn3 zvector3 (pi*time) (uniongs (map ball [1.. n])) where n = 40 ball i = withcolorg color ( move3 motion ( stretch3 0.1 spherelowres )) where motion = vector3spherical 1.5 (10*phi) phi phi = pi * fromint i / fromint n color = colorhsl (2*phi) Source: Fran library tutorial

8 Events: discrete values over time List[(time, value)] followmouseanddelay u = follow `over` later 1 follow where follow = move (mousemotion u) jake Source: Fran library tutorial

9 Reactive behavior: until behaviora until event -> behaviorb redblue u = buttonmonitor u `over` withcolor c circle where c = red `until` click u -=> blue redbluecycle u = buttonmonitor u `over` withcolor (cycle red blue u) circle where cycle c1 c2 u = c1 `until` nextuser_ click u ==> cycle c2 c1 Source: Fran library tutorial

10 First-order FRP (Elm) DSL for web apps (compiles to JavaScript) Purely functional Drives the Prezi fancy presentations web service Concept of Signal Infinite sequences of values over time (events) Signals keep their history No variable mutation, it s all events (event sourcing) Signals compose together with transforms to describe program flow Signal graphs are static: pipes cannot be rerouted at runtime. This makes for a deterministic program which allows time-travel and hot-swapping.

11 Source: FRP flavors by Elm creator Evan Czaplicki Inputs

12 Source: FRP flavors by Elm creator Evan Czaplicki Transformations

13 State

14 Example: hot-swapping super mario Super mario demo

15 Functional Reactive Programming (FRP) Explicit consideration of time (latency) Traditional program flow: no consideration of latency FRP program: allows writing code which accounts for latency time (scheduler)

Interrupt code after 5 min oh my final Runnable dosomelengthystuff = new Thread() { @Override public void run() { /* Do stuff here. */ } }; final ExecutorService executor = Executors.

16 Interrupt code after 5 min oh my final Runnable dosomelengthystuff = new Thread() public void run() { /* Do stuff here. */ } }; final ExecutorService executor = Executors.newSingleThreadExecutor(); final Future future = executor.submit(stufftodo); executor.shutdown(); // This does not cancel the already-scheduled task. try { future.get(5, TimeUnit.MINUTES); } catch (InterruptedException ie) { /* Handle the interruption. Or ignore it. */ } catch (ExecutionException ee) { /* Handle the error. Or ignore it. */ } catch (TimeoutException te) { /* Handle the timeout. Or ignore it. */ } if (!executor.isterminated()) executor.shutdownnow(); // If you want to stop the code that hasn't finished. TimeoutException!

17 Ok, how about this: Observable.fromCallable(() -> dosomelengthystuff()).timeout(5, TimeUnit.MINUTES).retry(3).subscribe( result => /*handle result*/, exception => /* definite failure after 3 attempts, handle here*/);

18 Functional Reactive Programming (FRP) Composition through functional programming flatmap:

19 Flavors of FRP Representation of time Discrete (most libraries) Continuous (academic) Composition Fixed (Elm) Dynamic (Rx) Drive Push-based (Rx) Pull-based (scala s FS2, Ix)

20 Four essential effects Pull (Synchronous/Interactive) Push (Asynchronous/Reactive) single value Object (or Failure) Promise (aka. Future, Task) multiple values Iterable (Array Set Map) Observable (aka. Stream, Publisher) FRP

21 Yin & Yang Pull (Iterable) Push (Observable) MoveNext() OnNext() In memory collections Database queries Generated sequences Message queues Event streams Asynchronous computations Asynchronous queries Asynchronous enumerations

22 Higher-order FRP: asynchronous data flow Dynamic graphs, thanks to Signals of Signals We can switch signals, create new signals, etc. Switching signals means we lose hot-swapping or timetravelling Since we can t preventively keep all history of signals we haven t created yet!

23 High-order FRP: flatmap Core operation required: flatmap() flatmap: Signal (Signal a) -> Signal a Diagram: Reactive Programming with RxJava, T. Nurkiewicz & Ben Chrisensen, O Reilly

24 RxJS + React + Redux demo Time travelling through redux event sourcing Cancellation support Debouncing, timeout, etc. Avoid event loops with one directional binding & rich actions and epics Testing asynchronicity (cancellation, timeout, errors)

25 Summary Nowadays strong ecosystem, paradigm of choice to program for the cloud

Coming up next Typescript: an introduction Declarative and functional programming: program without loops Synchronous and asynchronous programming: latency, callbacks, observer pattern, promises,

26 Coming up next Typescript: an introduction Declarative and functional programming: program without loops Synchronous and asynchronous programming: latency, callbacks, observer pattern, promises, async/await Functional reactive programming: observables and observers Rx operators and marble diagrams Generators, resource handling, hot and cold observables Concurrency and schedulers, virtual time and testing Error handling, resilience, scalability and backpressure Reactive architectures: react/redux, distributed systems, microservices, actors

Introduction to reactive programming. Jonas Chapuis, Ph.D.

Introduction to reactive programming Jonas Chapuis, Ph.D. Reactive programming is an asynchronous programming paradigm oriented around data flows and the propagation of change wikipedia Things happening