Refactoring to Functional. Hadi Hariri

Transcription

1 Refactoring to Functional Hadi Hariri

2 Functional Programming In computer science, functional programming is a programming paradigm, a style of building the structure and elements of computer programs, that treats computation as the evaluation of mathematical functions and avoids state and mutable data. It is a declarative programming paradigm, which means programming is done with expressions.

3 Let s refactor to functional

4 Wait. But why?

5 Goals Write less code. Write expressive code. Write correct code. Write performant code. (because Silicon Valley)

6 Be part of the in-crowd

7 Can I use any language?

8 What is a functional language?

9 A language with Functions as First-Class Citizens Higher-Order Functions Lambdas Top-level Functions* Immutable Data

10 I ll be using Kotlin. You can use Java 8, Java FJ, Scala, JavaScript, Clojure, Haskell, F#, C#, OCaml, Lisp.

11 Basic Function Syntax

12 Higher-Order Functions and Lambdas

13 Pure Functions Given same input, function always provides same output Execution does not cause observable side-effects Referential Transparency

14 Reduce moving parts

15 Aim for Pure Functions

16 Can we achieve our goals?

17

18

19 What s functional about that?

20 The Loops

21 Removing State

22 Some syntax sugar

23 Still emphasis on how, not what

24 Writing less code

25 Getting the data the way we need it

26 Transforming data

27 Again, let s write less

28 A more involved sample

29 The manual way

30 Once again, writing less code

31

32 Applying these techniques to common scenarios

33 Customer Search

34 Customer Search

35 Templates Patterns

36 Less boilerplate

37 Guaranteeing things take place

38 Guaranteeing things take place

39 Or when they take place

40 Strategy Pattern

41 Same strategy, less code

42 What about dependencies?

43 Let s think about dependencies in classes

44 When dependencies grow

45 How do we deal with dependencies?

46 We pass in the behaviour

47 Thinking Functionally

48 Functions are our primitives

49 We re merely combining functions

50 Functions taking functions filter - takes a predicate map - takes a mapping function groupby - takes a key lookup function

51 Functions returning functions

52 Pipelining

53 Keeping it readable Abstract multiple pipeline calls into descriptive functions Intermediate variables don t always help

54 How do we re-use?

55 Composing functions

56 Partial Function Applications

57 Partial Function Applications

58 Currying

59 Currying

60 And then there s the data

61 We re taking data and processing it in stages

62 What is our data? Customer Invoices Point Age

63 And what is this data? Scalars: Age, Date of Birth, Amount Collections of ATD s: List of Customers, List of Invoices, Set of Pairs

64 Take as input lists and output lists

65 Common List Operations map, flatmap, filter, findall, merge, zip..

66 And scalars can be obtained from lists

67 Common Scalar Operations first, last, find, aggregate..

68 Many functions boil down to folds fold, reduce, aggregate same thing.

69 What is fold? [ ] f(x,y) where x accumulator y element in list

70 What is fold? [ ] f(, ) =

71 What is fold? [ ] f(, ) =

72 What is fold? [ ] f(, ) =

73 What is fold? [ ] f(, ) =

74 What is fold? [ ] f(, ) =

75 What is fold? [ ] f(, ) =

76 Recursion, Pattern Matching and Folds

77 The Recursive Maximum

78 The Base is the accumulator

79 Immutability of the data

80 We need to avoid state Treat lists as infinite Allows for lazy evaluation, reactive programming Aim for immutability Create. Don t modify. There s a difference between ReadOnly and Immutable

81 What about Performance?

82 That Annoying Fibonacci

83 The Iterative Approach

84 Memoization

85 Recursion and Tail Calls

86 Converting to Tail Calls Memoization Tail Call Optimization

87 Tail Call Optimization

88 Inlining Higher-order functions can have performance impact Inlining functions can minimise performance impact

89 What about all that scary stuff?

90 Functors Collection of a whereby you can apply a function a -> b, returning collection of b map is a an example of Functor

91 Monads Abstract Data Type, following a series of rules Maybe Monad -> Option List Monad -> IEnumerable<T> (Iterable<T>) Promises

92 In Summary

93 Embrace Functions as Primitive Elements Focus on writing less your own code Focus on writing more descriptive code Focus on writing deterministic code Rocket Science

94 Recommended Books The Little Schemer Learn you a Haskell Functional Programming in Java

95 Thank you