Not Quite Object Oriented

127.0.0.1Aslam Khan :: @aslamkhn :: aslam.khan@factor10.com :: http://aslamkhan.net factor10

Not Quite Object Oriented a frustrating and incomplete journey from OO to FPAslam 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 thatIn the beginning, I used C

My journey in trying to write code it felt like a language journey, but it’s actually far from thatIn 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 thatIn 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 PatternsIn 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 PatternsIn 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 FinallyIn 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 FinallyIn 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 FinallyIn 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 FinallyIn 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 FinallyIn 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 FinallyIn 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 FinallyIn 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 FinallyIn 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 FinallyIn 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 FinallyIn 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 FinallyIn 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 FinallyIn 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 loopDon’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 loopDon’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 loopDon’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

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 TypesClosures 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 FunctionsList 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 conceptsevens 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-landval evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x

And in Scala list comprehensions are sometimes called for-comprehensions in Scala-landval evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x evens

And in Scala list comprehensions are sometimes called for-comprehensions in Scala-landval 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-landval 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-landval 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-landval 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-landval evens = (xs: List[Int]) => for (x <- xs; even(x) ) yield x evens takes from a list xs each x in xs where x is evenval even = (x:Int) => x % 2 == 0

And in Clojure Let’s use the built in “filter” function(defn evens [xs] (ﬁlter even? xs))

And in Clojure Let’s use the built in “filter” function(defn evens [xs] (ﬁlter even? xs)) evens

And in Clojure Let’s use the built in “filter” function(defn evens [xs] (ﬁlter even? xs)) evens applied to a list xs

And in Clojure Let’s use the built in “filter” function(defn evens [xs] (ﬁlter even? xs)) evens applied to a list xs applies the ﬁlter

And in Clojure Let’s use the built in “filter” function(defn evens [xs] (ﬁlter even? xs)) evens applied to a list xs applies the ﬁlter even? on xs

What if we have lots of “filters” Remember: We are using Haskell to understand functional conceptsevens 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 conceptsevens xs = [ x | x <- xs, even x ] odds xs = [ x | x <- xs, odd x ] abstract the parts that change ﬁnd 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 ﬁnd f xs = [ x | x <- xs, f x ]using ﬁlter 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 ﬁnd f xs = [ x | x <- xs, f x ]using ﬁlter 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 ﬁnd f xs = [ x | x <- xs, f x ]using ﬁlter 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 compositionsval ﬁnd = (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 compositionsval ﬁnd = (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 compositionsval ﬁnd = (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 compositionsval 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 ﬁnd [predicate, xs] (ﬁlter predicate xs))

And in Clojure notice how we compose more powerful functions from smaller functions(defn ﬁnd [predicate, xs] (ﬁlter 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 Substitutablehave to downcast to get the specific type

Let’s apply this learning how can we model a few rules? Non Substitutable Semantically Wronghave 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 ScalaUsing high order functions

In ScalaUsing high order functions class Project { val check = (rule :Prj => Boolean) => rule(this) }

In ScalaUsing high order functions class Project { val check = (rule :Prj => Boolean) => rule(this) } val overBudgetRule = (p :Project) => p.costToDate() > p.budget()

In ScalaUsing 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 typedata 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 typedata 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 typedata 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 -> Floatarea (Circle _ _ r) = pi * r^2 Squarearea (Rectangle _ _ w h) = w * h Square(x, y, l)area (Square _ _ l) = l * l

Haskell not inheritance, but “alternatives” of cases of the typedata 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 -> Floatarea (Circle _ _ r) = pi * r^2 Squarearea (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 Scalasealed abstract class Shape

Shapes in Scalasealed abstract class Shapecase class Circle( x: Int, y :Int, r :Int) extends Shape

Shapes in Scalasealed abstract class Shapecase class Circle( x: Int, y :Int, r :Int) extends Shapecase class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shape

Shapes in Scalasealed abstract class Shapecase class Circle( x: Int, y :Int, r :Int) extends Shapecase class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shapecase class Square(x :Int, y:Int, l :Int) extends Shape

Shapes in Scala Algebraic Types to describe how to construct alternativessealed abstract class Shapecase class Circle( x: Int, y :Int, r :Int) extends Shapecase class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shapecase class Square(x :Int, y:Int, l :Int) extends Shape

Shapes in Scala Algebraic Types to describe how to construct alternativessealed abstract class Shapecase class Circle( x: Int, y :Int, r :Int) extends Shapecase class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shapecase 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 alternativessealed abstract class Shapecase class Circle( x: Int, y :Int, r :Int) extends Shapecase class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shapecase class Square(x :Int, y:Int, l :Int) extends Shape Pattern Matching to specify use cases based on valuesval area : Shape => Int = _ match {}

Shapes in Scala Algebraic Types to describe how to construct alternativessealed abstract class Shapecase class Circle( x: Int, y :Int, r :Int) extends Shapecase class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shapecase class Square(x :Int, y:Int, l :Int) extends Shape Pattern Matching to specify use cases based on valuesval 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 alternativessealed abstract class Shapecase class Circle( x: Int, y :Int, r :Int) extends Shapecase class Rectangle(x: Int, y :Int, w :Int, h :Int) extends Shapecase class Square(x :Int, y:Int, l :Int) extends Shape Pattern Matching to specify use cases based on valuesval 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 ActivityPhase 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 patternsealed abstract class Activity Activity Phase Milestone Task Project

A better model for a Project Using the composite patternsealed abstract class Activity Activitycase class Task(description: String, person :String) extends Activity Phase Milestone Task Project

A better model for a Project Using the composite patternsealed abstract class Activity Activitycase class Task(description: String, person :String) extends Activitycase class Milestone(name :String) extends Activity Phase Milestone Task Project

A better model for a Project Using the composite patternsealed abstract class Activity Activitycase class Task(description: String, person :String) extends Activitycase class Milestone(name :String) extends Activitycase 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 patternsealed abstract class Activity Activitycase class Task(description: String, person :String) extends Activitycase class Milestone(name :String) extends Activitycase 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 patternsealed abstract class Activity Activitytrait ManyActivities { def activities :Seq[Activity] }case class Task(description: String, person :String) extends Activitycase class Milestone(name :String) extends Activitycase 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 patternsealed abstract class Activity Activitytrait ManyActivities { def activities :Seq[Activity] }case class Task(description: String, person :String) extends Activitycase class Milestone(name :String) extends Activitycase 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 patternsealed abstract class Activity Activitytrait ManyActivities { def activities :Seq[Activity] }case class Task(description: String, person :String) extends Activitycase class Milestone(name :String) extends Activitycase 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 patternsealed abstract class Activity Activitytrait ManyActivities { def activities :Seq[Activity] }case class Task(description: String, person :String) extends Activitycase class Milestone(name :String) extends Activitycase 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

With functions we don’t need the object oriented visitor patternsdef 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 { 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 andlists and dictionaries list comprehensions, map, reduce

Some changes in thinking as a result of going on this functional journey Simple Structures Simple Transformations andlists 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 andlists 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 andlists 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 andinteractions between objects values of data and transformations

Other things I work hard at Stop thinking about Remind myself of andinteractions 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 andinteractions 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 andinteractions 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 samethey express our understanding and show the organisation of our thoughts

Programs are the samethey express our understanding and show the organisation of our thoughts Think large static structures

Programs are the samethey 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 Thinkstru small composable structures

The language of functional And there are quite a few new concepts to understand Currying Algebraic TypesClosures 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

Not Quite Object Oriented

by Aslam Khan on Nov 09, 2011

Accessibility

Categories

Tags

Upload Details

Usage Rights

1 Embed 1

Statistics

Not Quite Object Oriented — Presentation Transcript