A simple introduction to the Clojure programming language. A talk given at the Spring 2011 edition of the JAX London conference.

1. GGeettttiinngg ssttaarrtteedd wwiitthh
((CClloojjuurree))
- or how I learned to stop worrying
and love the (function)

2. Its a strange kind of love...
 Clojure is very different
 Part of your brain may rebel !!
 Homo-Iconic
 List based
 Immutable state
 Dynamically typed
 Tiny syntax
 Infinitely extensible
with Macros

3. What is Clojure
 Functional programming on the JVM
 A better Lisp ?

4. Why get functional ?
 Clock speeds stopped getting faster around
2005
 Cant get around the speed of silicon switches
 Moores law still in effect
 More cores added every 18 months
 Laptops with 128 cores by 2020 ??
 Concurrency at the hardware level
 Not just multi-threading

5. You may end up working
here...

6. Why a better Lisp ?
 Clojure is easier to understand
 Nicer libraries
 Great interoperability with Java
platform
 Closer to pure functional
language
 Explicitly define mutable state
 STM – transactional memory

7. Classic or Re-Imagined
 Lisp  Clojure

8. Why create Clojure
 Concurrency in Java / OO is challenging
 Mutable state-full paradigm
 Fast enough persistent data structures made it
viable
 Functions as first class
 Functions part of data structure
 Functions do not have “side effects”
 Focus on computation (maths) rather than
procedural algorithms

9. Why use Clojure
 Its a pure functional programming language
 You can use existing Java code and platform
 Simple syntax
 It gets you thinking differently !!!
 An excuse to learn Emacs properly ??

10. The downside of Clojure
( x )

11. The downside of Clojure (2)
( ( x ) )

12. The downside of Clojure (3)
( ( ( x ) ) )

13. The downside of Clojure (4)
( ( ( ( x ) ) ) )

14. The downside of Clojure (...)
( ( ( ( ( x ) ) ) ) )

15. Tool support
 Emacs
 clojure-mode, clojure-test,
paredit-mode
 Netbeans
 enclojure
 IntelliJ
 La Clojure
 Eclipse
 Counterclockwise
plugin
 Build tools
 Leiningen
 Emacs + Slime
 Cake
 Maven

16. Lets look at Clojure code

18. We're not in Kansas any
more...
 Java
package … ;
class …;
member variables;
access retType methodName (param, param) {…}
 Clojure
(ns name-space-name)
(defstruct my-data-struture :label-name)
(functionName param (fn param))
; param's can be functions too !!

19. Its just a tree...

20. … a tree structure
 Functions are data
 Data structures are functions !!

21. Download
 clojure.org
 Or via buld tool
 Maven
 Leiningen
 Cake
 Java
 At least version 5
 Version 6 better
performance and
reporting

22. All hail the REPL
 An interactive shell for clojure
 Using Leiningen (Line – ing – en)
https://github.com/technomancy/leiningen/
lein
lein repl

23. Leiningen Clojure project
lein new
lein deps
lein repl
lein swank
 Create a new clojure project
 Download clojure
 Start the interactive shell
 Start repl server for emacs

24. Leiningen project file
(defproject my-jax-london-project "1.0.0-SNAPSHOT"
:description "A meaningful description"
:dependencies [[org.clojure/clojure "1.2.1"]
[org.clojure/clojure-contrib "1.2.0"]]
:dev-dependencies [[swank-clojure "1.2.1"]
[org.clojars.rayne/autodoc "0.8.0-
SNAPSHOT"]]
:autodoc { :name "London Clojure dojo", :page-title "Dojo API"}
;; Only re-fetch deps when they change in project.clj or when :library-path directory is empty.
:checksum-deps true
:license {:name "Eclipse Public License - v 1.0"

25. Loading code into the REPL
(load-file "temp.clj")
 Stuff too big to type
 use an absolute path or a path relative to
where you launched the REPL
 Use Emacs or other IDE when you're ready

26. Simplest possible examples
(* 2 2)
(+ 1 2 3)
( 24 4 3 2)
( 2 4)
( 2.0 4)
(+ (* 4 5) 22)
(+ 4 (* 3 2) 7)
(+ 3 (* 2 (- 7 2) 4) (/ 16 4))

27. Calling Java... ooooo!!
(javax.swing.JOptionPane/
showMessageDialog nil "Hello World" )

28. Ratio
 Basic data type
 Allow delaying computation
 Avoid loss of precision
(/ 2 4)
(/ 2.0 4)
(/ 1 3)
(/ 1.0 3)
(class (/ 1 3)

29. Simple function example
(defn hello-world [name] (println(str "Hello "
name)))
(hello-world "jr0cket")

30. What class is that...
(class (str "Jr0cket"))
java.lang.String
(class (defn hello-world [name] (str "Hello cruel
world")))
clojure.lang.Var

31. str
(str h e l l o)  Concatenate strings
together
 Can represent a
character using

32. Booleans / Expressions
(= 1 1.0)
(= 1 2)
(< 1 2)
 True is a symbol, but
also
user=> (class true)
java.lang.Boolean
(if 0 (println “True”))
(if nil (println “True”))
(if “” (println “True”))

33. More examples
(last [1 1 2 3 5 8])
(defn penultimate [x]
(last (butlast x)) )
(penultimate [1 2 3 4 5])
 (doc last)
 (doc butlast)

34. And more...
(nth [1 1 2 3 5 8] 2)
(count [1 1 2 3 5 8])
(reverse [1 1 2 3 5 8])
(defn palindrome? [x]
(= x (reverse x)) )
 Proposition – naming
convention

35. Even more
(flatten [[1 1] 2 [3 [5 8]]])
(compress "aaaabccaadeeee")
(encode "aaaabccaadeeee")
(replicate 10 "a")

36. Where to find out more...
http://clojure.org/cheatsheet
http://clojure.github.com/cloj
ure/clojure.core-api.html

37. Your own functions
 Define your own algorithms
(defn square [x] (* x x))

38. Anonymous functions
 (fn ) (# )
(def sqr #(* % %))

39. Overloading functions
(defn make
([ ] ; the make function that takes no arguments
(struct vector 0 0))
([x y] ; ... takes x and y keywords as arguments
(struct vector x y))
)

40. Pure functions – no side effects
 Clojure functions are pure
 they have no side effects
 Unless you define them as such
 Pure functions are easy to develop, test, and
understand
 Aim for pure functions where possible

41. Clojure data structures
 ( Lists ) - Ordered collection of elements
 (list 1 3 5) '(8 13 21)
 { map }

 [ Vectors ] - Optimised for random access
 [:tom :dick :harry]
 Lists are for code, Vectors for data
 (nth [:tom :dick :jane :harry ] 2)

42. List operations
(first 1 2 3)
 The head of the list
(last 7 8 9)
 The last element of the list
(rest 1 2 3 4 5)
 Everything but the head
(cons :new-list '(1 2 3 4 5))
 New list, given head and tail

43. More data structures...
(defstruct date :day :month :year)
(struct date)
 as we did not specify any parameters, we just
get nil values
 things in curly brackets are hash maps - the
usual Java hashmaps

44. maps
 { :a 1 :b 2}
 user=> { :a 1 :b 2}
 {:a 1, :b 2}
 user=> { :a 1 :b }
 java.lang.ArrayIndexOutOfB
oundsException: 3
 user=> { :a 1 :b 2}
 {:a 1, :b 2}
 user=> { :a 1 :b 3} ; this
should make the repl
complain in clojure 1.2,
fine in 1.1
 {:a 1, :b 3}
 user=> {:a {:a 1}}
 {:a {:a 1}}
 user=> {{:a 1} :a}
 {{:a 1} :a}
 ; idiom - put :a on the left

45. Vectors
 [:neo :morpheus :trinity :smith]
 [:matrix-characters [:neo :morpheus :trinity
:smith]]
 (first [:neo :morpheus :trinity :smith])
 (nth [:matrix :babylon5 :firefly :stargate] 2)
 (concat [:neo] [:trinity])
 (def my-vector
 (vector? x)

46. Your own data structures
 Special forms
(def johnny {:first-name "John", :last-name
"Stevenson"})
(defstruct person :first-name :last-name)
(defrecord person [String :first-name String
:last-name] :allow-nulls false)

47. Memory use
 Once all references to an immutable structure
disappears it can be garbage collected.
 Loops that create intermittent structures are
garbage collected every turn of the loop.
;;Memory : 0
(let [a (range 50000)]) ;; Memory: "big" while
the let is "executing"
;;Memory : 0 -- no reference to a anymore !

48. macros
 Define extensions to the language
 Clojure only has 7 primitive functions
 Everything else in the language is created with
macros
 Allows the language to be extended easily
without changes to the compiler

49. Special forms
 Recognized by the Clojure compiler and not
implemented in Clojure source code.
 A relatively small number of special forms
 New ones cannot be implemented
 catch, def, do, dot ('.'), finally, fn, if, let, loop,
monitor-enter, monitor-exit, new, quote,
recur, set!, throw, try and var

50. if
user=> (doc if)
-------------------------
if
Special Form
Please see http://clojure.org/special_forms#if
nil

51. Sequences
 Sequences are logical views of collections
 Logical lists
 Java collections, Clojure-specific collections,
strings, streams, directory structures and XML
trees.
 New Clojure collections created efficiently
 Creates a sort of branch (delta) in the data
structure tree

52. Working with Sequences
 first
 rest
 cons

53. Software Transactional
Memory
 Works like transactional databases
 Provides safe, concurrent access to memory
 Agents allow encapsulated access to mutable
resources

54. Sharing mutable data
 Use mutable references to immutable data
 Reference Types
 synchronous access to multiple pieces of
shared data ("coordinated") by using STM
 Atoms
 synchronous access to a single piece of shared
data.
 Agents
 asynchronous access to a single piece of
shared data

55. Name-spaces
 Define a namespace
(ns name-space-name)
 Include namespace code
(use 'names-space-name)
 Like a package statement in Java

56. Clojure Libraries
(use 'clojure.contrib.str-utils)
'
 Dont treat the next thing as a function
 Open source libraries - http://clojars.org/

57. Recursive functions
 Functions that call
themselves
 Fractal coding
 Tail recursion
 Avoids blowing the
heap
 A trick as the JVM
does not support
tail recursion
directly :-(

58. Tail recursion
(defn factorial [x]
(if (= x 0)
1
(* x (factorial (- x 1))
)))
 Dont blow your stack
!!

59. TDD with Clojure is nice
 Clojure test
(deftest test-name
(is (= value (function params))) )

60. Simple test
(ns simple-test
(:use clojure.test)
(:use simple))
(deftest simple-test
(is (= (hello) "Hello world!"))
(is (= (hello "test") "Hello test!")))

61. Working with Java
 Java Classes
 fullstop after class name
 (JFrame. )
 (Math/cos 3) ; static method call
 Java methods
 fullstop before method name
 (.getContentPane frame) ;;method name first
 (. frame getContentPane) ;;object first

62. Importing
(ns drawing-demo
(:import [javax.swing JPanel JFrame]
[java.awt Dimension]))

63. Working with Java (2)
 Clojure gives you clean, simple, direct access
to Java
 call any Java API directly
 (System/getProperties)
 -> {java.runtime.name=Java(TM) SE Runtime
Environment

64. Calling Clojure from Java
 Export the clojure to a .jar
 Add the jar to the classpath
 Import the library in your code
 Call it like any other method

65. Errors are inevitable
 In the REPL
(printStackTrace *e)
 *e holds the last exception raised
 Clojure exceptions are Java exceptions

66. Managing State in Immutable
world
 Mutable data structures to share between
threads (Software Transactional Memory)
 refs, vars, atoms, agents
 No locks required for thread safe code, no
deadlocks or race conditions
 Atomically apply changes

67. Mutable functions
 Swap!

 Name functions that have side effects with an
exclamation mark
 Naming convention

68. Deployment
 lein jar
 lein uberjar

69. Documentation
(doc function-name)
(javadoc class-name)
(defn function-name
“A meaningful
description of the
function”
params )
 Show fn description
 Show javadoc in
browser
 Write documentation
for your own
functions

70. Example documentation
(doc str)
Use doc to print the documentation for str:
user=> (doc str)
-------------------------
clojure.core/str
([] [x] [x & ys])
With no args, returns the empty string. With one
arg x, returns x.toString(). (str nil) returns
the empty string. With more than one arg,
returns the concatenation of the str values
of the args.
 Fully qualified
namespace
 Arguments
 Details

71. find-doc
(find-doc “reduce”)
user=> (find-doc "reduce" )
-------------------------
clojure/areduce
([a idx ret init expr])
Macro
... details ...
-------------------------
clojure/reduce
([f coll] [f val coll])
... details ...
 Search for functions
you dont know
 Keyword parameter

72. Autodoc
 Generate a website for your API's
 http://tomfaulhaber.github.com/auto
doc/
 Add dependency to your build file
 http://clojars.org/org.clojars.rayne/autodoc
 lein deps
 lein autodoc

73. Where next
 Coding dojo – London / start your own
 www.londonjavacommunity.co.uk
 Books – Programming Clojure (Pragmatic)
 Website – clojure.org dev.clojure.org
 Full Disclojure
vimeo.com/channels/fulldisclojure
 clojure.jr0cket.co.uk
 99 problems in clojure

74. Credits
No parentheses
were harmed in the
making of this
presentation....

75. TThhaannkk yyoouu
 HHaavvee ffuunn
lleeaarrnniinngg !!!!
JJoohhnn@@jjrr00cckkeett..ccoomm
@@jjrr00cckkeett
jjoohhnn..jjrr00cckkeett..ccoo..uukk
cclloojjuurree..jjrr00cckkeett..ccoo..uukk