A Rubyist's Guide to Functional Programming with Clojure

Ruby is such an elegant language! There couldn't be anything for us to learn from Clojure...could there?

Functional programming seems to be all the rage these days. The Clojure programming language is getting a lot of attention, too, and not without reason. Clojure lets you get stuff done in a concise way.

You'll learn:

* Some basic Clojure syntax

* What makes functional programming different from object-oriented programming

* What higher-order functions are, and how we can use them to create powerful abstractions

* Why concurrency is easier and safer in Clojure than in Ruby

We'll wrap up with some lessons we can apply to our own Ruby code. Learning Clojure will make you a better Ruby programmer.

Transcript

1. A Rubyist's Guide to Functional Programming with Clojure
2. Hello! I'm Michael Stalker. I work for We make and
3. Level Up Your Ruby Skills with Clojure
4. Let’s talk about Clojure
5. Who is this talk for?
6. ⚠ WARNING ⚠
7. Let’s talk about Clojure ◦ What? ◦ Why? ◦ How do I get started? ◦ How does this help my Ruby?
8. WHAT IS CLOJURE? 1
9. WHAT IS CLOJURE? 1. It’s a programming language.
10. “ Why did I write yet another programming language? Basically because I wanted: ◦ A Lisp ◦ for Functional Programming ◦ symbiotic with an established Platform ◦ designed for Concurrency and couldn't find one. - Rich Hickey
11. COMMENTS ; I don't have much to say.
12. STRINGS "Hi. I’m a string."
13. NUMBERS 3 4.5
14. KEYWORDS :a :testing
15. MAPS {:a 5, :b "hi", :c [1 2 3]}
16. MAPS {:a 5 :b "hi" :c [1 2 3]}
17. VECTORS [1 2 "hi" "bye"]
18. LISTS '(1 2 3) (list 1 2 3)
19. WHAT IS CLOJURE? 1. It’s a programming language. 2. It’s a Lisp dialect.
20. IT’S A LISP DIALECT ; Add 1 plus 3 (+ 1 3) ;= 4
22. IT’S A LISP DIALECT ; Add 1 plus 3 (+ 1 3) ;= 4 (+ 1 2 3 4) ;= 10
23. DEFINING A VAR (def my-number 3)
24. DEFINING A VAR (def my-number 3) my-number ;= 3
25. A VAR IS A VAR IS A VAR... A var is not a variable.
26. CREATING A FUNCTION (fn [x] (* 2 x))
27. CREATING A FUNCTION (def double (fn [x] (* 2 x))
28. CREATING A FUNCTION (def double (fn [x] (* 2 x)) double 3
29. CREATING A FUNCTION (def double (fn [x] (* 2 x)) double 3 ;= #<user$double user$double@b3f0ef0> ;= 3
31. CREATING A FUNCTION (def double (fn [x] (* 2 x)) double 3 ;= #<user$double user$double@b3f0ef0> ;= 3
32. CREATING A FUNCTION (def double (fn [x] (* 2 x)) (double 3)
33. CREATING A FUNCTION (def double (fn [x] (* 2 x)) (double 3) ;= 6
34. SHORTHAND FOR CREATING A FUNCTION (def double (fn [x] (* 2 x)) (defn double [x] (* 2 x))
35. SHORTHAND FOR CREATING A FUNCTION (def double (fn [x] (* 2 x)) (defn double [x] (* 2 x))
36. SHORTHAND FOR CREATING A FUNCTION (def double (fn [x] (* 2 x)) (defn double [x] (* 2 x))
37. BIGGER FUNCTIONS (defn take [n coll] (lazy-seq (when (pos? n) (when-let [s (seq coll)] (cons (first s) (take (dec n) (rest s)))))))
39. WHAT IS CLOJURE? 1. It’s a programming language. 2. It’s a Lisp dialect. 3. It’s functional.
40. FUNCTIONS ARE FIRST- CLASS CITIZENS
41. FUNCTIONS ARE FIRST-CLASS OBJECTS ◦ Functions are data, just like the string "hi" and the number 3.
42. FUNCTIONS ARE FIRST-CLASS OBJECTS (def my-number 3)
43. FUNCTIONS ARE FIRST-CLASS OBJECTS (def my-number 3) (def double (fn [x] (* 2 x))
44. FUNCTIONS ARE FIRST-CLASS OBJECTS ◦ Functions are data, just like the string “hi” and the number 3. ◦ You can pass functions as arguments to functions.
45. FUNCTIONS ARE DATA (defn add-and-double [x y] (* 2 (+ x y)))
46. FUNCTIONS ARE DATA (defn add-and-double [x y] (* 2 (+ x y))) (defn combine-and-triple [combiner a b] (* 3 (combiner a b)))
47. FUNCTIONS ARE DATA (defn add-and-double [x y] (* 2 (+ x y))) (defn combine-and-triple [combiner a b] (* 3 (combiner a b))) (combine-and-triple add-and-double 4 6)
48. FUNCTIONS ARE DATA (defn add-and-double [x y] (* 2 (+ x y))) (defn combine-and-triple [combiner a b] (* 3 (combiner a b))) (combine-and-triple add-and-double 4 6)
49. FUNCTIONS ARE DATA (defn add-and-double [x y] (* 2 (+ x y))) (defn combine-and-triple [combiner a b] (* 3 (combiner a b))) ;= (* 3 (add-and-double 4 6))
50. FUNCTIONS ARE DATA (defn add-and-double [x y] (* 2 (+ x y))) (defn combine-and-triple [combiner a b] (* 3 (combiner a b))) ;= (* 3 (add-and-double 4 6)) ;= (* 3 (* 2 (+ 4 6)))
51. FUNCTIONS ARE DATA (defn add-and-double [x y] (* 2 (+ x y))) (defn combine-and-triple [combiner a b] (* 3 (combiner a b))) ;= (* 3 (add-and-double 4 6)) ;= (* 3 (* 2 (+ 4 6))) ;= (* 3 (* 2 10))
52. FUNCTIONS ARE DATA (defn add-and-double [x y] (* 2 (+ x y))) (defn combine-and-triple [combiner a b] (* 3 (combiner a b))) ;= (* 3 (add-and-double 4 6)) ;= (* 3 (* 2 (+ 4 6))) ;= (* 3 (* 2 10)) -> 60
53. BLOCKS IN RUBY def combine_and_triple(a, b) 3 * yield(a, b) end
54. BLOCKS IN RUBY def combine_and_triple(a, b) 3 * yield(a, b) end combine_and_triple(4, 6) do |x, y| 2 * (x + y) end
55. BLOCKS IN RUBY def combine_and_triple(a, b) 3 * yield(a, b) end combine_and_triple(4, 6) do |x, y| 2 * (x + y) end #=> 60
56. LAMBDAS IN RUBY def combine_and_triple(a, b) 3 * yield(a, b) end add_and_double = ->(x, y) { 2 * (x + y) }
57. LAMBDAS IN RUBY def combine_and_triple(a, b) 3 * yield(a, b) end add_and_double = ->(x, y) { 2 * (x + y) } combine_and_triple(4, 6, &add_and_double)
58. LAMBDAS IN RUBY def combine_and_triple(a, b) 3 * yield(a, b) end add_and_double = ->(x, y) { 2 * (x + y) } combine_and_triple(4, 6, &add_and_double) #=> 60
59. LAMBDAS IN RUBY def combine_and_triple(a, b, combiner) 3 * combiner.call(a, b) end add_and_double = ->(x, y) { 2 * (x + y) } combine_and_triple(4, 6, add_and_double)
60. LAMBDAS IN RUBY def combine_and_triple(a, b, combiner) 3 * combiner.call(a, b) end add_and_double = ->(x, y) { 2 * (x + y) } combine_and_triple(4, 6, add_and_double) #=> 60
61. SPECIFY BEHAVIOR THROUGH INHERITANCE class NumberProcessor def combine_and_triple(a, b) raise NotImplementedError end end class AdderDoubler < NumberProcessor def combine_and_triple(a, b) 3 * (2 * (a + b)) end end
62. SPECIFY BEHAVIOR THROUGH INHERITANCE class NumberProcessor def combine_and_triple(a, b) raise NotImplementedError end end class AdderDoubler < NumberProcessor def combine_and_triple(a, b) 3 * (2 * (a + b)) end end AdderDoubler.new.combine_and_triple(4, 6)
63. SPECIFY BEHAVIOR THROUGH COMPOSITION class NumberProcessor def combine_and_triple(a, b, combiner) 3 * combiner.process(a, b) end end class AdderDoubler def process(a, b) 2 * (a + b) end end
64. SPECIFY BEHAVIOR THROUGH COMPOSITION class NumberProcessor def combine_and_triple(a, b, combiner) 3 * combiner.process(a, b) end end class AdderDoubler def process(a, b) 2 * (a + b) end end NumberProcessor.new.combine_and_triple(4, 6, AdderDoubler.new)
65. SPECIFY BEHAVIOR WITH A BLOCK class NumberProcessor def combine_and_triple(a, b) 3 * yield(a, b) end end NumberProcessor.new.combine_and_triple(4, 6) { |x, y| 2 * (x + y) }
66. FUNCTIONS ARE FIRST-CLASS OBJECTS ◦ Functions are data, just like the string “hi” and the number 3. ◦ You can pass functions as arguments to functions. ◦ You can return functions from functions.
67. HIGH SCHOOL ALGEBRA y = 2x x y
68. RETURNING FUNCTIONS FROM FUNCTIONS (defn double [x] (* 2 x)) x y
69. RETURNING FUNCTIONS FROM FUNCTIONS (defn double [x] (* 2 x)) x y y = x
70. RETURNING FUNCTIONS FROM FUNCTIONS (defn double [x] (* 2 x)) x y
71. RETURNING FUNCTIONS FROM FUNCTIONS (defn double [x] (* 2 x)) (defn one-and-a-half [x] (* (/ 3 2) x) x y
72. RETURNING FUNCTIONS FROM FUNCTIONS (defn double [x] (* 2 x)) (defn one-and-a-half [x] (* (/ 3 2) x) x y
73. RETURNING FUNCTIONS FROM FUNCTIONS (defn double [x] (* 2 x))
74. RETURNING FUNCTIONS FROM FUNCTIONS (defn double [x] (* 2 x)) (defn average-damp [f] (fn [x] (average x (f x))))
75. RETURNING FUNCTIONS FROM FUNCTIONS (defn double [x] (* 2 x)) (defn average-damp [f] (fn [x] (average x (f x))))
76. RETURNING FUNCTIONS FROM FUNCTIONS (defn double [x] (* 2 x)) (defn average-damp [f] (fn [x] (average x (f x))))
77. RETURNING FUNCTIONS FROM FUNCTIONS (defn double [x] (* 2 x)) (defn average-damp [f] (fn [x] (average x (f x)))) (def damped-double (average-damp double))
78. RETURNING FUNCTIONS FROM FUNCTIONS (defn double [x] (* 2 x)) (defn average-damp [f] (fn [x] (average x (f x)))) (def damped-double (average-damp double)) ;= (fn [x] (average x (double x))
79. RETURNING FUNCTIONS FROM FUNCTIONS (defn double [x] (* 2 x)) (defn average-damp [f] (fn [x] (average x (f x)))) (def damped-double (average-damp double)) (damped-double 4)
80. RETURNING FUNCTIONS FROM FUNCTIONS (defn double [x] (* 2 x)) (defn average-damp [f] (fn [x] (average x (f x)))) (def damped-double (average-damp double)) (damped-double 4) ;= ((fn [x] (average x (double x))) 4)
81. RETURNING FUNCTIONS FROM FUNCTIONS (defn double [x] (* 2 x)) (defn average-damp [f] (fn [x] (average x (f x)))) (def damped-double (average-damp double)) (damped-double 4) ;= ((fn [x] (average x (double x))) 4) ;= (average 4 (double 4))
82. RETURNING FUNCTIONS FROM FUNCTIONS (defn double [x] (* 2 x)) (defn average-damp [f] (fn [x] (average x (f x)))) (def damped-double (average-damp double)) (damped-double 4) ;= ((fn [x] (average x (double x))) 4) ;= (average 4 (double 4)) ;= (average 4 8)
83. RETURNING FUNCTIONS FROM FUNCTIONS (defn double [x] (* 2 x)) (defn average-damp [f] (fn [x] (average x (f x)))) (def damped-double (average-damp double)) (damped-double 4) ;= ((fn [x] (average x (double x))) 4) ;= (average 4 (double 4)) ;= (average 4 8) ;= 6
85. IN RUBY class Damper def double ->(x){ 2 * x } end def average_damp ->(x){ (x + yield.call(x)) / 2 } end def damped_double ->(x){ average_damp { double } } end end damper = Damper.new damper.average_damp { damper.double }.call(4) #=> 6
86. BACK IN CLOJURE (defn average-damp [f] (fn [x] (average x (f x)))) (defn double [x] (* 2 x)) (def damped-double (average-damp double))
87. RETURNING FUNCTIONS FROM FUNCTIONS (defn average-damp [f] (fn [x] (average x (f x)))) (defn triple [x] (* 3 x)) (def damped-triple (average-damp triple))
88. RETURNING FUNCTIONS FROM FUNCTIONS (defn average-damp [f] (fn [x] (average x (f x)))) (def damped-cosine (average-damp Math/cos))
89. RETURNING FUNCTIONS FROM FUNCTIONS (defn average-damp [f] (fn [x] (average x (f x)))) (def damped-cosine (average-damp Math/cos)) (def doubly-damped-cosine (average-damp (average-damp Math/cos)))
90. RETURNING FUNCTIONS FROM FUNCTIONS (defn average-damp [f] (fn [x] (average x (f x)))) (def triply-damped-cosine (average-damp (average-damp (average-damp Math/cos))))
95. WHY USE CLOJURE? 2
96. WHY USE CLOJURE? 1. It’s powerful.
97. “ The shape of a program should reflect only the problem it needs to solve. Any other regularity in the code is a sign...that I'm using abstractions that aren't powerful enough… - Paul Graham
98. “ 16 of 23 patterns [in the Design Patterns book] are either invisible or simpler [in Lisp] - Peter Norvig
99. WHY USE CLOJURE? 1. It’s powerful. 2. It will make you a better programmer.
100. “ Clojure demands that you raise your game, and pays you back for doing so. - Clojure Programming
101. WHY USE CLOJURE? 1. It’s powerful. 2. It will make you a better programmer. 3. It’s fast.
102. SITEMAP GENERATOR Ruby:
103. SITEMAP GENERATOR Ruby: 15-20 minutes
104. SITEMAP GENERATOR Ruby: 15-20 minutes Clojure: 7 minutes
105. WHY USE CLOJURE? 1. It’s powerful. 2. It will make you a better programmer. 3. It’s fast. 4. It makes concurrency easy.
106. Source: http://www.gotw.ca/publications/concurrency-ddj.htm
107. CONCURRENCY IN RUBY # @inventory has 4000 hats. threads = [] 40.times do threads << Thread.new do 100.times { @inventory.decrease(:hats) } end end threads.each(&:join) puts @inventory[:hats]
108. LET’S COMPARE RUBY INTERPRETERS MRI 1.9.3 0
109. LET’S COMPARE RUBY INTERPRETERS JRuby 1.7.2 486 MRI 1.9.3 0
110. LET’S COMPARE RUBY INTERPRETERS JRuby 1.7.2 486 MRI 1.9.3 0 RBX 2.0.0rc1 2
112. JRUBY’S CONCURRENCY BASICS 1. Don't do it.
113. JRUBY’S CONCURRENCY BASICS 1. Don't do it. 2. If you must do it, don't share data across threads.
114. JRUBY’S CONCURRENCY BASICS 1. Don't do it. 2. If you must do it, don't share data across threads. 3. If you must share data across threads, don't share mutable data.
115. JRUBY’S CONCURRENCY BASICS 1. Don't do it. 2. If you must do it, don't share data across threads. 3. If you must share data across threads, don't share mutable data. 4. If you must share mutable data across threads, synchronize access to that data.
116. RUBY’S CONCURRENCY … has some gotchas.
117. SITEMAPPER Ruby: 15-20 minutes Clojure: 7 minutes
118. SITEMAPPER Ruby: 15-20 minutes Clojure: 7 minutes Clojure + core-async: 1.5 minutes
119. 13x faster
120. CLOJURE’S CONCURRENCY … is fantastic.
121. WHY USE CLOJURE? 1. It’s powerful. 2. It will make you a better programmer. 3. It’s fast. 4. It makes concurrency easy. 5. It uses the JVM.
122. WHY USE CLOJURE? 1. It’s powerful. 2. It will make you a better programmer. 3. It’s fast. 4. It makes concurrency easy. 5. It uses the JVM. 6. It favors immutability.
123. “ ...functional programs not having state modification except in very limited constrained ways really does lead to programs that are easier to understand. - Brian Marick
124. IMMUTABILITY Immutability => Understandability
125. IMMUTABILITY Immutability => Understandability Understandability => Fewer Errors
126. HOW DO I GET STARTED? 3
127. BOOK Clojure Programming By Chas Emerick, Brian Carper, Christophe Grand
128. BOOK/WEBSITE Clojure for the Brave and True By Daniel Higginbotham braveclojure.com
129. EDITORS ◦ Light Table ◦ Vim ▫ Fireplace ▫ vim-niji ▫ paredit.vim ◦ Emacs
130. WRITING CODE ◦ REPL: `lein repl` ◦ https://www.4clojure.com/
131. HOW DOES THIS HELP MY RUBY? 4
132. APPLICATIONS FOR RUBY 1. Don't mutate if you don't have to
133. DON'T MUTATE IF YOU DON'T HAVE TO class MyAwesomeClass def with_city(geo_data) geo_data.merge!(city: 'Raleigh') end end
134. DON'T MUTATE IF YOU DON'T HAVE TO class MyAwesomeClass def with_city(geo_data) geo_data.merge(city: 'Raleigh') end end
135. DON'T MUTATE IF YOU DON'T HAVE TO module CityHelper def please_dont_do_this params[:city] = 'Raleigh' end end
136. APPLICATIONS FOR RUBY 1. Don't mutate if you don't have to 2. Learn to love the block
137. APPLICATIONS FOR RUBY 1. Don't mutate if you don't have to 2. Learn to love the block 3. Learn to love Enumerable#inject
138. APPLICATIONS FOR RUBY 1. Don't mutate if you don't have to 2. Learn to love the block 3. Learn to love Enumerable#inject 4. Use the right tool for the job
139. We talked about Clojure ◦ What? ◦ Why? ◦ How do I get started? ◦ How does this help my Ruby?
140. CREDITS ◦ Presentation template by SlidesCarnival ◦ Some photographs by Unsplash ◦ Thread problem: http://www.jstorimer.com/pages/ruby-core-classes-arent- thread-safe ◦ Average damping problem: SICP ◦ https://github.com/jruby/jruby/wiki/Concurrency-in-jruby#concurrency_basics ◦ Jackie Chan image: troll.me ◦ Mind blown image: http://giphy.com/gifs/tim-and-eric-mind-blown- EldfH1VJdbrwY ◦ Paul Graham quote: http://www.paulgraham.com/icad.html ◦ Peter Norvig quote: in PDF found here: http://www.norvig.com/design-patterns/
141. Thanks! ANY QUESTIONS?