Abstraction Oriented Programming: Functioneel programmeren op de JVM met Clojure (presentatie)

8/6/2019 Abstraction Oriented Programming: Functioneel programmeren op de JVM met Clojure (presentatie)

http://slidepdf.com/reader/full/abstraction-oriented-programming-functioneel-programmeren-op-de-jvm-met-clojure 1/53

Abstraction Oriented ProgrammingFunctioneel Programmeren op de JVM met Clojure

Who? Rik van AchterbergBrian van der BijlWouter HassingMa hijs Steen

From? Hogeschool Utrecht

When? Juni



Presentatie

Inleiding

Doel van het onderzoek

Casus: RichRailVerschillen met JavaOnderwijs

Conclusie



Inleiding

Wat is Clojure?

1 ( defn square [x] (* x x))2 ; define the function square

3 ; [x] is the parameter

4 ; (* x x ) = x * x = x^2



Inleiding

Wat is Functioneel Programmeren?

1 ( defn double [x] (* 2 x))

2 ( map double [1 2 3])

3 ; Dit heeft hetzelfde resultaat als

4 ; [(double 1) (double 2) (double 3)] = [2 4 6]



Inleiding

Wat is Functioneel Programmeren?

1 ( defn double [x] (* 2 x))

2 ( map double [1 2 3])

3 ; Dit heeft hetzelfde resultaat als

4 ; [(double 1) (double 2) (double 3)] = [2 4 6]

Waarom is dit interessant?




Vragen

Wat zijn de voornaamste verschillen tussen Clojure en Java?




Vragen


Wat zijn de voornaamste voor- en nadelen vanFunctioneel Programmeren in Clojure t.o.v.Object-georië nteerd Programmeren in Java?




Vragen


Wat zijn de voornaamste voor- en nadelen vanFunctioneel Programmeren in Clojure t.o.v.Object-georië nteerd Programmeren in Java?

Zou de Hogeschool Utrecht er goed aan doen omFunctioneel Programmeren in het informatica-curriculumop te nemen?



Vers illen met Java

OO versus FP



Vers illen met Java

OO versus FP



Vers illen met Java

OO vs. FPEncapsulation

Closures



Vers illen met Java


Closures

1 ( defn create []

2 ( let [remembers 5]

3 ( fn [] remembers)))

4 ( println ((create)))



Vers illen met Java


Closures

1 ( defn create []




Namespaces



Vers illen met Java


Closures

1 ( defn create []




NamespacesImmutability



Inheritance

1 class Person {

2 public String getFullName() { /* body */ }

3 }

4 class Employee extends Person {

5 public BusinessCard getBusinessCard() { /* body */ }

6 }



Inheritance

1 ( defn full-name [x]

2 ( str (:first-name x) ” ” (:last-name x)))3 ( defn business-card [x]

4 [(full-name) (:mail-address x)])



Inheritance

„It is be er to have functions operate on one data

structure than to have functions operate on datastructures.” - Alan J. Perlis



Vers illen met Java

OO versus FP

Statisch versus Dynamisch



Statis vs. Dynamis

Clojure is dynamisch getypeerd

Traditioneel zijn LISPs altijd dynamisch

Dynamic typed system is eenvoudiger te implementerenMacro’s en code on runtime aanpassen zouden praktischonmogelijk zijn met een statisch typering



Vers illen met Java

OO versus FP

Statisch versus DynamischRecursie versus Iteratie



Recursie vs. Iteratie

De functionele oplossing voor iteratie is recursie

Tail recursion optimalization

C Ri R il



Casus: Ri Rail

Pa erns and Frameworks

From PoorRail to Richrail

Ri R il J d i



Ri Rail: Java design

Ri R il Cl j



Ri Rail: Clojure



Ri Rail: Clojure



Ri Rail: Clojure

Clojure is niet OOHoe representeer je een depot, trein, wagon?

Ri Rail: Clojure



Ri Rail: Clojure

Clojure is niet OOHoe representeer je een depot, trein, wagon?

1 ( def depot ( atom [( list ) ( list )]))

2 ( def train {:train id :twagons ( list )})

3 ( def wagon {:wagon id :seats seats :status :free})

Ri Rail: Clojure



Ri Rail: Clojure

Commando’sFuncties op collecties

Ri Rail: Clojure



Ri Rail: Clojure


Lijst van treinen → lijst van treinen

Ri Rail: Clojure



Ri Rail: Clojure


Lijst van treinen → lijst van treinenLi en naar depot

Ri Rail: Clojure



Ri Rail: Clojure


Lijst van treinen → lijst van treinenLi en naar depot

Li en naar atom

Ri Rail: Clojure



Ri Rail: Clojure

Commando’s

1 ( defn- try-if-exists [exist id f error]

2 ( fn [coll]

3 ( if ((exists? exist) ( some ( comp ( partial = id) obj-id) coll))

4 (f coll)5 [coll [( str ”> ” error)]])))

6

7 ( defn- new-train [id]

8 (try-if-exists :no id

9 ( fn [coll] [( cons {:train id :twagons ( list )} coll) [( str ”> ↲

train ” id ” created” )]])

10 ( str ”no train created, ” id ” exists!” )) )

Ri Rail: Clojure



Ri Rail: Clojure

Commando’s

1 ( defn- get-wagon [id]

2 (try-if-exists :yes id

3 ( fn [coll] [coll [( str ”> number of seats in wagon ” id ” : ” ↲

(:seats (find-object coll id)))]])4 ( str ”wagon ” id ” does not exist” )) )

5

6 ( defn- del-vehicle [id]

7 (try-if-exists :yes id

8 ( fn [coll] [( remove ( comp ( partial = id) obj-id) coll) [( str ↲

”> ” id ” deleted” )]])

9 ( str id ” not deleted, it wasn’t there to begin with!” )) )

Ri Rail: Clojure



Ri Rail: Clojure

1 ( defn- do-to-both [wfunc tfunc]

2 ( fn [depot]

3 (with-monad log-m

4 ((m-chain [(in-trains tfunc) (in-wagons wfunc)]) depot))))

5

6 ( def in-both do-to-both)

7

8 ( defn- modify! [at funcs]

9 ( let [action (with-monad log-m (m-chain funcs))

10 [_ msg] (action @at)]

11 (swap! at ( comp first action))12 ( doseq [msg msg] ( println msg))

13 (str-join ”\n” msg)))

Ri Rail: Clojure



j

Easy-access

1 ( defn- new-wagon-cmd [id & seats] (in-wagons (new-wagon id ( first ↲

seats))))

2 ( defn- new-train-cmd [id] (in-trains (new-train id)))

3 ( defn- get-wagon-cmd [id] (in-wagons (get-wagon id)))

4 ( defn- get-train-cmd [id] (in-trains (get-train id)))

5 ( defn- add-wagon-to-train-cmd [wid tid]

6 (in-both (set-wagon wid :connected) (wagon-to-train wid tid)))

7 ( defn- remove-wagon-from-train-cmd [wid tid]

8 (in-both (set-wagon wid :free) (wagon-from-train wid tid)))

9 ( defn- del-wagon-cmd [id]

10 (in-both (del-vehicle id) (wagon-from-train id (connected-train ↲

id))))

11 ( defn- del-train-cmd [id]

12 (in-both (release-wagons id) (del-vehicle id)))

Ri Rail: Clojure



j

ParsersSimpele functies om bijvoorbeeld karakters te parsen

Ri Rail: Clojure



j

ParsersSimpele functies om bijvoorbeeld karakters te parsen

Dankzij monads makkelijk te combineren tot complexeparsers



Ri Rail: Clojure



Parsers1 ( defn- any-char [strn]

2 ( if (= ”” strn)

3 nil

4 ( list ( first strn) (. strn (substring 1)))))

5 ( defn- char-test [pred]

6 (domonad parser-m

7 [c any-char

8 : when (pred c)]

9 ( str c)))

10 ( defn- is-char [c]

11 (char-test ( partial = c)))

Ri Rail: Clojure



Parsers

1 ( defn- match-string [target-strn]

2 (with-monad parser-m

3 ( if (= ”” target-strn)

4 (m-result ”” )

5 (domonad parser-m

6 [c (is-char ( first target-strn))

7 cs (match-string ( apply str ( rest target-strn)↲

)) ]

8 ( str c cs)))))

9 ( def id-parser

10 (with-monad parser-m (both (m-plus (match-string ”wg”)

11 (match-string ”tr” )) number))↲

)

12 ( def type-parser

13 (with-monad parser-m (m-plus (match-string ”wagon” ) (↲

match-string ”train” ))))

Ri Rail: Clojure



Parsers

1 ( def new-command-parser

2 (domonad parser-m

3 [ _ (match-string ”new” )

4 _ whitespace

5 obj-type type-parser

6 _ whitespace

7 id id-parser

8 seats (optional numseats-parser)

9 ]

10 ( if (= obj-type ”train” )

11 ( fn [depot] (modify! depot [(new-train-cmd id)]))12 ( if ( nil ? seats)

13 ( fn [depot] (modify! depot [(new-wagon-cmd id)]))

14 ( fn [depot] (modify! depot [(new-wagon-cmd id seats)])))↲

)) )

Ri Rail: Clojure



1 ( def parse-command

2 (with-monad parser-m (m-plus add-command-parser ↲

new-command-parser get-command-parser delete-command-parser ↲

remove-command-parser print-command-parser)))

3

4 ( defn- do-evaluate [string]

5 ( eval (( first (parse-command string)) depot)))

Ri Rail: Clojure



InteropUIs in Clojure bestaan voornamelijk uit interop

Ri Rail: Clojure




In plaats daarvan interop gebruikt om aan Java versie tekoppelen

Ri Rail: Clojure




In plaats daarvan interop gebruikt om aan Java versie tekoppelen

Zet Clojure structuren om in Java structuren

Ri Rail: Clojure



Interop

1 ( ns com.richrail.interop.state

2 (: gen-class

3 : name com.richrail.state.ClojureStateProvider

4 :prefix method-

5 :implements [com.richrail.state.StateProvider])

6 (: import java.util.ArrayList

7 com.richrail.state.DepotState

8 com.richrail.state.TrainState

9 com.richrail.state.WagonState)

10 (: use com.richrail.core))

11 ( defn train->object [train]

12 (TrainState. (obj-id train) (ArrayList. ( reverse ( map ( fn [id] (↲wagon->object (find-object wagons @depot id))) (:twagons train)↲

)))))

13 ( defn method-getState [_]

14 (DepotState. (ArrayList. ( map train->object ( reverse (trains ↲

@depot))))

15 (ArrayList. ( map wagon->object ( reverse (wagons ↲

Onderwijs



FP in het onderwijs?

Onderwijs




Onze ervaring

Onderwijs




Onze ervaringWij zeggen: doen!

Conclusie



Clojure is…

Conclusie



Clojure is…

Declaratief vs Imperatief

Conclusie



Clojure is…

Declaratief vs Imperatief

Functioneel vs OOP



Abstraction Oriented Programming: Functioneel programmeren op de JVM met Clojure (presentatie)

Documents