Clojure: Practical functional approach on JVM

1. 我把所有穿过的袜子在沙发上摆成一个二叉堆，每天回家便把袜子脱下来放在堆的最末尾，然后每次拿起两双袜子放在鼻子下闻闻，不断向上调整它在堆中的位置，直到比它的父亲更臭为止。这样，我每天早晨出门时便能方便地选出一双最不臭的袜子。

2. Clojure Practical Functional Approach on JVM Sun Ning 2011.11.28

3. Agenda Introduction to Clojure

4. Real World Clojure

5. Clojure People

7. Introduction to Clojure Functional Programming

8. Lisp Syntax

9. State Management

10. Macro

11. Java Interop

13. Lisp Syntax

14. State Management

15. Macro

16. Java Interop

17. Functional Programming Avoiding Mutable State

18. Functions as First-Class Values

19. Lambdas and Closures

20. Higher-Order Functions

21. Side-Effect-Free Functions

22. Recursion

23. Lazy vs. Eager Evaluation

24. Declarative vs. Imperative Programming

25. Functional Programming Avoiding Mutable State Better concurrency (no need for locking)

26. Persistent data structure zs = xs + ys

27. Functional Programming Functions as First-Class Values

28. Lambdas and Closures

29. Higher-Order Functions ;; integer as first class value (def a 10) ;; function as first class value (def b (fn [x] (+ x a))) ;; anonymous function #(+ a %) ;; function that generate a closure (def c (fn [x] #(+ x %))) ;; high order function (function as parameter) (def d (fn [f x] (f x a)))

30. Functional Programming Side-Effect-Free Functions ;; function that free of side effect (defn f [x] (+ x 1000)) ;; function with side effect (defn f [x] (println (str “logging: x=” x)) (+ x 1000)) ;; I/O operations are side effect (defn dump [writer data] (.write writer data))

31. Functional Programming Recursion Recursive Looping public int sumAll(int n) { int i = 1, s = 0; while(i <= n) { s = s + i; i++; } return s; } public int sumAll(int n) { if ( n > 0){ return n + sumAll(n-1); } else { return 0; } } (defn sum-all [n] (if (> n 0) (+ n (sum-all (dec n))) 0)) (defn sum-all2 [n s] (if (> n 0) ( recur (dec n) (+ n s)) s)) (defn sum-all [n] (sum-all2 n 0)) java.lang.StackOverflowError Tail recursion

32. Functional Programming Lazy Evaluation ;; define data (def data [1 2 3 4 5]) ;; a function with side effect (defn side-effect-inc [i] (println i) (inc i)) ;; create lazy sequence with map (def lazy-data (map side-effect-inc data)) ;; consume first 2 items for lazy sequence (take 2 lazy-data) (1 2 3 4 5 2 3) (take 5 (range)) (take 5 (repeat “a”))

33. Functional Programming Declarative Programming DSL (cd "/home/login" (path "/home/login/bin" (run "clojure"))) (cd "/home/login" (path "/home/login/bin" (env "JAVA_OPTS" "-XMaxPermSize=128m" (run "ant compile"))))

35. Lisp Syntax

37. Macro

38. Java Interop

39. Syntax Symbol: user/m

40. Character: \a

41. Integer: 1 2 3

42. String: “hello”

43. Keyword: :world

44. Boolean: true

45. Null: nil

46. Collections Vector: [1 2 3]

47. List: (1 2 3)

48. Set: #{1 2 3}

49. Map: {:a 1 :b 2}

50. (def a 12)

51. (def b “tomcat”)

52. (def c (fn [x y] (+ x y)))

53. (def c #(+ %1 %2))

54. (defn c [x y] (+ x y))

56. Lisp Syntax

58. Macro

59. Java Interop

60. State management Coordinated vs. Independent State Coordinated updates can’t just take one identity into account—they have to manage the states of several interdependent identities to ensure that they are all updated at the same time and that none are left out. Synchronous vs. Asynchronous Updates

61. State management Ref - Synchronous, Coordinated

62. Atom – Synchronous, Independent

63. Agent – Asynchronous

64. Vars – Thread local values

65. State management ;;refs and STM (def a (ref 0)) (def b (ref 1)) (dosync (alter a inc) (alter b + @a)) @a @b ;;atoms (def a (atom 0)) (def b (atom 1)) (swap! a inc) (swap! b + @a) @a @b ;;agents (def a (agent 0)) (def b (agent 1)) (send a inc) (send b + @a) ;;thread local binding (def a 0) (def b 1) (binding [a 100] (+ b a)) a

66. STM Multiple version concurrent control Each transaction gets its own view of the data that it’s interested in.

67. Each transaction merrily chugs along making changes to in-transaction values only.

68. Examine the refs against the modification target for conflicts.

69. Commit changes or Retry

71. Lisp Syntax

73. Macro

74. Java Interop

75. Macro Write code that writes code

76. Macro (defmacro cd "change current directory" [path & cmd] `(str "cd " ~path "; " ~ @cmd) ) (defmacro run "simply run a command" [cmd] `(str ~cmd "; ") )

77. Macro (cd “/home/nsun” (run “rm -rf ./*”)) cd /home/nsun; rm -rf ./*; (macroexpand '(cd "/home/nsum" (run "rm -rf ./*"))) (clojure.core/str "cd " "/home/nsum" "; " (run "rm -rf ./*"))

79. Lisp Syntax

81. Macro

82. Java Interop

83. Java Interop – Java for Clojure (import java.util.Date) (def now (Date.)) (.getTime now) (System/currentTimeMillis)

84. Java Interop - Clojure->Java (ns gen-class-test.core (:gen-class :state value :init init :constructors {[String] []} :methods [[printValue [String] void] ^{:static true} [version [] String]])) (defn version [] "1.0") (defn -init [name] [[] (atom {:name name})]) (defn -printValue [this prefix] (println (str prefix @(.value this))))

85. Real World Clojure where functional programming landed

86. Real World Clojure Network programming

87. Web development

88. Databases

89. Network Programming Aleph – network programming framework (HTTP/TCP/UDP)

90. Lamina – Abstraction of Queue

91. Gloss – Abstraction of bytes protocol

92. Based on Netty

93. Aleph (defcodec dummy-codec (finite-frame :int24 (string :utf8))) (defn echo-handler [ch client-info] (receive-all ch #(do (println %) (enqueue ch %)))) (start-tcp-server echo-handler {:port 1234, :frame dummy-codec}) Gloss codec Lamina queue Aleph

94. Web Development Web handler abstraction Ring (Similar to WSGI, Rack) Web frameworks Compojure

95. Noir

96. Ring (defn app [req] {:status 200 :headers {"Content-Type" "text/html"} :body "Hello World from Ring"}) Middleware Middleware Middleware Handler Middleware

97. Compojure framework (defroutes default-routes (GET "/rage/:id" [] get-rage) (GET "/rages/:channel" [] get-rages)) (defn get-rage [req] (let [id (:id (:params req))] (json-response (get-data id)))) (defroutes default-routes (GET "/rage/:id" [] get-rage) (GET "/rages/:channel" [] get-rages))

98. Clojure JDBC DDL ;; database config (def db {:classname "org.hsqldb.jdbc.JDBCDriver" :subprotocol "hsqldb" :subname "testdb" :user "SA" :password ""}) (defn create-db [] (jdbc/with-connection db (jdbc/create-table table-name [:name "VARCHAR(32)" "PRIMARY KEY"] [:submitter "VARCHAR(32)"] [:title "VARCHAR(512)"])))

99. Clojure JDBC DML (jdbc/with-connection db (jdbc/with-query-results results [(str "select * from " (name table-name))] (into [] results)))

100. Clojure People Meet clojure hackers on github

101. @richhickey Creator of clojure

102. Presentations: Simple made Easy

103. Hammock-driven-development

104. @fogus Clojure and ClojureScript core developers

105. Author of “The Joy of Clojure”

106. http://blog.fogus.me/

107. @nathanmarz Leader engineer of backtype (acquired by twitter)

108. Creator of Storm (realtime computation framework)

109. Cascalog (clojure query language on hadoop)

110. @mmcgrana Heroku engineer

111. Author of Ring spec

112. Author of Clj-redis

113. Clj-http

114. Clj-stacktrace

115. ...

116. @technomancy Heroku engineer

117. Emacs hacker Author of emacs-starter-kit Author of leiningen (clojure build tool)

118. @Raynes 17 years old Clojure guy

119. co-developer of Clojail

120. tryclj.com Clojure community and me

121. Many more @ztellman (Aleph, Lamina, Gloss)

122. @ibdknox (Noir, Korma, I Will Build Your Prototype )

123. @weavejester (Compojure, Ring)

124. @ghoseb (Planet Clojure)

125. @cemerick (O'Reilly Clojure Programming)

126. @stuarthalloway (Pragmatic Programming Clojure)

127. @stuartsierra (Clojure core developer, Apress Practical Clojure)

128. Q&A

129. Thanks

Clojure: Practical functional approach on JVM

Recommended

More Related Content

What's hot (20)

Viewers also liked (18)

Similar to Clojure: Practical functional approach on JVM (20)

Recently uploaded (20)

Clojure: Practical functional approach on JVM