FRP Talk given at LambdaJam Australia 2013

1. Taming asynchronous
workflows with Functional
Reactive Programming
LambdaJam - Brisbane, 2013
Leonardo Borges
@leonardo_borges
www.leonardoborges.com
www.thoughtworks.com
Friday, 17 May 13

2. Leonardo Borges
@leonardo_borges
www.leonardoborges.com
www.thoughtworks.com
• Thoughtworker
• Functional Programming enthusiast
• Clojure Evangelist
• Founder & Organiser of the Sydney
Clojure User Group (clj-syd)
• World traveller
• Fan of Murray’s Beers :)
about:me
Friday, 17 May 13

3. Functional programmers like
programming with values:
a, b, c...
and pure functions:
f, g, h...
Friday, 17 May 13

4. We get new values by applying
functions to it
(f a) ;;=> b
Friday, 17 May 13

5. But that’s hardly useful when
we have multiple values
(def vals [a b c])
Friday, 17 May 13

6. So we use Higher Order
Functions
(map f vals)
Friday, 17 May 13

7. And compose them as we see fit
(-> vals
(filter f)
(map g)
(reduce h))
Friday, 17 May 13

8. But what if the value isn’t
known...yet?
a?
Friday, 17 May 13

9. We make promises
;; thread#1
(def a (promise))
;; ...later in the program
(f @a) ;;<= blocks thread
;; thread#2
(deliver a 10) ;; now thread#1 continues
Friday, 17 May 13

10. Not great if we want to ‘react’
to a new value
Friday, 17 May 13

11. What about a list of - as of yet
unknown - values?
[a,b,c]? ? ?
Friday, 17 May 13

12. Or better yet, a value that
changes over time?
0
37.5
75
112.5
150
10s 20s 30s 40s 50s 60
Value
Time
Friday, 17 May 13

13. Does this sound familiar?
Friday, 17 May 13

14. Spreadsheets: a poor man’s
reactive programming model
Values
Function
Friday, 17 May 13

15. Spreadsheets: a poor man’s
reactive programming model
As we change
a value
Our function cell
reacts to the
change
Friday, 17 May 13

16. ‘Changing a value’ is an event
Several events over time form an
event stream
Friday, 17 May 13

17. “Functional Reactive
Programming is about effectively
processing event streams without
explicitly managing state”
- me
Friday, 17 May 13

18. “FRP is about handling time-
varying values like they were
regular values.”
- Haskell wiki
Friday, 17 May 13

19. We’ll use Reactive Extensions
(Rx) - but there are many
implementations
Friday, 17 May 13

20. In Rx, event streams are called
Observable sequences
Friday, 17 May 13

21. Rx 101
(-> (.returnValue js/Rx.Observable 42)
(.map #(* % 2))
(.subscribe #(.log js/console %)))
;; 84
Friday, 17 May 13

22. Rx 101
(-> (.fromArray js/Rx.Observable
(clj->js [10 20 30]))
(.map #(* % 2))
(.reduce +)
(.subscribe #(.log js/console %)))
;; 120
Friday, 17 May 13

23. Rx 101
(defn project-range [n]
(.returnValue js/Rx.Observable (range n)))
(-> (.fromArray js/Rx.Observable
(clj->js [1 2 3]))
(.selectMany project-range)
(.subscribe #(.log js/console (clj->js %))))
;; [0]
;; [0 1]
;; [0 1 2]
Friday, 17 May 13

24. Observables are Monads
Friday, 17 May 13

25. The Monad Type Class
class Monad m where
return :: a -> m a
(>>=) :: m a -> (a -> m b) -> m b
Friday, 17 May 13

26. Monad functions: return
return :: a -> m a
returnValue :: a -> Observable a
Friday, 17 May 13

27. (>>=) :: m a -> (a -> m b) -> m b
selectMany :: Observable a -> (a -> Observable b) -> Observable b
Monad functions: >>= (bind)
Friday, 17 May 13

28. Demo: Simple polling app
Friday, 17 May 13

29. Server exposes poll questions
and results
e.g.:
{:id 7
:question "Which is the best music style?"
:results {:a 10
:b 47
:c 17}}
Friday, 17 May 13

30. What we want
• Render results
• Continuously poll server every 2 secs
• If current question is the same as the previous one
update results;
• Otherwise:
• Stop polling;
• Display countdown message;
• Render new question and results;
• Restart polling;
Friday, 17 May 13

31. The core idea
Friday, 17 May 13

32. Turn server results into an
event stream
112334
Friday, 17 May 13

33. Duplicate stream, skipping one
112334
123345
skip 1
Friday, 17 May 13

34. Zip them together
112334
1
2
zip
2
3
3
3
3
4
4
5 1
123345
1
Friday, 17 May 13

35. Now we have access to both
the previous and current
results, with no local variables
Friday, 17 May 13

36. Show me the code!
https://github.com/leonardoborges/frp-code
Friday, 17 May 13

37. (def results-connectable
(let [obs (-> js/Rx.Observable
(.interval 2000)
(.selectMany results-observable)
(.publish)
(.refCount))
obs-1 (.skip obs 1)]
(.zip obs obs-1 (fn [prev curr]
{:prev prev
:curr curr}))))
Turn server results into an event stream
{
The core idea
Clone stream, skip one
Zip them together
{
Friday, 17 May 13

38. “FRP is about handling time-
varying values like they were
regular values.”
- Haskell wiki
Friday, 17 May 13

39. Questions?
Leonardo Borges
@leonardo_borges
www.leonardoborges.com
www.thoughtworks.com
Friday, 17 May 13

40. References
Code - https://github.com/leonardoborges/frp-code
RxJS - https://github.com/Reactive-Extensions/RxJS
RxJava - https://github.com/Netflix/RxJava
Other FRP implementations:
Reactive-banana - http://www.haskell.org/haskellwiki/Reactive-banana
Javelin (Clojurescript) - https://github.com/tailrecursion/javelin
Bacon.js - https://github.com/raimohanska/bacon.js
Friday, 17 May 13