2 Years of. Real World FP at Scala Developer at

Size: px

Start display at page:

Download "2 Years of. Real World FP at Scala Developer at"

Stephanie Lane
5 years ago
Views:

1 2 Years of λ Real World FP at Scala Developer at

2 Me 14 years 5 years 5 years when possible when bored when forced

3 @ - 3 teams - 17 codebases - 43K LOC Jul 13 Jan 14 Jul 14 Jan 15

4 Why Functional Programming?

5 Compelling, tangible software engineering benefits

6 Modularity Abstraction Composability

7 Modular, abstract, composable programs are simple programs

8 Modularity

9 Can you reason about something in isolation?

10 Or do you need to fit everything in your head at once?

11 A B C K Is the cost of replacing B with K just writing K?

12 A KB C Is the cost of replacing B with K just writing K?

13 glue A K KB glue C K or rewriting half the program?

14 A pure function is just input output; no side effects You can tell what it does without Looking at surrounding context.

15 Consider: Let s parse a string like Richmond, VIC 3121 def parselocation(str: String): Location = { val parts = str.split(, ) val secondstr = parts(1) val parts2 = secondstr.split( ) Location( parts(0), parts2(0), parts(1).toint) }

16 Possible errors: 1 def parselocation(str: String): Location = { val parts = str.split(, ) val secondstr = parts(1) val parts2 = secondstr.split( ) Location( parts(0), parts2(0), parts(1).toint) } Could be null

17 Possible errors: 2 def parselocation(str: String): Location = { val parts = str.split(, ) val secondstr = parts(1) val parts2 = secondstr.split( ) Location( parts(0), parts2(0), parts(1).toint) } Might not have enough elements

18 Possible errors: 3 def parselocation(str: String): Location = { val parts = str.split(, ) val secondstr = parts(1) val parts2 = secondstr.split( ) Location( parts(0), parts2(0), parts(1).toint) } Might not have enough elements

19 Possible errors: 4 def parselocation(str: String): Location = { val parts = str.split(, ) val secondstr = parts(1) val parts2 = secondstr.split( ) Location( parts(0), parts2(0), parts(1).toint) } Might not have enough elements

20 Possible errors: 5 def parselocation(str: String): Location = { val parts = str.split(, ) val secondstr = parts(1) val parts2 = secondstr.split( ) Location( parts(0), parts2(0), parts(1).toint) } Might not have enough elements

21 Possible errors: 6 def parselocation(str: String): Location = { val parts = str.split(, ) val secondstr = parts(1) val parts2 = secondstr.split( ) Location( parts(0), parts2(0), parts(1).toint) } Might not be an int

22 Possible errors: = 9 def dosomethingelse(): Unit = { //...Do other stuff parselocation( Melbourne, VIC 3000 ) } 3 6

23 Possible errors: = 13 def anotherthing(): Unit = { //...Do even more stuff dosomethingelse() } 4 9

24 Code inherits all the errors and side-effects of code it calls. Local reasoning becomes impossible; modularity is lost.

25 Possible errors: 0 def parselocation(str: String): Option[Location] = { val parts = str.split(,") for { locality <- parts.optget(0) thereststr <- parts.optget(1) therest = thereststr.split(" ") subdivision <- therest.optget(0) postcodestr <- therest.optget(1) postcode <- postcodestr.opttoint } yield Location(locality, subdivision, postcode) }

26 All possibilities have been elevated into the type system Local reasoning is possible! Local reasoning is possible about things that call it, etc

27 Abstraction

28 Know as little as you need

29 Know as little as you need Produce as little as you can

30 def sumints( list: List[Int]): Int = { } var result = 0 for (x <- list) { result = result + x } return result

31 def flatten[a]( list: List[List[A]]): List[A] = { } var result = List() for (x <- list) { result = result ++ x } return result

32 def all[a]( list: List[Boolean]): Boolean = { } var result = true for (x <- list) { result = result && x } return result

33 def sumints( list: List[Int]): Int = { } var result = 0 for (x <- list) { result = result + x } return result

34 def flatten[a]( list: List[List[A]]): List[A] = { } var result = List() for (x <- list) { result = result ++ x } return result

35 def all[a]( list: List[Boolean]): Boolean = { } var result = true for (x <- list) { result = result && x } return result

36 Extract the essence! trait Monoid[M] { def zero: M def append(m1: M, m2: M): M }

37 def fold[m](list: List[M]) (implicit m: Monoid[M]): M = { } var result = m.zero for (x <- list) { result = m.append(result,x) } result

38 def fold[m](list: List[M]) (implicit m: Monoid[M]): M = list.foldleft(m.zero)(m.append)

39 fold(list(1, 2, 3, 4)) 10 fold(list(list("a", "b"), List("c"))) List("a", "b", "c") fold(list(true, true, false, true)) false

40 Abstraction is always a good thing! Less repetition More reuse Less decay, because code can t grow tumours around unnecessary detail

41 Composability

42 Functions compose. A => B B => C C => D D => E

43 Functions compose. A => E

44 Sideways too. A => E X => Y

45 Sideways too. (A,X) => (E,Y)

46 This works in the large, as well as the small! Entire systems can be composable like functions. without side effects

47 Truly composable systems can accrue more and more stuff without getting more complex!

48 Simplicity Modularity Reason locally Abstraction say only what you need, hide everything you don t Composability scale without accruing complexity

49 The human process

50 Software GSD development is a Coffee Tea Quiet time human process Ponies Reconsider! Technical excellence isn t enough!

55 Xi an offshore team Team Team Team Team

56 Xi an offshore team Many teams are partly based in Xi an. They re very good, but Communication is hard! It works, but requires great investment of time and money

57 Bottom-up tech decisions

68 GET /buzz/5/ POST {"partytime": "5:00"} GET /foo/bar PUT {"mode": "banana"}

69 Architect Mountain

70 Architect Mountain

71 Architect Mountain

72 Architect Mountain Don t forget your velocity Just needs more Agile More meetings, but littler NO No no no no no no no no no no no no no no no no no no no no no no no no no no no no no no no no not like this. Wake up it s a school day

73 Bottom-up tech decisions You have to win

74 Bottom-up tech decisions You have to win

75 Bottom-up tech decisions You have to win

76 Software Paleontology Everyone s got a history

77 Scriptozoic era Mostly Perl

78 Monolithocene epoch Ruby, Java Scriptozoic era Mostly Perl

79 Microservices 2012 Ruby, Scala, JS AWS Monolithocene epoch Ruby, Java Scriptozoic era Mostly Perl

80 Adoption

81 June, 2013

85 λ

87 λ λ

88 λ λ λ

89 λ λ λ

90 λ λ

91 λ λ

92 λ

93 Language choice Object Oriented Functional Powerful static types JVM

94 Object Oriented Functional Powerful static types JVM

95 Functional JVM

96 Functional JVM

97 Functional JVM

98 Functional JVM

99 Whatever works for you!

100 The journey

101 Jul 13 Jan 14 1

102 #1 Type LOC Web JSON DB Dep Inj API 6K Play2 Play2 Squeryl / Play2 Constructors

103 #1 Type LOC Web JSON DB Dep Inj API 6K Play2 Play2 Squeryl / Play2 Constructors Learning Investment Mentor Code reviews

104 #1 Type LOC Web JSON DB Dep Inj API 6K Play2 Play2 Squeryl / Play2 Constructors Learning Investment Mentor Code reviews Report card Learning curve Technical result Productivity Sentiment Steep but ok Great; but FWs too heavy OK; slight dip

105 Jul 13 Jan Some infrastructure

106 #2 Type LOC Web JSON DB Dep Inj API 3K Play2 Argonaut Squeryl / Play2 Constructors

107 #2 Type LOC Web JSON DB Dep Inj API 3K Play2 Argonaut Squeryl / Play2 Constructors Learning Investment Almost none

108 #2 Type LOC Web JSON DB Dep Inj API 3K Play2 Argonaut Squeryl / Play2 Constructors!!! Learning Investment Almost none Report card Learning curve Technical result Productivity Sentiment Learning? Needed rework; OK in the end Meh

109 Lesson #1 New tech, mindset requires investment in learning Invest in your people!

110 λ

111 Another team! λ

112 λ We ll have some of that!

113 New team; new ideas! Jul 13 Jan

114 #3,4, 5,6 Type Web app, libs, API x 2 LOC 2K, 3K, 4K, 1K Web JSON DB Dep Inj Unfinagled Argonaut Slick Constructors Learning Investment 2 x Mentor Report card Learning curve Technical result Not bad Great Productivity Sentiment Great

115 Theft & innovation Jul 13 Jan 14 Jul

116 Lesson #2 Having multiple teams is great, because you can steal from each other

117 #7 Type LOC Web JSON DB Dep Inj API 4K Unfinagled Argonaut Slick Monad Transformers

118 #7 Type LOC Web JSON DB Dep Inj API 4K Unfinagled Argonaut Slick Monad Transformers Learning Investment 2 x Mentor

119 #7 Type LOC Web JSON DB Dep Inj API 4K Unfinagled Argonaut Slick Monad Transformers Learning Investment 2 x Mentor Report card Learning curve Technical result Vertical Great Productivity Sentiment Great

120 Monad Transformers Good technical benefits, but Only 2 people could understand the code Experienced engineers felt totally helpless Learning curve way too steep

121 Devops Gurus All-rounders

122 JS / CSS / HTML Gurus All-rounders

123 AWS Gurus All-rounders

124 Scala (originally!) Gurus

125 Scala (now) Gurus Smooth learning curve is utterly essential We need more allrounders We can t leave people behind All-rounders

126 Lesson #3 Familiar, but technically unsound concepts have limited value. However if we can t make a concept learnable, then we can t use it.

127 A Ruby team considers its options λ

128 λ

129 λ

130 A 3 rd team dips its toe in the water Jul 13 Jan 14 Jul

131 #8 Type LOC Web JSON DB Dep Inj Web app 2K Play2 Play2 Anorm Constructors

132 #8 Type LOC Web JSON DB Dep Inj Web app 2K Play2 Play2 Anorm Constructors Learning Investment Trial and error Code Katas

133 #8 Type LOC Web JSON DB Dep Inj Web app 2K Play2 Play2 Anorm Constructors Learning Investment Trial and error Code Katas Report card Learning curve Technical result Productivity Sentiment Steep OK Meh

134 Lesson #4 It s really hard learning from scratch Be prepared for pain up front

135 λ

136 Latest iteration Jul 13 Jan 14 Jul 14 Jan

137 Design trends Inheritance/mixins Static functions

138 Design trends Inheritance/mixins Partial functions Static functions Total functions

139 Design trends Inheritance/mixins Partial functions Exceptions Static functions Total functions Sum types

140 Design trends Inheritance/mixins Partial functions Exceptions Strings/primitives Static functions Total functions Sum types Wrapper types

141 FP Guild Every Thursday, in work hours 7 12 people each week Reading, exercises, talks, live coding

142 #17 Type LOC Web JSON DB Dep Inj API 3K Unfiltered Argonaut Slick Free Monads

143 #17 Type LOC Web JSON DB Dep Inj API 3K Unfiltered Argonaut Slick Free Monads Learning Investment 2 x Mentors Pull Requests Code reviews Pairing FP Guild

144 #17 Type LOC Web JSON DB Dep Inj API 3K Unfiltered Argonaut Slick Free Monads Learning Investment 2 x Mentors Pull Requests Code reviews Pairing FP Guild Report card Learning curve Technical result Productivity Sentiment Smooth Brilliant Great

145 App runtime Server Web Framework Interpreter Pure core Routes Controllers Logic Script Authenticate Use config Get from DB Update DB Log result Actual DB

146 Pure tests Input Output Assert Pure Interpreter Pure core Routes Controllers Logic Script Authenticate Use config Get from DB Update DB Log result

147 Wafer thin E2E tests App runtime Pure core Input Server Web Framework Interpreter Output Assert Actual DB

148 object SearchController { } def getlist(uid: UserId): Script[Response] = { for { searches <- getsearches(uid) cfg <- getconfig results <- addlinks(searches, cfg) } yield Ok ~> Response(result.toJson) }

149 Learning curve:

150 Learning curve: Smooooth

151 Mocks

152 Stubs

153 Flaky pretend servers just to check a response code

154 Flaky tests that take 30 min to run

155 Side effects everywhere

156 Exceptions

157 Intrusive DI frameworks

158 Most business software isn t rocket science. You shouldn t be dealing with all that complexity and crap!

159 There is a better way FP is a tall tree But there is so much low hanging fruit!

160 Thank you!

HOW WE MOVED FROM JAVA TO SCALA

HOW WE MOVED FROM JAVA TO SCALA Graham Tackley guardian.co.uk @tackers mostly HOW WE MOVED FROM ^ JAVA TO SCALA Graham Tackley guardian.co.uk @tackers History Java shop since 2006 guardian.co.uk: java