Functional Reactive Programming

A general introduction to Functional and Reactive programming

Transcript

1. Functional Reactive Programming @MariusBudin
3. Is this something new I should know about?
4. it’s NOT new
5. and YES, you should know about it
7. We’ll be talking about • Reactive programming • Functional programming • Why are they so cool together • How to cook a lasagna 45’
8. Reactive Programming
10. Yeah, that’s still 6
11. Yeah, that’s still 6
12. Yeah, that’s still 6
13. The value ‘10’ assigned to a is never used Yeah, that’s still 6
14. Reactive programming means this is true FOREVER
15. RP implies you have a datatype representing a value over time
16. If a changes over time and b = a + 1; then b will change over time
17. It’s actually that simple*
18. It’s actually that simple* * it’s not
19. Continuous processing: updating a display of changing data Coordinating concurrent computations is difficult and can involve complex synchronization patterns Long story…
20. State changes over time, and there are typically dependencies between data When one thing changes, the programmer must update everything that depends on it. Done by hand, this is a tedious and error-prone task. Long story…
21. Reacting to changes usually implies using callbacks, routines that perform imperative operations in response to events. Coordination within the resulting “callback soup” can be difficult, since numerous isolated code fragments end up manipulating the same data. Long story…
22. All* problems gone if this is true FOREVER Short story…
23. Functional Programming
24. It’s all about side-effects
25. NO side-effects
26. –Robert C. Martin (Uncle Bob) “Functional programming is programming without assignment statements.”
28. Each loop causes the variable i to take a new value
29. Each loop causes the variable i to take a new value This is assignment
30. The functional way (no assignments)
31. The functional way (no assignments) This is actually valid Clojure code :)
32. The functional way (no assignments) The program takes the first 25 elements of a list of the squares of sequential integers starting at 1
33. Referential Transparency The program takes the first 25 elements of a list of the squares of sequential integers starting at 1
35. Referential Transparency The program takes the first 25 elements of a list of the squares of sequential integers starting at 1
36. Referential Transparency The program takes the first 25 elements of a list of the squares of sequential integers starting at 1 you can replace the words in that sentence with their definitions, and not change the meaning
37. take(25, (squares-of (integers))) (1 4 9 16 25 36 49 64 ... 576 625) you can replace the words in that sentence with their definitions, and not change the meaning
38. take(25, (squares-of (1 2 3 …))) (1 4 9 16 25 36 49 64 ... 576 625) you can replace the words in that sentence with their definitions, and not change the meaning
39. take(25, (1 4 9 16 25 36 49…)) (1 4 9 16 25 36 49 64 ... 576 625) you can replace the words in that sentence with their definitions, and not change the meaning
40. (1 4 9 16 25 36 49 64 ... 576 625) (1 4 9 16 25 36 49 64 ... 576 625) you can replace the words in that sentence with their definitions, and not change the meaning
41. every time you invoke a particular function call, you will get the same result
42. every time you invoke a particular function call, you will get the same result Functional Programming
43. mathematical functions f(x) = x+2 Functional Programming
44. no changing-state no mutable data Functional Programming
45. Characteristic Imperative Functional Programmer focus How to perform tasks (algorithms) and how to track changes in state. What information is desired and what transformations are required. State changes Important Non-existent. Order of execution Important Low importance. Primary flow control Loops, conditionals, and function (method) calls. Function calls, including recursion. Primary manipulation unit Instances of structures or classes. Functions as first-class objects and data collections
46. Characteristic Imperative Functional Programmer focus How to perform tasks (algorithms) and how to track changes in state. What information is desired and what transformations are required. State changes Important Non-existent. Order of execution Important Low importance. Primary flow control Loops, conditionals, and function (method) calls. Function calls, including recursion. Primary manipulation unit Instances of structures or classes. Functions as first-class objects and data collections
47. Print the second string containing a “2” in upper case from an array of strings, print “none” if none found and log the error if something bad happens
48. Print the second string containing a “2” in upper case from an array of strings, print “none” if none found and log the error if something bad happens
49. Print the second string containing a “2” in upper case from an array of strings, print “none” if none found and log the error if something bad happens
50. Print the second string containing a “2” in upper case from an array of strings, print “none” if none found and log the error if something bad happens
51. Print the second string containing a “2” in upper case from an array of strings, print “none” if none found and log the error if something bad happens
52. Print the second string containing a “2” in upper case from an array of strings, print “none” if none found and log the error if something bad happens
53. Benefits of FP • Composability -> self-contained and stateless • Increased readability and maintainability -> each function is designed to accomplish a specific task given its arguments. The function does not rely on any external state. • Easier reiterative development -> the code is easier to refactor • Easier testing -> pure functions can more easily be tested in isolation, you can write test code that calls the pure function with typical values, valid edge cases, and invalid edge cases.
54. Functional Reactive Programming The Next Big Thing ®
55. FRP RP FP
56. FP • Based on functions (the mathematical sense of the word) • Deliberately avoids shared mutable state • Implies the use of inmutable data structures • Emphasizes composability Recap
57. RP • It’s event-based • Acts to input • Is a flow of data (value over time) Recap
58. FRP
59. FRP Love the bacon, love the ice cream…
60. not a methodology
61. A programming technique to improve your code in an area that just happens to be a common source of complexity (and therefore bugs): event propagation. What it IS
62. What it IS • A replacement for the observer pattern (callbacks/listeners) • A composable, modular way to code event-driven logic. • A way to bring order to the management of program state • A different way of thinking: The program is expressed as a reaction to its inputs, or as a flow of data.
63. • A replacement for the observer pattern (callbacks/listeners) • A composable, modular way to code event-driven logic. • A way to bring order to the management of program state • A different way of thinking: The program is expressed as a reaction to its inputs, or as a flow of data. What it IS what’s wrong with this?
64. Sources of bugs in listeners • Unpredictable order -> the order in which events are received can depend on the order you registered the listeners in. FRP makes the order not matter in most cases, and it makes it predictable in the rest. • Missed first event -> It can be difficult to guarantee that you have registered your listeners before you send the first event. FRP is transactional, so it is possible to provide this guarantee. • Messy state -> Callbacks push your code into a traditional state machine style, which gets messy fast. FRP brings order. • Threading issues -> Attempting to make listeners thread-safe can lead to deadlocks. FRP eliminates this issue. • Accidental recursion -> The order in which you update local state and notify listeners can be critical, and it's easy to make mistakes. FRP eliminates this issue.
65. FRP will appear a bit strange simple != easy to understand Paradigm shift
66. Thinking declaratively: What the program is, not what it does The key
67. Cook lasagna 1. Heat the oil in a large pan. 2. Fry the onions until golden. 3. Add ground beef and tomato. …. What your mind is telling you
68. Cook lasagna • Lasagna is grated cheese on cheese sauce on flat pasta on cheese sauce on bolognese on flat pasta on cheese sauce on bolognese on flat pasta on cheese sauce baked for 45 minutes. • Bolognese is onion and oil fried until golden mixed with ground beef mixed with tomato simmered for 20 minutes. • Cheese sauce is milk and cheese added progressively to roux while frying it until the sauce thickens. • Roux is flour and butter fried briefly. • Baked is put in an oven dish in a hot oven. • Fried is put in a pan on high and mixed frequently. • Simmered is put in a pan on low and mixed infrequently. The a-ha! moment
69. Cook lasagna • Lasagna is grated cheese on cheese sauce on flat pasta on cheese sauce on bolognese on flat pasta on cheese sauce on bolognese on flat pasta on cheese sauce baked for 45 minutes. • Bolognese is onion and oil fried until golden mixed with ground beef mixed with tomato simmered for 20 minutes. • Cheese sauce is milk and cheese added progressively to roux while frying it until the sauce thickens. • Roux is flour and butter fried briefly. • Baked is put in an oven dish in a hot oven. • Fried is put in a pan on high and mixed frequently. • Simmered is put in a pan on low and mixed infrequently. The a-ha! moment
70. bon appetit!
71. thanks @MariusBudin