The disaster of mutable state

1. The disaster of mutable state The disaster of mutable state

2. What’s the big deal 1. Referential transparency is super important 2. Effects and mutability do immense damage 3. How to write a pure core with a thin effectful crust What’s the big deal 1. Referential transparency is super important 2. Effects and mutability do immense damage 3. How to write a pure core with a thin effectful crust

3. Referential transparency • For the given inputs, we will always get the same outputs • Like a mathematical function • You can substitute an expression with its results Referential transparency • For the given inputs, we will always get the same outputs • Like a mathematical function • You can substitute an expression with its results

4. Benefits • Easier to reason about • Easier to test • Easier to compose & recombine • More modular • Safe caching • Share data with impunity • Thread-safe Benefits • Easier to reason about • Easier to test • Easier to compose & recombine • More modular • Safe caching • Share data with impunity • Thread-safe

5. Drawbacks? • Requires some discipline to maintain • If you break RT in one place, it ruins everything • Updating data requires copying data structures, which might be expensive (or not) Drawbacks? • Requires some discipline to maintain • If you break RT in one place, it ruins everything • Updating data requires copying data structures, which might be expensive (or not)

6. What’s off the menu? • Network/DB/File system I/O • Mutating state • Reading/observing state that can be mutated • Creating a mutable object • Reference equality • Time.now() • random() • Exceptions What’s off the menu? • Network/DB/File system I/O • Mutating state • Reading/observing state that can be mutated • Creating a mutable object • Reference equality • Time.now() • random() • Exceptions

7. Equational reasoning • Our starting point is no more complex than the final result, and can be replaced without changing the meaning • Order doesn’t matter 2 + (25 * 3) – 7 = 2 + 75 – 7 = 77 – 7 = 70 Equational reasoning • Our starting point is no more complex than the final result, and can be replaced without changing the meaning • Order doesn’t matter 2 + (25 * 3) – 7 = 2 + 75 – 7 = 77 – 7 = 70

8. Pure example def add(a,b) a + b end def mult(a,b) a * b end # Interchangeable # Evaluation order doesn’t matter add(4, mult(3,2)) add(4, 6) 10 Pure example def add(a,b) a + b end def mult(a,b) a * b end # Interchangeable # Evaluation order doesn’t matter add(4, mult(3,2)) add(4, 6) 10

9. Impure example mutavar = 0 def mult(num) mutavar *= num end def add(num) mutavar += num end # Cannot change order # Cannot substitute actions for results add(5) mult(2) add(-2) Impure example mutavar = 0 def mult(num) mutavar *= num end def add(num) mutavar += num end # Cannot change order # Cannot substitute actions for results add(5) mult(2) add(-2)

10. . Composition pure style! • Give input, check output • output = foo(bar(baz(input)))

11. . Composition pure style! • Give input, check output • output = foo(bar(baz(input)))

12. . Composition pure style! • Give input, check output • output = foo(bar(baz(input)))

13. . Composition pure style! • Put something inside another thing • output = foo(bar(baz(input)))

14. . Testing pure style! • Give input, check output • output == foo(bar(baz(input))) Give it one of these …and we get this?

15. . Composition mutable style

16. . Composition mutable style

17. . Composition mutable style

18. . Composition mutable style

19. . Composition mutable style

20. . Composition mutable style

21. . Composition mutable style

22. . Composition mutable style

23. . Composition mutable style

24. . Composition mutable style

25. . Composition mutable style

26. . Composition mutable style

27. . Composition mutable style

28. . Composition mutable style

29. . Composition mutable style • We need to fit every level of detail in our head! We can’t ignore anything. • Any level could fiddle with something that changes the whole • Non-modular • Not really “composition” in a true sense

30. . Testing mutable style! AKA “web of lies” MOCK – HANDLE WITH CARE MOCK – HANDLE WITH CARE If I say “Gerbil”, then you say “Party time!” And then you call my thing with a baked potato! The 3rd time I knock, then you put on a Darth Vader mask and breath heavily Let’s totally alter the fabric of space-time.

31. . Modularity (pure) What does this do? Elitist academic Ivory Tower genius

32. . Modularity (pure) What does this do? Elitist academic Ivory Tower genius

33. . Modularity (with side-effects) What does this do? Pragmatic real world coder who gets shit done

34. . Modularity (with side-effects) What does this do? Pragmatic real world coder who gets shit done

35. . Modularity (with side-effects) What does this do? Pragmatic real world coder who gets shit done

36. . Modularity (with side-effects) What does this do? Pragmatic real world coder who gets shit done

37. . Modularity (with side-effects) What does this do? Pragmatic real world coder who gets shit done Expected order 1) This 2) That 3) Depends 4) ??? 5) Touches here 6) Widdles the widget 7) Diddles the doobilacky Gets a bit hairy here Best we don’t modify this

38. . “I’m not smart enough to use mutable state!” - Functional programmers

39. . State, time & identity “But the real world is mutable!”

40. . State, time & identity samuel_l_jackson.hairstyle samuel_l_jackson.occupation

41. . State, time & identity samuel_l_jackson.hairstyle samuel_l_jackson.occupation => “bald” => “actor”

42. . State, time & identity samuel_l_jackson.hairstyle samuel_l_jackson.occupation => “bald” => “actor” ... in 2014

43. . State, time & identity samuel_l_jackson.hairstyle samuel_l_jackson.occupatio n => “afro” => “student” 1960s:

44. . State, time & identity “Samuel L Jackson” 1960 1970 1980 1990 2000 2010 H: “bald” O: “actor” H: “afro” O: “student” Identity

45. . State, time & identity • Mutable state implies identity • This totally changes the nature of the object • Identities refer to different states over time • Each state is eternal and immutable

46. . Arguably OK identity class ToyRobot attr_accessor :facing, :pos end

47. . Arguably OK identity • ToyRobot will hold many facing/position states over time • Robot’s identity is at least a meaningful concept

48. . Totally wrong and broken identity class Position attr_accessor :x, :y end

49. . Totally wrong and broken identity • A position can change under your feet! • What can it possibly mean?? • What use is an identity that strings together different Position states over time?

50. . Consider… class Integer attr_accessor :value def plus(n); value += n.value; end end three = Integer.new 3 three.value = 4 three.plus(three) 8