Aslam Khan, profile picture
Uploaded byAslam Khan
KEY, PDF841 views

Not Quite Object Oriented

The document chronicles Aslam Khan's journey in programming, detailing a transition from object-oriented (OO) languages to functional programming (FP). It emphasizes the learning curve associated with grasping functional concepts through practical examples in languages like Haskell, Scala, and Clojure. The author's exploration involves writing parsers, implementing higher-order functions, and developing an understanding of functional programming principles like currying, monads, and list comprehensions.

Embed presentation

Downloaded 27 times
1 / 151
2 / 151
3 / 151
4 / 151
5 / 151
6 / 151
7 / 151
8 / 151
9 / 151
10 / 151
11 / 151
12 / 151
13 / 151
14 / 151
15 / 151
16 / 151
17 / 151
18 / 151
19 / 151
20 / 151
21 / 151
22 / 151
23 / 151
24 / 151
25 / 151
26 / 151
27 / 151
28 / 151
29 / 151
30 / 151
31 / 151
32 / 151
33 / 151
34 / 151
35 / 151
36 / 151
37 / 151
38 / 151
39 / 151
40 / 151
41 / 151
42 / 151
43 / 151
44 / 151
45 / 151
46 / 151
47 / 151
48 / 151
49 / 151
50 / 151
51 / 151
52 / 151
53 / 151
54 / 151
55 / 151
56 / 151
57 / 151
58 / 151
59 / 151
60 / 151
61 / 151
62 / 151
63 / 151
64 / 151
65 / 151
66 / 151
67 / 151
68 / 151
69 / 151
70 / 151
71 / 151
72 / 151
73 / 151
74 / 151
75 / 151
76 / 151
77 / 151
78 / 151
79 / 151
80 / 151
81 / 151
82 / 151
83 / 151
84 / 151
85 / 151
86 / 151
87 / 151
88 / 151
89 / 151
90 / 151
91 / 151
92 / 151
93 / 151
94 / 151
95 / 151
96 / 151
97 / 151
98 / 151
99 / 151
100 / 151
101 / 151
102 / 151
103 / 151
104 / 151
105 / 151
106 / 151
107 / 151
108 / 151
109 / 151
110 / 151
111 / 151
112 / 151
113 / 151
114 / 151
115 / 151
116 / 151
117 / 151
118 / 151
119 / 151
120 / 151
121 / 151
122 / 151
123 / 151
124 / 151
125 / 151
126 / 151
127 / 151
128 / 151
129 / 151
130 / 151
131 / 151
132 / 151
133 / 151
134 / 151
135 / 151
136 / 151
137 / 151
138 / 151
139 / 151
140 / 151
141 / 151
142 / 151
143 / 151
144 / 151
145 / 151
146 / 151
147 / 151
148 / 151
149 / 151
150 / 151
151 / 151
127.0.0.1 Aslam Khan :: @aslamkhn :: aslam.khan@factor10.com :: http://aslamkhan.net factor10
Not Quite Object Oriented a frustrating and incomplete journey from OO to FP Aslam Khan :: @aslamkhn :: +Aslam Khan :: factor10.com :: aslamkhan.net factor10
My journey in trying to write code it felt like a language journey, but it’s actually far from that
My journey in trying to write code it felt like a language journey, but it’s actually far from that In the beginning, I used C
My journey in trying to write code it felt like a language journey, but it’s actually far from that In the beginning, Procedural I used C C++
My journey in trying to write code it felt like a language journey, but it’s actually far from that In the beginning, Procedural Procedural I used C C++ Java
My journey in trying to write code it felt like a language journey, but it’s actually far from that Patterns In the beginning, Procedural Procedural and I used C C++ Java Polymorphism
My journey in trying to write code it felt like a language journey, but it’s actually far from that Java Patterns In the beginning, Procedural Procedural and Ruby I used C C++ Java Polymorphism C#
My journey in trying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C#
My journey in trying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript
My journey in trying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy JavaScript
My journey in trying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” JavaScript JavaScript
My journey in trying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” Haskell Tutorial JavaScript JavaScript on Parsers
My journey in trying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” Haskell Tutorial More functional JavaScript JavaScript on Parsers JavaScript
My journey in trying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” Haskell Tutorial More functional JavaScript JavaScript on Parsers JavaScript inspired to be more functional
My journey in trying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” Haskell Tutorial More functional JavaScript JavaScript on Parsers JavaScript inspired to be more functional Object Oriented Scala
My journey in trying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” Haskell Tutorial More functional JavaScript JavaScript on Parsers JavaScript inspired to be more functional Object Oriented Read Haskell Scala
My journey in trying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” Haskell Tutorial More functional JavaScript JavaScript on Parsers JavaScript inspired to be more functional Object Oriented More Read Haskell Scala Functional Scala
My journey in trying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” Haskell Tutorial More functional JavaScript JavaScript on Parsers JavaScript inspired to be more functional Object Oriented More Read Haskell Clojure Scala Functional Scala
My journey in trying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” Haskell Tutorial More functional JavaScript JavaScript on Parsers JavaScript inspired to be more functional Object Oriented More Long mental Read Haskell Clojure Scala Functional Scala journey ...
My functional learning loop Don’t forget the Haskell talk by Simon Peyton Jones on the Cool Languages Track Read about functional concepts in Haskell do this slowly … don’t rush!
My functional learning loop Don’t forget the Haskell talk by Simon Peyton Jones on the Cool Languages Track Read about functional concepts in Haskell do this slowly … don’t rush! Try the equivalent in Scala with some trivial example
My functional learning loop Don’t forget the Haskell talk by Simon Peyton Jones on the Cool Languages Track Read about functional concepts in Haskell do this slowly … don’t rush! Try the equivalent in Scala with some trivial example Try it on your project the essential parts of the problem and solution
My functional learning loop Don’t forget the Haskell talk by Simon Peyton Jones on the Cool Languages Track Read about functional concepts in Haskell do this slowly … don’t rush! Stuck ? Try the equivalent in Scala (impurity) or (ignorance) ? with some trivial example Try it on your project the essential parts of the problem and solution
My functional learning loop Don’t forget the Haskell talk by Simon Peyton Jones on the Cool Languages Track Read about functional concepts in Haskell do this slowly … don’t rush! Stuck ? Try the equivalent in Scala (impurity) or (ignorance) ? with some trivial example Try it on your project the essential parts of the problem and solution
The language of functional And there are quite a few new concepts to understand
The language of functional And there are quite a few new concepts to understand Currying Algebraic Types Closures Type Classes Monads High Order Functions Pattern Matching Monoids Functors Lambdas Polymorphic Functions List Comprehension
The language of functional And there are quite a few new concepts to understand Currying Closures Type Classes Monads Monoids Functors Lambdas Polymorphic Functions List Comprehension High Order Functions Algebraic Types Pattern Matching
Let’s write some Java Find all even integers in a range List<Integer> xs = range(1,20); List<Integer> evenRange = evens(xs);
Let’s write some Java Find all even integers in a range List<Integer> range(int start, int end) { List<Integer> xs = new ArrayList<Integer>(); for (int i = start; i < end + 1; i++) { xs.add(i); } return xs; } List<Integer> xs = range(1,20); List<Integer> evenRange = evens(xs);
Let’s write some Java Find all even integers in a range List<Integer> range(int start, int end) { List<Integer> xs = new ArrayList<Integer>(); for (int i = start; i < end + 1; i++) { xs.add(i); } return xs; } List<Integer> xs = range(1,20); List<Integer> evenRange = evens(xs); List<Integer> evens(List<Integer> xs) { List<Integer> keep = new ArrayList<Integer>(); for (Integer x : xs) { if (isEven(x)) keep.add(x); } return keep; }
Let’s write some Java Find all even integers in a range List<Integer> range(int start, int end) { List<Integer> xs = new ArrayList<Integer>(); for (int i = start; i < end + 1; i++) { xs.add(i); } return xs; } List<Integer> xs = range(1,20); List<Integer> evenRange = evens(xs); List<Integer> evens(List<Integer> xs) { List<Integer> keep = new ArrayList<Integer>(); for (Integer x : xs) { if (isEven(x)) keep.add(x); } return keep; } boolean isEven(Integer x) { return x % 2 == 0; }
The Haskell way? Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ]
The Haskell way? Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] function evens
The Haskell way? Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] function evens applied to xs
The Haskell way? Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] function evens applied to xs is a list
The Haskell way? Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] function evens applied to xs is a list for each x in xs
The Haskell way? Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] function evens applied to xs is a list for each x in xs where x is even
The Haskell way? Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] function evens applied to xs is a list for each x in xs where x is even for example: evens [1..20]
And in Scala list comprehensions are sometimes called for-comprehensions in Scala-land val evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x
And in Scala list comprehensions are sometimes called for-comprehensions in Scala-land val evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x evens
And in Scala list comprehensions are sometimes called for-comprehensions in Scala-land val evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x evens takes from a list xs
And in Scala list comprehensions are sometimes called for-comprehensions in Scala-land val evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x evens takes from a list xs each x
And in Scala list comprehensions are sometimes called for-comprehensions in Scala-land val evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x evens takes from a list xs each x in xs
And in Scala list comprehensions are sometimes called for-comprehensions in Scala-land val evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x evens takes from a list xs each x in xs where x is even
And in Scala list comprehensions are sometimes called for-comprehensions in Scala-land val evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x evens takes from a list xs each x in xs where x is even val even = (x:Int) => x % 2 == 0
And in Clojure Let’s use the built in “filter” function (defn evens [xs] (filter even? xs))
And in Clojure Let’s use the built in “filter” function (defn evens [xs] (filter even? xs)) evens
And in Clojure Let’s use the built in “filter” function (defn evens [xs] (filter even? xs)) evens applied to a list xs
And in Clojure Let’s use the built in “filter” function (defn evens [xs] (filter even? xs)) evens applied to a list xs applies the filter
And in Clojure Let’s use the built in “filter” function (defn evens [xs] (filter even? xs)) evens applied to a list xs applies the filter even? on xs
What if we have lots of “filters” Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] odds xs = [ x | x <- xs, odd x ]
What if we have lots of “filters” Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] odds xs = [ x | x <- xs, odd x ]
What if we have lots of “filters” Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] odds xs = [ x | x <- xs, odd x ] abstract the parts that change find f xs = [ x | x <- xs, f x ]
What if we have lots of “filters” Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] odds xs = [ x | x <- xs, odd x ] abstract the parts that change find f xs = [ x | x <- xs, f x ] using filter f
What if we have lots of “filters” Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] odds xs = [ x | x <- xs, odd x ] abstract the parts that change find f xs = [ x | x <- xs, f x ] using filter f on a list xs
What if we have lots of “filters” Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] odds xs = [ x | x <- xs, odd x ] abstract the parts that change find f xs = [ x | x <- xs, f x ] using filter f on a list xs for each x in xs
What if we have lots of “filters” Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] odds xs = [ x | x <- xs, odd x ] abstract the parts that change find f xs = [ x | x <- xs, f x ] using filter f on a list xs for each x in xs where x satisfies the filter f
High Order Functions helps you get DRY and leads to clean compositions val find = (predicate :Int => Boolean, xs :List[Int]) => for (x <- xs; if predicate(x)) yield x val even = (x :Int) => x % 2 == 0 val odd = (x :Int) => x % 2 == 1
High Order Functions helps you get DRY and leads to clean compositions val find = (predicate :Int => Boolean, xs :List[Int]) => for (x <- xs; if predicate(x)) yield x use any function which we locally call predicate val even = (x :Int) => x % 2 == 0 val odd = (x :Int) => x % 2 == 1
High Order Functions helps you get DRY and leads to clean compositions val find = (predicate :Int => Boolean, xs :List[Int]) => for (x <- xs; if predicate(x)) yield x use any function which we as long as the provided function takes an locally call predicate integer and returns a boolean val even = (x :Int) => x % 2 == 0 val odd = (x :Int) => x % 2 == 1
High Order Functions helps you get DRY and leads to clean compositions val find = (predicate :Int => Boolean, xs :List[Int]) => for (x <- xs; if predicate(x)) yield x use any function which we as long as the provided function takes an locally call predicate integer and returns a boolean val even = (x :Int) => x % 2 == 0 val odd = (x :Int) => x % 2 == 1
High Order Functions helps you get DRY and leads to clean compositions val find = (predicate :Int => Boolean, xs :List[Int]) => for (x <- xs; if predicate(x)) yield x use any function which we as long as the provided function takes an locally call predicate integer and returns a boolean val even = (x :Int) => x % 2 == 0 val odd = (x :Int) => x % 2 == 1 for example find(even, List.range(0,21)) find(odd, List.range(0,21))
And in Clojure notice how we compose more powerful functions from smaller functions (defn find [predicate, xs] (filter predicate xs))
And in Clojure notice how we compose more powerful functions from smaller functions (defn find [predicate, xs] (filter predicate xs)) function
And in Clojure notice how we compose more powerful functions from smaller functions (defn find [predicate, xs] (filter predicate xs)) function for example (find odd? [1,2,3,4]) (find even? [1,2,3,4])
Let’s apply this learning how can we model a few rules?
Let’s apply this learning how can we model a few rules? Non Substitutable have to downcast to get the specific type
Let’s apply this learning how can we model a few rules? Non Substitutable have to downcast to get the specific type
Let’s apply this learning how can we model a few rules? Non Substitutable Semantically Wrong have to downcast to get how can a FixedTime the specific type project be over budget?
It’s the rules that vary In Java, using the strategy patterns
It’s the rules that vary In Java, using the strategy patterns class Project { public boolean check(CheckProjectRule rule) { return rule.check(this); } }
It’s the rules that vary In Java, using the strategy patterns class Project { public boolean check(CheckProjectRule rule) { return rule.check(this); } } interface ProjectRule { public boolean check(Project p); }
It’s the rules that vary In Java, using the strategy patterns class Project { public boolean check(CheckProjectRule rule) { return rule.check(this); } } interface ProjectRule { public boolean check(Project p); } class OverdueProjectRule implements ProjectRule { ... public boolean check(Project p) { return p.getEndDate().isBefore(today()); } }
In Scala Using high order functions
In Scala Using high order functions class Project { val check = (rule :Prj => Boolean) => rule(this) }
In Scala Using high order functions class Project { val check = (rule :Prj => Boolean) => rule(this) } val overBudgetRule = (p :Project) => p.costToDate() > p.budget()
In Scala Using high order functions class Project { val check = (rule :Prj => Boolean) => rule(this) } val overBudgetRule = (p :Project) => p.costToDate() > p.budget() val overdueProjectRule = (p :Project) => p.getEndDate().isBefore(today()) The Strategy Pattern is not needed because of high order functions
A Model for Shapes Shape abstract area() Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) Square Square(x, y, l) It’s easy to imagine what the Java code will look like
Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) Square Square(x, y, l)
Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) Square Square(x, y, l)
Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) Square Square(x, y, l)
Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) Square Square(x, y, l)
Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) area :: Shape -> Float Square Square(x, y, l)
Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) area :: Shape -> Float area (Circle _ _ r) = pi * r^2 Square area (Rectangle _ _ w h) = w * h Square(x, y, l) area (Square _ _ l) = l * l
Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) area :: Shape -> Float area (Circle _ _ r) = pi * r^2 Square area (Rectangle _ _ w h) = w * h Square(x, y, l) area (Square _ _ l) = l * l
Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) area :: Shape -> Float area (Circle _ _ r) = pi * r^2 Square area (Rectangle _ _ w h) = w * h Square(x, y, l) area (Square _ _ l) = l * l
Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) area :: Shape -> Float area (Circle _ _ r) = pi * r^2 Square area (Rectangle _ _ w h) = w * h Square(x, y, l) area (Square _ _ l) = l * l Algebraic Types used to construct values for specific cases
Shapes in Scala
Shapes in Scala sealed abstract class Shape
Shapes in Scala sealed abstract class Shape case class Circle( x: Int, y :Int, r :Int) extends Shape
Shapes in Scala sealed abstract class Shape case class Circle( x: Int, y :Int, r :Int) extends Shape case class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shape
Shapes in Scala sealed abstract class Shape case class Circle( x: Int, y :Int, r :Int) extends Shape case class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shape case class Square(x :Int, y:Int, l :Int) extends Shape
Shapes in Scala Algebraic Types to describe how to construct alternatives sealed abstract class Shape case class Circle( x: Int, y :Int, r :Int) extends Shape case class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shape case class Square(x :Int, y:Int, l :Int) extends Shape
Shapes in Scala Algebraic Types to describe how to construct alternatives sealed abstract class Shape case class Circle( x: Int, y :Int, r :Int) extends Shape case class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shape case class Square(x :Int, y:Int, l :Int) extends Shape Pattern Matching to specify use cases based on values
Shapes in Scala Algebraic Types to describe how to construct alternatives sealed abstract class Shape case class Circle( x: Int, y :Int, r :Int) extends Shape case class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shape case class Square(x :Int, y:Int, l :Int) extends Shape Pattern Matching to specify use cases based on values val area : Shape => Int = _ match { }
Shapes in Scala Algebraic Types to describe how to construct alternatives sealed abstract class Shape case class Circle( x: Int, y :Int, r :Int) extends Shape case class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shape case class Square(x :Int, y:Int, l :Int) extends Shape Pattern Matching to specify use cases based on values val area : Shape => Int = _ match {     case Circle( _, _, radius ) => Pi * ( pow( radius, 2.0 ) )      case Rectangle( _, _, width, height ) => width * height      case Square( _, _, length ) => length * length }
Shapes in Scala Algebraic Types to describe how to construct alternatives sealed abstract class Shape case class Circle( x: Int, y :Int, r :Int) extends Shape case class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shape case class Square(x :Int, y:Int, l :Int) extends Shape Pattern Matching to specify use cases based on values val area : Shape => Int = _ match {     case Circle( _, _, radius ) => Pi * ( pow( radius, 2.0 ) )      case Rectangle( _, _, width, height ) => width * height      case Square( _, _, length ) => length * length case Rectangle( _, _, 1, height ) => height case Rectangle( _, _, width, 1 ) => width }
What has been our journey so far? Maybe we should apply it to something a bit more substantial List Comprehension
What has been our journey so far? Maybe we should apply it to something a bit more substantial List Comprehension High Order Functions
What has been our journey so far? Maybe we should apply it to something a bit more substantial List Comprehension High Order Functions Algebraic Types
What has been our journey so far? Maybe we should apply it to something a bit more substantial List Comprehension High Order Functions Algebraic Types Pattern Matching
A better model for a Project Using the composite pattern Activity Phase Milestone Task Project
A better model for a Project Using the composite pattern Activity Phase Milestone Task Project
A better model for a Project Using the composite pattern Activity Phase Milestone Task Project
A better model for a Project Using the composite pattern sealed abstract class Activity Activity Phase Milestone Task Project
A better model for a Project Using the composite pattern sealed abstract class Activity Activity case class Task(description: String, person :String) extends Activity Phase Milestone Task Project
A better model for a Project Using the composite pattern sealed abstract class Activity Activity case class Task(description: String, person :String) extends Activity case class Milestone(name :String) extends Activity Phase Milestone Task Project
A better model for a Project Using the composite pattern sealed abstract class Activity Activity case class Task(description: String, person :String) extends Activity case class Milestone(name :String) extends Activity case class Project(name :String) extends Activity lazy val activities = List ( Phase(1), Phase Milestone Task Project Task("Develop", "Peter"), Milestone("Release to UAT"), ) }
A better model for a Project Using the composite pattern sealed abstract class Activity Activity case class Task(description: String, person :String) extends Activity case class Milestone(name :String) extends Activity case class Project(name :String) extends Activity lazy val activities = List ( Phase(1), Phase Milestone Task Project Task("Develop", "Peter"), Milestone("Release to UAT"), ) } case class Phase(phaseNumber :Int) extends Activity
A better model for a Project Using the composite pattern sealed abstract class Activity Activity case class Task(description: String, person :String) extends Activity case class Milestone(name :String) extends Activity case class Project(name :String) extends Activity lazy val activities = List ( Phase(1), Phase Milestone Task Project Task("Develop", "Peter"), Milestone("Release to UAT"), ) } case class Phase(phaseNumber :Int) extends Activity
A better model for a Project Using the composite pattern sealed abstract class Activity Activity trait ManyActivities { def activities :Seq[Activity] } case class Task(description: String, person :String) extends Activity case class Milestone(name :String) extends Activity case class Project(name :String) extends Activity lazy val activities = List ( Phase(1), Phase Milestone Task Project Task("Develop", "Peter"), Milestone("Release to UAT"), ) } case class Phase(phaseNumber :Int) extends Activity
A better model for a Project Using the composite pattern sealed abstract class Activity Activity trait ManyActivities { def activities :Seq[Activity] } case class Task(description: String, person :String) extends Activity case class Milestone(name :String) extends Activity case class Project(name :String) extends Activity with ManyActivities { lazy val activities = List ( Phase Milestone Task Project Phase(1), Task("Develop", "Peter"), Milestone("Release to UAT"), ) } case class Phase(phaseNumber :Int) extends Activity
A better model for a Project Using the composite pattern sealed abstract class Activity Activity trait ManyActivities { def activities :Seq[Activity] } case class Task(description: String, person :String) extends Activity case class Milestone(name :String) extends Activity case class Project(name :String) extends Activity with ManyActivities { lazy val activities = List ( Phase Milestone Task Project Phase(1), Task("Develop", "Peter"), Milestone("Release to UAT"), ) } case class Phase(phaseNumber :Int) extends Activity with ManyActivities { val activities = List( Task("Analysis", "John"), Milestone("Ready for Development") ) }
A better model for a Project Using the composite pattern sealed abstract class Activity Activity trait ManyActivities { def activities :Seq[Activity] } case class Task(description: String, person :String) extends Activity case class Milestone(name :String) extends Activity case class Project(name :String) extends Activity with ManyActivities { lazy val activities = List ( Phase Milestone Task Project Phase(1), Task("Develop", "Peter"), Milestone("Release to UAT"), ) unapply() is an Extractor for } algebraic types object ManyActivities { case class Phase(phaseNumber :Int) extends Activity def unapply(a :Activity) = { with ManyActivities { a match { val activities = List( case (a :ManyActivities) => Some(a.activities) Task("Analysis", "John"), case _ => None Milestone("Ready for Development") } ) } } }
Actions for this project Using the visitor pattern Activity process (Action) Phase Milestone Task Project Action for_Phase() for_Milestone() for_Task() for_Project() Plan Start Status Celebrate
Actions for this project Using the visitor pattern Activity process (Action) Phase Milestone Task Project Action for_Phase() for_Milestone() for_Task() for_Project() Plan Start Status Celebrate
With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } Action for_Phase() for_Milestone() for_Task() for_Project() Plan Start Status Celebrate
With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } Action for_Phase() for_Milestone() for_Task() for_Project() Plan Start Status Celebrate
With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } Action for_Phase() for_Milestone() for_Task() for_Project() Plan Start Status Celebrate
With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } Action for_Phase() for_Milestone() for_Task() for_Project() Plan Start Status Celebrate
With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } def plan(a :Activity) { Action a match { for_Phase() for_Milestone() case Task(description, person) => { ... } for_Task() case Phase(number) => { ... } for_Project() case Milestone(name) => { ... } case Project(name) => { ... } } Plan Start Status Celebrate }
With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } def plan(a :Activity) { Action a match { for_Phase() for_Milestone() case Task(description, person) => { ... } for_Task() case Phase(number) => { ... } for_Project() case Milestone(name) => { ... } case Project(name) => { ... } } Plan Start Status Celebrate }
With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } def plan(a :Activity) { Action a match { for_Phase() for_Milestone() case Task(description, person) => { ... } for_Task() case Phase(number) => { ... } for_Project() case Milestone(name) => { ... } case Project(name) => { ... } } Plan Start Status Celebrate }
With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } def plan(a :Activity) { Action a match { for_Phase() for_Milestone() case Task(description, person) => { ... } for_Task() case Phase(number) => { ... } for_Project() case Milestone(name) => { ... } case Project(name) => { ... } } Plan Start Status Celebrate }
With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } def plan(a :Activity) { Action a match { for_Phase() for_Milestone() case Task(description, person) => { ... } for_Task() case Phase(number) => { ... } for_Project() case Milestone(name) => { ... } case Project(name) => { ... } } Plan Start Status Celebrate }
With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { val prj = Project("HelloWorld") (Action) process case ManyActivities(activities) => activities.foreach(process(action)) case _ => () process(plan)(prj) } action(a) } process(start)(prj) Phase Milestone Task Project } def plan(a :Activity) { Action a match { for_Phase() for_Milestone() case Task(description, person) => { ... } for_Task() case Phase(number) => { ... } for_Project() case Milestone(name) => { ... } case Project(name) => { ... } } Plan Start Status Celebrate }
With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { val prj = Project("HelloWorld") (Action) process case ManyActivities(activities) => activities.foreach(process(action)) case _ => () process(plan)(prj) } action(a) } process(start)(prj) Phase Milestone Task Project } def plan(a :Activity) { Action a match { for_Phase() for_Milestone() case Task(description, person) => { ... } for_Task() case Phase(number) => { ... } for_Project() Next Steps case Milestone(name) => { ... } Look at Haskell type classes and Scala implicit case Project(name) => { ... } def for polymorphic functions } Plan Start Status Celebrate }
Can you take the same journey with Clojure? Use each step to build confidence, and go pure if you are stuck Read about functional concepts in Haskell do this slowly … don’t rush! Stuck ? Try equivalent in Clojure (impurity of Clojure) or (my ignorance) ? with some trivial example Try it on your project the essential parts of the problem and solution
Some changes in thinking as a result of going on this functional journey Simple Structures Simple Transformations and lists and dictionaries list comprehensions, map, reduce
Some changes in thinking as a result of going on this functional journey Simple Structures Simple Transformations and lists and dictionaries list comprehensions, map, reduce Find a starting set of elements [ a, b, c, d, e, f ]
Some changes in thinking as a result of going on this functional journey Simple Structures Simple Transformations and lists and dictionaries list comprehensions, map, reduce Find a starting set of elements [ a, b, c, d, e, f ] Transform to what you need [ (a, b), (c,d) (e, f) ]
Some changes in thinking as a result of going on this functional journey Simple Structures Simple Transformations and lists and dictionaries list comprehensions, map, reduce Find a starting set of elements [ a, b, c, d, e, f ] Transform to what you need [ (a, b), (c,d) (e, f) ] Filter to get what you want [(c,d)]
Other things I work hard at Stop thinking about Remind myself of and interactions between objects values of data and transformations
Other things I work hard at Stop thinking about Remind myself of and interactions between objects values of data and transformations Keep it immutable with val var feels dirty in Scala
Other things I work hard at Stop thinking about Remind myself of and interactions between objects values of data and transformations Keep it immutable with val var feels dirty in Scala No unexpected side effects
Other things I work hard at Stop thinking about Remind myself of and interactions between objects values of data and transformations Keep it immutable with val var feels dirty in Scala No unexpected side effects Always return something makes me consider every branch
Benefits that I’ve observed and some that I have an anticipation that will happen
Benefits that I’ve observed and some that I have an anticipation that will happen DRY, really DRY more than I expected
Benefits that I’ve observed and some that I have an anticipation that will happen DRY, really DRY more than I expected Very declarative makes it very readable too
Benefits that I’ve observed and some that I have an anticipation that will happen DRY, really DRY more than I expected Very declarative makes it very readable too Some OO patterns disappear into trivial implementations
Benefits that I’ve observed and some that I have an anticipation that will happen DRY, really DRY more than I expected Very declarative makes it very readable too Some OO patterns disappear into trivial implementations Very testable small, immutable, side-effect free
Benefits that I’ve observed and some that I have an anticipation that will happen DRY, really DRY more than I expected Very declarative makes it very readable too Some OO patterns disappear into trivial implementations Very testable small, immutable, side-effect free Modular with excellent composition
How I now think about code Primitive expressions food, I, put, my, mouth, in A means of combination I put food in my mouth A means of abstraction I eat This is the basics of understanding and organisation of thought
Programs are the same they express our understanding and show the organisation of our thoughts
Programs are the same they express our understanding and show the organisation of our thoughts Think large static structures
Programs are the same they express our understanding and show the organisation of our thoughts Think large Think static small structures composable structures
Programs are the same they express our understanding and show the organisation of our thoughts Th ink la rge st atic ctu res or Think stru small composable structures
The language of functional And there are quite a few new concepts to understand Currying Algebraic Types Closures Type Classes Monads High Order Functions Pattern Matching Monoids Functors Lambdas Polymorphic Functions List Comprehension
My functional learning loop Don’t forget the Haskell talk by Simon Peyton Jones on the Cool Languages Track Read about functional concepts in Haskell do this slowly … don’t rush! Stuck ? Try the equivalent in Scala (impurity) or (ignorance) ? with some trivial example Try it on your project the essential parts of the problem and solution
What How do you want to build? factor10.com :: @aslamkhn :: aslamkhan.net

More Related Content

PDF
Einführung in die funktionale Programmierung
byDigicomp Academy AG
 
PDF
Functional Principles for OO Developers
byjessitron
 
PDF
Intro to J Ruby
byFrederic Jean
 
PDF
JRuby, Not Just For Hard-Headed Pragmatists Anymore
byErin Dees
 
PDF
DEVCON1 - BooJs
byIván Montes
 
PDF
Write Your Own JVM Compiler
byErin Dees
 
PDF
OpenThink Labs Training : Diving into Java, The Head First Way
byWildan Maulana
 
PDF
Tjava10a
byMeenakshi Chandrasekaran
 
Einführung in die funktionale Programmierung
byDigicomp Academy AG
 
Functional Principles for OO Developers
byjessitron
 
Intro to J Ruby
byFrederic Jean
 
JRuby, Not Just For Hard-Headed Pragmatists Anymore
byErin Dees
 
DEVCON1 - BooJs
byIván Montes
 
Write Your Own JVM Compiler
byErin Dees
 
OpenThink Labs Training : Diving into Java, The Head First Way
byWildan Maulana
 
Tjava10a
byMeenakshi Chandrasekaran
 

Similar to Not Quite Object Oriented

PDF
Java Programming
byTracy Clark
 
KEY
Java Building Blocks
byCate Huston
 
PPTX
SAD14 - The Nuts and Bolts
byMichael Heron
 
PPT
Introduction to Software Development
byZeeshan MIrza
 
DOC
6010 java programming version 6
bybestip
 
PDF
Ruby an overall approach
byFelipe Schmitt
 
PPTX
Java Starting
byRaja Sekhar
 
PDF
Ruby — An introduction
byGonçalo Silva
 
PPTX
10 Reasons Your Software Sucks - Election 2012 Edition
byCaleb Jenkins
 
PDF
What is new and cool j2se & java
byEugene Bogaart
 
PDF
Intro to c# (vs. objective c and java)
byJohn Smith
 
PDF
Intro to c# (vs. objective c and java)
byWes Yanaga
 
PDF
Mixing Source and Bytecode: A Case for Compilation By Normalization (OOPSLA 2...
bylennartkats
 
PDF
Ruby1_full
bytutorialsruby
 
PDF
Ruby1_full
bytutorialsruby
 
PDF
It's the end of design patterns as we know it (and i feel fine)
byLuiz Borba
 
PPT
Dr archana dhawan bajaj - c# dot net
byDr-archana-dhawan-bajaj
 
KEY
U Xml Defense presentation
byksp4186
 
PDF
Appengine ja-night-10
byJohn Woodell
 
PPTX
Why learn new programming languages
byJonas Follesø
 
Java Programming
byTracy Clark
 
Java Building Blocks
byCate Huston
 
SAD14 - The Nuts and Bolts
byMichael Heron
 
Introduction to Software Development
byZeeshan MIrza
 
6010 java programming version 6
bybestip
 
Ruby an overall approach
byFelipe Schmitt
 
Java Starting
byRaja Sekhar
 
Ruby — An introduction
byGonçalo Silva
 
10 Reasons Your Software Sucks - Election 2012 Edition
byCaleb Jenkins
 
What is new and cool j2se & java
byEugene Bogaart
 
Intro to c# (vs. objective c and java)
byJohn Smith
 
Intro to c# (vs. objective c and java)
byWes Yanaga
 
Mixing Source and Bytecode: A Case for Compilation By Normalization (OOPSLA 2...
bylennartkats
 
Ruby1_full
bytutorialsruby
 
Ruby1_full
bytutorialsruby
 
It's the end of design patterns as we know it (and i feel fine)
byLuiz Borba
 
Dr archana dhawan bajaj - c# dot net
byDr-archana-dhawan-bajaj
 
U Xml Defense presentation
byksp4186
 
Appengine ja-night-10
byJohn Woodell
 
Why learn new programming languages
byJonas Follesø
 

More from Aslam Khan

PDF
The Humble Programmer
byAslam Khan
 
PDF
Agile Rabbit Holes
byAslam Khan
 
PDF
Puppet for Human Beings (NOT!)
byAslam Khan
 
PDF
Do we care rubyfuza 2019
byAslam Khan
 
PDF
Experiments in Reasoning
byAslam Khan
 
PDF
Lean in Software Development
byAslam Khan
 
PDF
Being in a State of REST
byAslam Khan
 
PDF
Practical Scrum with Kent Beck (SD Times Webinar)
byAslam Khan
 
PDF
Beyond Apartheid and Democracy
byAslam Khan
 
PDF
Product Ownership - Leaders of Agile Webinar
byAslam Khan
 
PDF
How to get open data into the hands of activists
byAslam Khan
 
PDF
Collaboration: TRC
byAslam Khan
 
PDF
Yet another building metaphor
byAslam Khan
 
The Humble Programmer
byAslam Khan
 
Agile Rabbit Holes
byAslam Khan
 
Puppet for Human Beings (NOT!)
byAslam Khan
 
Do we care rubyfuza 2019
byAslam Khan
 
Experiments in Reasoning
byAslam Khan
 
Lean in Software Development
byAslam Khan
 
Being in a State of REST
byAslam Khan
 
Practical Scrum with Kent Beck (SD Times Webinar)
byAslam Khan
 
Beyond Apartheid and Democracy
byAslam Khan
 
Product Ownership - Leaders of Agile Webinar
byAslam Khan
 
How to get open data into the hands of activists
byAslam Khan
 
Collaboration: TRC
byAslam Khan
 
Yet another building metaphor
byAslam Khan
 

Recently uploaded

PDF
AI Meets Integration: Delivering AI-Ready Data in Real Time.pdf
byPrecisely
 
PDF
API-First Architecture in Financial Systems
bycyy111112
 
PDF
TrustArc Webinar - Looking Ahead: The 2026 Privacy Landscape
byTrustArc
 
PDF
Real-Time Data Insight Using Microsoft Forms for Business
byElevate
 
PDF
Access Control 2025: From Security Silo to Software-Defined Ecosystem
byMemoori
 
PDF
Cybersecurity: Safeguarding Digital Assets
byYasir Naveed Riaz
 
PPTX
AI in Cybersecurity: Digital Defense by Yasir Naveed Riaz
byYasir Naveed Riaz
 
PDF
Cross-Cultural Agile Development -Challenges and Strategies for Overcoming Them-
byTakashi Makino
 
PDF
Day 5 - Red Team + Blue Team in the Cloud - 2nd Sight Lab Cloud Security Class
by2nd Sight Lab
 
PDF
Data Virtualization in Action: Scaling APIs and Apps with FME
bySafe Software
 
PPTX
cybercrime in Information security .pptx
byismaeelsahib032
 
PDF
Day 3 - Data and Application Security - 2nd Sight Lab Cloud Security Class
by2nd Sight Lab
 
PDF
Security Forum Sessions from Houston 2025 Event
byMark Simos
 
PPTX
Coded Agents – with UiPath SDK + LangGraph [Virtual Hands-on Workshop]
byUiPathCommunity
 
PPTX
Software Analysis &Design ethiopia chap-2.pptx
byAbbas484771
 
PDF
Eredità digitale sugli smartphone: cosa resta di noi nei dispositivi mobili
bySpeck&Tech
 
PDF
Unlocking the Power of Salesforce Architecture: Frameworks for Effective Solu...
byvarsha30tiwari
 
PDF
Session 1 - Solving Semi-Structured Documents with Document Understanding
byDianaGray10
 
PDF
The year in review - MarvelClient in 2025
bypanagenda
 
PDF
Unser Jahresrückblick – MarvelClient in 2025
bypanagenda
 
AI Meets Integration: Delivering AI-Ready Data in Real Time.pdf
byPrecisely
 
API-First Architecture in Financial Systems
bycyy111112
 
TrustArc Webinar - Looking Ahead: The 2026 Privacy Landscape
byTrustArc
 
Real-Time Data Insight Using Microsoft Forms for Business
byElevate
 
Access Control 2025: From Security Silo to Software-Defined Ecosystem
byMemoori
 
Cybersecurity: Safeguarding Digital Assets
byYasir Naveed Riaz
 
AI in Cybersecurity: Digital Defense by Yasir Naveed Riaz
byYasir Naveed Riaz
 
Cross-Cultural Agile Development -Challenges and Strategies for Overcoming Them-
byTakashi Makino
 
Day 5 - Red Team + Blue Team in the Cloud - 2nd Sight Lab Cloud Security Class
by2nd Sight Lab
 
Data Virtualization in Action: Scaling APIs and Apps with FME
bySafe Software
 
cybercrime in Information security .pptx
byismaeelsahib032
 
Day 3 - Data and Application Security - 2nd Sight Lab Cloud Security Class
by2nd Sight Lab
 
Security Forum Sessions from Houston 2025 Event
byMark Simos
 
Coded Agents – with UiPath SDK + LangGraph [Virtual Hands-on Workshop]
byUiPathCommunity
 
Software Analysis &Design ethiopia chap-2.pptx
byAbbas484771
 
Eredità digitale sugli smartphone: cosa resta di noi nei dispositivi mobili
bySpeck&Tech
 
Unlocking the Power of Salesforce Architecture: Frameworks for Effective Solu...
byvarsha30tiwari
 
Session 1 - Solving Semi-Structured Documents with Document Understanding
byDianaGray10
 
The year in review - MarvelClient in 2025
bypanagenda
 
Unser Jahresrückblick – MarvelClient in 2025
bypanagenda
 

Not Quite Object Oriented

  • 1.
    127.0.0.1 Aslam Khan ::@aslamkhn :: aslam.khan@factor10.com :: http://aslamkhan.net factor10
  • 2.
    Not Quite ObjectOriented a frustrating and incomplete journey from OO to FP Aslam Khan :: @aslamkhn :: +Aslam Khan :: factor10.com :: aslamkhan.net factor10
  • 3.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that
  • 4.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that In the beginning, I used C
  • 5.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that In the beginning, Procedural I used C C++
  • 6.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that In the beginning, Procedural Procedural I used C C++ Java
  • 7.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that Patterns In the beginning, Procedural Procedural and I used C C++ Java Polymorphism
  • 8.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that Java Patterns In the beginning, Procedural Procedural and Ruby I used C C++ Java Polymorphism C#
  • 9.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C#
  • 10.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript
  • 11.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy JavaScript
  • 12.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” JavaScript JavaScript
  • 13.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” Haskell Tutorial JavaScript JavaScript on Parsers
  • 14.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” Haskell Tutorial More functional JavaScript JavaScript on Parsers JavaScript
  • 15.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” Haskell Tutorial More functional JavaScript JavaScript on Parsers JavaScript inspired to be more functional
  • 16.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” Haskell Tutorial More functional JavaScript JavaScript on Parsers JavaScript inspired to be more functional Object Oriented Scala
  • 17.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” Haskell Tutorial More functional JavaScript JavaScript on Parsers JavaScript inspired to be more functional Object Oriented Read Haskell Scala
  • 18.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” Haskell Tutorial More functional JavaScript JavaScript on Parsers JavaScript inspired to be more functional Object Oriented More Read Haskell Scala Functional Scala
  • 19.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” Haskell Tutorial More functional JavaScript JavaScript on Parsers JavaScript inspired to be more functional Object Oriented More Read Haskell Clojure Scala Functional Scala
  • 20.
    My journey intrying to write code it felt like a language journey, but it’s actually far from that Java Patterns Finally In the beginning, Procedural Procedural and Ruby Object I used C C++ Java Polymorphism Oriented! C# then I had to write a parser in JavaScript Ultra messy “Object Oriented” Haskell Tutorial More functional JavaScript JavaScript on Parsers JavaScript inspired to be more functional Object Oriented More Long mental Read Haskell Clojure Scala Functional Scala journey ...
  • 21.
    My functional learningloop Don’t forget the Haskell talk by Simon Peyton Jones on the Cool Languages Track Read about functional concepts in Haskell do this slowly … don’t rush!
  • 22.
    My functional learningloop Don’t forget the Haskell talk by Simon Peyton Jones on the Cool Languages Track Read about functional concepts in Haskell do this slowly … don’t rush! Try the equivalent in Scala with some trivial example
  • 23.
    My functional learningloop Don’t forget the Haskell talk by Simon Peyton Jones on the Cool Languages Track Read about functional concepts in Haskell do this slowly … don’t rush! Try the equivalent in Scala with some trivial example Try it on your project the essential parts of the problem and solution
  • 24.
    My functional learningloop Don’t forget the Haskell talk by Simon Peyton Jones on the Cool Languages Track Read about functional concepts in Haskell do this slowly … don’t rush! Stuck ? Try the equivalent in Scala (impurity) or (ignorance) ? with some trivial example Try it on your project the essential parts of the problem and solution
  • 25.
    My functional learningloop Don’t forget the Haskell talk by Simon Peyton Jones on the Cool Languages Track Read about functional concepts in Haskell do this slowly … don’t rush! Stuck ? Try the equivalent in Scala (impurity) or (ignorance) ? with some trivial example Try it on your project the essential parts of the problem and solution
  • 26.
    The language offunctional And there are quite a few new concepts to understand
  • 27.
    The language offunctional And there are quite a few new concepts to understand Currying Algebraic Types Closures Type Classes Monads High Order Functions Pattern Matching Monoids Functors Lambdas Polymorphic Functions List Comprehension
  • 28.
    The language offunctional And there are quite a few new concepts to understand Currying Closures Type Classes Monads Monoids Functors Lambdas Polymorphic Functions List Comprehension High Order Functions Algebraic Types Pattern Matching
  • 29.
    Let’s write someJava Find all even integers in a range List<Integer> xs = range(1,20); List<Integer> evenRange = evens(xs);
  • 30.
    Let’s write someJava Find all even integers in a range List<Integer> range(int start, int end) { List<Integer> xs = new ArrayList<Integer>(); for (int i = start; i < end + 1; i++) { xs.add(i); } return xs; } List<Integer> xs = range(1,20); List<Integer> evenRange = evens(xs);
  • 31.
    Let’s write someJava Find all even integers in a range List<Integer> range(int start, int end) { List<Integer> xs = new ArrayList<Integer>(); for (int i = start; i < end + 1; i++) { xs.add(i); } return xs; } List<Integer> xs = range(1,20); List<Integer> evenRange = evens(xs); List<Integer> evens(List<Integer> xs) { List<Integer> keep = new ArrayList<Integer>(); for (Integer x : xs) { if (isEven(x)) keep.add(x); } return keep; }
  • 32.
    Let’s write someJava Find all even integers in a range List<Integer> range(int start, int end) { List<Integer> xs = new ArrayList<Integer>(); for (int i = start; i < end + 1; i++) { xs.add(i); } return xs; } List<Integer> xs = range(1,20); List<Integer> evenRange = evens(xs); List<Integer> evens(List<Integer> xs) { List<Integer> keep = new ArrayList<Integer>(); for (Integer x : xs) { if (isEven(x)) keep.add(x); } return keep; } boolean isEven(Integer x) { return x % 2 == 0; }
  • 33.
    The Haskell way? Remember:We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ]
  • 34.
    The Haskell way? Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] function evens
  • 35.
    The Haskell way? Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] function evens applied to xs
  • 36.
    The Haskell way? Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] function evens applied to xs is a list
  • 37.
    The Haskell way? Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] function evens applied to xs is a list for each x in xs
  • 38.
    The Haskell way? Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] function evens applied to xs is a list for each x in xs where x is even
  • 39.
    The Haskell way? Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] function evens applied to xs is a list for each x in xs where x is even for example: evens [1..20]
  • 40.
    And in Scala list comprehensions are sometimes called for-comprehensions in Scala-land val evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x
  • 41.
    And in Scala list comprehensions are sometimes called for-comprehensions in Scala-land val evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x evens
  • 42.
    And in Scala list comprehensions are sometimes called for-comprehensions in Scala-land val evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x evens takes from a list xs
  • 43.
    And in Scala list comprehensions are sometimes called for-comprehensions in Scala-land val evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x evens takes from a list xs each x
  • 44.
    And in Scala list comprehensions are sometimes called for-comprehensions in Scala-land val evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x evens takes from a list xs each x in xs
  • 45.
    And in Scala list comprehensions are sometimes called for-comprehensions in Scala-land val evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x evens takes from a list xs each x in xs where x is even
  • 46.
    And in Scala list comprehensions are sometimes called for-comprehensions in Scala-land val evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x evens takes from a list xs each x in xs where x is even val even = (x:Int) => x % 2 == 0
  • 47.
    And in Clojure Let’s use the built in “filter” function (defn evens [xs] (filter even? xs))
  • 48.
    And in Clojure Let’s use the built in “filter” function (defn evens [xs] (filter even? xs)) evens
  • 49.
    And in Clojure Let’s use the built in “filter” function (defn evens [xs] (filter even? xs)) evens applied to a list xs
  • 50.
    And in Clojure Let’s use the built in “filter” function (defn evens [xs] (filter even? xs)) evens applied to a list xs applies the filter
  • 51.
    And in Clojure Let’s use the built in “filter” function (defn evens [xs] (filter even? xs)) evens applied to a list xs applies the filter even? on xs
  • 52.
    What if wehave lots of “filters” Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] odds xs = [ x | x <- xs, odd x ]
  • 53.
    What if wehave lots of “filters” Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] odds xs = [ x | x <- xs, odd x ]
  • 54.
    What if wehave lots of “filters” Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] odds xs = [ x | x <- xs, odd x ] abstract the parts that change find f xs = [ x | x <- xs, f x ]
  • 55.
    What if wehave lots of “filters” Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] odds xs = [ x | x <- xs, odd x ] abstract the parts that change find f xs = [ x | x <- xs, f x ] using filter f
  • 56.
    What if wehave lots of “filters” Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] odds xs = [ x | x <- xs, odd x ] abstract the parts that change find f xs = [ x | x <- xs, f x ] using filter f on a list xs
  • 57.
    What if wehave lots of “filters” Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] odds xs = [ x | x <- xs, odd x ] abstract the parts that change find f xs = [ x | x <- xs, f x ] using filter f on a list xs for each x in xs
  • 58.
    What if wehave lots of “filters” Remember: We are using Haskell to understand functional concepts evens xs = [ x | x <- xs, even x ] odds xs = [ x | x <- xs, odd x ] abstract the parts that change find f xs = [ x | x <- xs, f x ] using filter f on a list xs for each x in xs where x satisfies the filter f
  • 59.
    High Order Functions helps you get DRY and leads to clean compositions val find = (predicate :Int => Boolean, xs :List[Int]) => for (x <- xs; if predicate(x)) yield x val even = (x :Int) => x % 2 == 0 val odd = (x :Int) => x % 2 == 1
  • 60.
    High Order Functions helps you get DRY and leads to clean compositions val find = (predicate :Int => Boolean, xs :List[Int]) => for (x <- xs; if predicate(x)) yield x use any function which we locally call predicate val even = (x :Int) => x % 2 == 0 val odd = (x :Int) => x % 2 == 1
  • 61.
    High Order Functions helps you get DRY and leads to clean compositions val find = (predicate :Int => Boolean, xs :List[Int]) => for (x <- xs; if predicate(x)) yield x use any function which we as long as the provided function takes an locally call predicate integer and returns a boolean val even = (x :Int) => x % 2 == 0 val odd = (x :Int) => x % 2 == 1
  • 62.
    High Order Functions helps you get DRY and leads to clean compositions val find = (predicate :Int => Boolean, xs :List[Int]) => for (x <- xs; if predicate(x)) yield x use any function which we as long as the provided function takes an locally call predicate integer and returns a boolean val even = (x :Int) => x % 2 == 0 val odd = (x :Int) => x % 2 == 1
  • 63.
    High Order Functions helps you get DRY and leads to clean compositions val find = (predicate :Int => Boolean, xs :List[Int]) => for (x <- xs; if predicate(x)) yield x use any function which we as long as the provided function takes an locally call predicate integer and returns a boolean val even = (x :Int) => x % 2 == 0 val odd = (x :Int) => x % 2 == 1 for example find(even, List.range(0,21)) find(odd, List.range(0,21))
  • 64.
    And in Clojure notice how we compose more powerful functions from smaller functions (defn find [predicate, xs] (filter predicate xs))
  • 65.
    And in Clojure notice how we compose more powerful functions from smaller functions (defn find [predicate, xs] (filter predicate xs)) function
  • 66.
    And in Clojure notice how we compose more powerful functions from smaller functions (defn find [predicate, xs] (filter predicate xs)) function for example (find odd? [1,2,3,4]) (find even? [1,2,3,4])
  • 67.
    Let’s apply thislearning how can we model a few rules?
  • 68.
    Let’s apply thislearning how can we model a few rules? Non Substitutable have to downcast to get the specific type
  • 69.
    Let’s apply thislearning how can we model a few rules? Non Substitutable have to downcast to get the specific type
  • 70.
    Let’s apply thislearning how can we model a few rules? Non Substitutable Semantically Wrong have to downcast to get how can a FixedTime the specific type project be over budget?
  • 71.
    It’s the rulesthat vary In Java, using the strategy patterns
  • 72.
    It’s the rulesthat vary In Java, using the strategy patterns class Project { public boolean check(CheckProjectRule rule) { return rule.check(this); } }
  • 73.
    It’s the rulesthat vary In Java, using the strategy patterns class Project { public boolean check(CheckProjectRule rule) { return rule.check(this); } } interface ProjectRule { public boolean check(Project p); }
  • 74.
    It’s the rulesthat vary In Java, using the strategy patterns class Project { public boolean check(CheckProjectRule rule) { return rule.check(this); } } interface ProjectRule { public boolean check(Project p); } class OverdueProjectRule implements ProjectRule { ... public boolean check(Project p) { return p.getEndDate().isBefore(today()); } }
  • 75.
    In Scala Using highorder functions
  • 76.
    In Scala Using highorder functions class Project { val check = (rule :Prj => Boolean) => rule(this) }
  • 77.
    In Scala Using highorder functions class Project { val check = (rule :Prj => Boolean) => rule(this) } val overBudgetRule = (p :Project) => p.costToDate() > p.budget()
  • 78.
    In Scala Using highorder functions class Project { val check = (rule :Prj => Boolean) => rule(this) } val overBudgetRule = (p :Project) => p.costToDate() > p.budget() val overdueProjectRule = (p :Project) => p.getEndDate().isBefore(today()) The Strategy Pattern is not needed because of high order functions
  • 79.
    A Model forShapes Shape abstract area() Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) Square Square(x, y, l) It’s easy to imagine what the Java code will look like
  • 80.
    Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) Square Square(x, y, l)
  • 81.
    Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) Square Square(x, y, l)
  • 82.
    Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) Square Square(x, y, l)
  • 83.
    Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) Square Square(x, y, l)
  • 84.
    Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) area :: Shape -> Float Square Square(x, y, l)
  • 85.
    Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) area :: Shape -> Float area (Circle _ _ r) = pi * r^2 Square area (Rectangle _ _ w h) = w * h Square(x, y, l) area (Square _ _ l) = l * l
  • 86.
    Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) area :: Shape -> Float area (Circle _ _ r) = pi * r^2 Square area (Rectangle _ _ w h) = w * h Square(x, y, l) area (Square _ _ l) = l * l
  • 87.
    Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) area :: Shape -> Float area (Circle _ _ r) = pi * r^2 Square area (Rectangle _ _ w h) = w * h Square(x, y, l) area (Square _ _ l) = l * l
  • 88.
    Haskell not inheritance, but “alternatives” of cases of the type data Shape = Circle Float Float Float | Shape   Rectangle Float Float Float Float | abstract area() Square Float Float Float Circle Rectangle Circle(x, y, r) Rectangle(x, y, w, h) area :: Shape -> Float area (Circle _ _ r) = pi * r^2 Square area (Rectangle _ _ w h) = w * h Square(x, y, l) area (Square _ _ l) = l * l Algebraic Types used to construct values for specific cases
  • 89.
  • 90.
    Shapes in Scala sealedabstract class Shape
  • 91.
    Shapes in Scala sealedabstract class Shape case class Circle( x: Int, y :Int, r :Int) extends Shape
  • 92.
    Shapes in Scala sealedabstract class Shape case class Circle( x: Int, y :Int, r :Int) extends Shape case class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shape
  • 93.
    Shapes in Scala sealedabstract class Shape case class Circle( x: Int, y :Int, r :Int) extends Shape case class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shape case class Square(x :Int, y:Int, l :Int) extends Shape
  • 94.
    Shapes in Scala Algebraic Types to describe how to construct alternatives sealed abstract class Shape case class Circle( x: Int, y :Int, r :Int) extends Shape case class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shape case class Square(x :Int, y:Int, l :Int) extends Shape
  • 95.
    Shapes in Scala Algebraic Types to describe how to construct alternatives sealed abstract class Shape case class Circle( x: Int, y :Int, r :Int) extends Shape case class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shape case class Square(x :Int, y:Int, l :Int) extends Shape Pattern Matching to specify use cases based on values
  • 96.
    Shapes in Scala Algebraic Types to describe how to construct alternatives sealed abstract class Shape case class Circle( x: Int, y :Int, r :Int) extends Shape case class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shape case class Square(x :Int, y:Int, l :Int) extends Shape Pattern Matching to specify use cases based on values val area : Shape => Int = _ match { }
  • 97.
    Shapes in Scala Algebraic Types to describe how to construct alternatives sealed abstract class Shape case class Circle( x: Int, y :Int, r :Int) extends Shape case class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shape case class Square(x :Int, y:Int, l :Int) extends Shape Pattern Matching to specify use cases based on values val area : Shape => Int = _ match {     case Circle( _, _, radius ) => Pi * ( pow( radius, 2.0 ) )      case Rectangle( _, _, width, height ) => width * height      case Square( _, _, length ) => length * length }
  • 98.
    Shapes in Scala Algebraic Types to describe how to construct alternatives sealed abstract class Shape case class Circle( x: Int, y :Int, r :Int) extends Shape case class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shape case class Square(x :Int, y:Int, l :Int) extends Shape Pattern Matching to specify use cases based on values val area : Shape => Int = _ match {     case Circle( _, _, radius ) => Pi * ( pow( radius, 2.0 ) )      case Rectangle( _, _, width, height ) => width * height      case Square( _, _, length ) => length * length case Rectangle( _, _, 1, height ) => height case Rectangle( _, _, width, 1 ) => width }
  • 99.
    What has beenour journey so far? Maybe we should apply it to something a bit more substantial List Comprehension
  • 100.
    What has beenour journey so far? Maybe we should apply it to something a bit more substantial List Comprehension High Order Functions
  • 101.
    What has beenour journey so far? Maybe we should apply it to something a bit more substantial List Comprehension High Order Functions Algebraic Types
  • 102.
    What has beenour journey so far? Maybe we should apply it to something a bit more substantial List Comprehension High Order Functions Algebraic Types Pattern Matching
  • 103.
    A better modelfor a Project Using the composite pattern Activity Phase Milestone Task Project
  • 104.
    A better modelfor a Project Using the composite pattern Activity Phase Milestone Task Project
  • 105.
    A better modelfor a Project Using the composite pattern Activity Phase Milestone Task Project
  • 106.
    A better modelfor a Project Using the composite pattern sealed abstract class Activity Activity Phase Milestone Task Project
  • 107.
    A better modelfor a Project Using the composite pattern sealed abstract class Activity Activity case class Task(description: String, person :String) extends Activity Phase Milestone Task Project
  • 108.
    A better modelfor a Project Using the composite pattern sealed abstract class Activity Activity case class Task(description: String, person :String) extends Activity case class Milestone(name :String) extends Activity Phase Milestone Task Project
  • 109.
    A better modelfor a Project Using the composite pattern sealed abstract class Activity Activity case class Task(description: String, person :String) extends Activity case class Milestone(name :String) extends Activity case class Project(name :String) extends Activity lazy val activities = List ( Phase(1), Phase Milestone Task Project Task("Develop", "Peter"), Milestone("Release to UAT"), ) }
  • 110.
    A better modelfor a Project Using the composite pattern sealed abstract class Activity Activity case class Task(description: String, person :String) extends Activity case class Milestone(name :String) extends Activity case class Project(name :String) extends Activity lazy val activities = List ( Phase(1), Phase Milestone Task Project Task("Develop", "Peter"), Milestone("Release to UAT"), ) } case class Phase(phaseNumber :Int) extends Activity
  • 111.
    A better modelfor a Project Using the composite pattern sealed abstract class Activity Activity case class Task(description: String, person :String) extends Activity case class Milestone(name :String) extends Activity case class Project(name :String) extends Activity lazy val activities = List ( Phase(1), Phase Milestone Task Project Task("Develop", "Peter"), Milestone("Release to UAT"), ) } case class Phase(phaseNumber :Int) extends Activity
  • 112.
    A better modelfor a Project Using the composite pattern sealed abstract class Activity Activity trait ManyActivities { def activities :Seq[Activity] } case class Task(description: String, person :String) extends Activity case class Milestone(name :String) extends Activity case class Project(name :String) extends Activity lazy val activities = List ( Phase(1), Phase Milestone Task Project Task("Develop", "Peter"), Milestone("Release to UAT"), ) } case class Phase(phaseNumber :Int) extends Activity
  • 113.
    A better modelfor a Project Using the composite pattern sealed abstract class Activity Activity trait ManyActivities { def activities :Seq[Activity] } case class Task(description: String, person :String) extends Activity case class Milestone(name :String) extends Activity case class Project(name :String) extends Activity with ManyActivities { lazy val activities = List ( Phase Milestone Task Project Phase(1), Task("Develop", "Peter"), Milestone("Release to UAT"), ) } case class Phase(phaseNumber :Int) extends Activity
  • 114.
    A better modelfor a Project Using the composite pattern sealed abstract class Activity Activity trait ManyActivities { def activities :Seq[Activity] } case class Task(description: String, person :String) extends Activity case class Milestone(name :String) extends Activity case class Project(name :String) extends Activity with ManyActivities { lazy val activities = List ( Phase Milestone Task Project Phase(1), Task("Develop", "Peter"), Milestone("Release to UAT"), ) } case class Phase(phaseNumber :Int) extends Activity with ManyActivities { val activities = List( Task("Analysis", "John"), Milestone("Ready for Development") ) }
  • 115.
    A better modelfor a Project Using the composite pattern sealed abstract class Activity Activity trait ManyActivities { def activities :Seq[Activity] } case class Task(description: String, person :String) extends Activity case class Milestone(name :String) extends Activity case class Project(name :String) extends Activity with ManyActivities { lazy val activities = List ( Phase Milestone Task Project Phase(1), Task("Develop", "Peter"), Milestone("Release to UAT"), ) unapply() is an Extractor for } algebraic types object ManyActivities { case class Phase(phaseNumber :Int) extends Activity def unapply(a :Activity) = { with ManyActivities { a match { val activities = List( case (a :ManyActivities) => Some(a.activities) Task("Analysis", "John"), case _ => None Milestone("Ready for Development") } ) } } }
  • 116.
    Actions for thisproject Using the visitor pattern Activity process (Action) Phase Milestone Task Project Action for_Phase() for_Milestone() for_Task() for_Project() Plan Start Status Celebrate
  • 117.
    Actions for thisproject Using the visitor pattern Activity process (Action) Phase Milestone Task Project Action for_Phase() for_Milestone() for_Task() for_Project() Plan Start Status Celebrate
  • 118.
    With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } Action for_Phase() for_Milestone() for_Task() for_Project() Plan Start Status Celebrate
  • 119.
    With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } Action for_Phase() for_Milestone() for_Task() for_Project() Plan Start Status Celebrate
  • 120.
    With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } Action for_Phase() for_Milestone() for_Task() for_Project() Plan Start Status Celebrate
  • 121.
    With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } Action for_Phase() for_Milestone() for_Task() for_Project() Plan Start Status Celebrate
  • 122.
    With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } def plan(a :Activity) { Action a match { for_Phase() for_Milestone() case Task(description, person) => { ... } for_Task() case Phase(number) => { ... } for_Project() case Milestone(name) => { ... } case Project(name) => { ... } } Plan Start Status Celebrate }
  • 123.
    With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } def plan(a :Activity) { Action a match { for_Phase() for_Milestone() case Task(description, person) => { ... } for_Task() case Phase(number) => { ... } for_Project() case Milestone(name) => { ... } case Project(name) => { ... } } Plan Start Status Celebrate }
  • 124.
    With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } def plan(a :Activity) { Action a match { for_Phase() for_Milestone() case Task(description, person) => { ... } for_Task() case Phase(number) => { ... } for_Project() case Milestone(name) => { ... } case Project(name) => { ... } } Plan Start Status Celebrate }
  • 125.
    With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } def plan(a :Activity) { Action a match { for_Phase() for_Milestone() case Task(description, person) => { ... } for_Task() case Phase(number) => { ... } for_Project() case Milestone(name) => { ... } case Project(name) => { ... } } Plan Start Status Celebrate }
  • 126.
    With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { process (Action) case ManyActivities(activities) => activities.foreach(process(action)) case _ => () } action(a) } Phase Milestone Task Project } def plan(a :Activity) { Action a match { for_Phase() for_Milestone() case Task(description, person) => { ... } for_Task() case Phase(number) => { ... } for_Project() case Milestone(name) => { ... } case Project(name) => { ... } } Plan Start Status Celebrate }
  • 127.
    With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { val prj = Project("HelloWorld") (Action) process case ManyActivities(activities) => activities.foreach(process(action)) case _ => () process(plan)(prj) } action(a) } process(start)(prj) Phase Milestone Task Project } def plan(a :Activity) { Action a match { for_Phase() for_Milestone() case Task(description, person) => { ... } for_Task() case Phase(number) => { ... } for_Project() case Milestone(name) => { ... } case Project(name) => { ... } } Plan Start Status Celebrate }
  • 128.
    With functions we don’t need the object oriented visitor patterns def process(action :Activity => Unit)(a :Activity) { Activity a match { val prj = Project("HelloWorld") (Action) process case ManyActivities(activities) => activities.foreach(process(action)) case _ => () process(plan)(prj) } action(a) } process(start)(prj) Phase Milestone Task Project } def plan(a :Activity) { Action a match { for_Phase() for_Milestone() case Task(description, person) => { ... } for_Task() case Phase(number) => { ... } for_Project() Next Steps case Milestone(name) => { ... } Look at Haskell type classes and Scala implicit case Project(name) => { ... } def for polymorphic functions } Plan Start Status Celebrate }
  • 129.
    Can you takethe same journey with Clojure? Use each step to build confidence, and go pure if you are stuck Read about functional concepts in Haskell do this slowly … don’t rush! Stuck ? Try equivalent in Clojure (impurity of Clojure) or (my ignorance) ? with some trivial example Try it on your project the essential parts of the problem and solution
  • 130.
    Some changes inthinking as a result of going on this functional journey Simple Structures Simple Transformations and lists and dictionaries list comprehensions, map, reduce
  • 131.
    Some changes inthinking as a result of going on this functional journey Simple Structures Simple Transformations and lists and dictionaries list comprehensions, map, reduce Find a starting set of elements [ a, b, c, d, e, f ]
  • 132.
    Some changes inthinking as a result of going on this functional journey Simple Structures Simple Transformations and lists and dictionaries list comprehensions, map, reduce Find a starting set of elements [ a, b, c, d, e, f ] Transform to what you need [ (a, b), (c,d) (e, f) ]
  • 133.
    Some changes inthinking as a result of going on this functional journey Simple Structures Simple Transformations and lists and dictionaries list comprehensions, map, reduce Find a starting set of elements [ a, b, c, d, e, f ] Transform to what you need [ (a, b), (c,d) (e, f) ] Filter to get what you want [(c,d)]
  • 134.
    Other things Iwork hard at Stop thinking about Remind myself of and interactions between objects values of data and transformations
  • 135.
    Other things Iwork hard at Stop thinking about Remind myself of and interactions between objects values of data and transformations Keep it immutable with val var feels dirty in Scala
  • 136.
    Other things Iwork hard at Stop thinking about Remind myself of and interactions between objects values of data and transformations Keep it immutable with val var feels dirty in Scala No unexpected side effects
  • 137.
    Other things Iwork hard at Stop thinking about Remind myself of and interactions between objects values of data and transformations Keep it immutable with val var feels dirty in Scala No unexpected side effects Always return something makes me consider every branch
  • 138.
    Benefits that I’veobserved and some that I have an anticipation that will happen
  • 139.
    Benefits that I’veobserved and some that I have an anticipation that will happen DRY, really DRY more than I expected
  • 140.
    Benefits that I’veobserved and some that I have an anticipation that will happen DRY, really DRY more than I expected Very declarative makes it very readable too
  • 141.
    Benefits that I’veobserved and some that I have an anticipation that will happen DRY, really DRY more than I expected Very declarative makes it very readable too Some OO patterns disappear into trivial implementations
  • 142.
    Benefits that I’veobserved and some that I have an anticipation that will happen DRY, really DRY more than I expected Very declarative makes it very readable too Some OO patterns disappear into trivial implementations Very testable small, immutable, side-effect free
  • 143.
    Benefits that I’veobserved and some that I have an anticipation that will happen DRY, really DRY more than I expected Very declarative makes it very readable too Some OO patterns disappear into trivial implementations Very testable small, immutable, side-effect free Modular with excellent composition
  • 144.
    How I nowthink about code Primitive expressions food, I, put, my, mouth, in A means of combination I put food in my mouth A means of abstraction I eat This is the basics of understanding and organisation of thought
  • 145.
    Programs are thesame they express our understanding and show the organisation of our thoughts
  • 146.
    Programs are thesame they express our understanding and show the organisation of our thoughts Think large static structures
  • 147.
    Programs are thesame they express our understanding and show the organisation of our thoughts Think large Think static small structures composable structures
  • 148.
    Programs are thesame they express our understanding and show the organisation of our thoughts Th ink la rge st atic ctu res or Think stru small composable structures
  • 149.
    The language offunctional And there are quite a few new concepts to understand Currying Algebraic Types Closures Type Classes Monads High Order Functions Pattern Matching Monoids Functors Lambdas Polymorphic Functions List Comprehension
  • 150.
    My functional learningloop Don’t forget the Haskell talk by Simon Peyton Jones on the Cool Languages Track Read about functional concepts in Haskell do this slowly … don’t rush! Stuck ? Try the equivalent in Scala (impurity) or (ignorance) ? with some trivial example Try it on your project the essential parts of the problem and solution
  • 151.
    What How doyou want to build? factor10.com :: @aslamkhn :: aslamkhan.net

Editor's Notes