Main sponsor
(map Clojure everyday-tasks)
Jacek Laskowski

About me
• Functional apprentice to Clojure
• Founder and co-leader of Warszawa JUG
• Conference organizer of Javarsovia, Confitura, warsjawa
• Member of NetBeans DreamTeam
• Blogger of http://JacekLaskowski.pl
• Blogger of http://blog.japila.pl
• @jaceklaskowski
• Member of Apache Software Foundation
• IBMer

Why should I care
about Clojure?
(map Clojure everyday-tasks)
Clojure for real-world, day-to-day programming

List comprehension
(for [x (range 2)
y (range 2)]
[x y])

List comprehension
(for [x (range 2)
y (range 2)]
[x y])
user=> ([0 0] [0 1] [1 0] [1 1])

List comprehension
function
(for [x (range 2)
y (range 2)]
[x y])
user=> ([0 0] [0 1] [1 0] [1 1])

Persistent data
structures
• list ()
• vector []
• map {}
• set #{}
• They can nest freely
• They’re persistent (a.k.a. immutable)

(for [n #{"jacek" "agatka"
"iwetka" "patryk"
"maksym"}]
[n (count n)])

Lists in Clojure
1st item
(fn arg1 arg2 ...)
3rd item
2nd item

Function calls in
Clojure
function name
(fn arg1 arg2 ...)
function param
function param

Reason #1
Functional programming
language

Functional language
• Functions are first-class citizens
• They’re like other values
• They can be
• passed to a function
• returned from a function
• HOF = higher-order function

Function definition
(fn [args]
(body)
(defn function-name [args]
(body))
#(body)

Function call
(function-name arg1 arg2 ...)

Fundamental functions
• map - apply a function to a sequence
• returns a sequence
• reduce - accumulation over a sequence
• returns an accumulator
• filter - filters items satisfying a predicate
• return a sequence

map function
Apply a function
(map f ‘(1 2 3)) to a sequence
and return a sequence
in which every item is
‘((f 1) (f 2) (f 3)) transformed by the
function
Examples: addVat, convertCurrency
http://cyrille.martraire.com/2011/03/thinking-functional-programming-with-map-and-fold-in-your-everyday-java/

reduce function
(reduce f ‘( 1 2 3 4 )) Accumulate
over a sequence
and
‘( f ( f ( f 1 2 ) 3 ) 4 ) return the accumulator

Mutation
• Persistent references to a mutable state
• Var - dynamically rebound on a per-
thread basis (thread isolation)
• Ref - transactional via Clojure STM
• Agent - independent, asynchronous
change of individual location
• Atom - synchronous, independent state

(def ^:dynamic *b* 5)
(defn printb []
*b*)
(binding [*b* 10]
(printb))

(def ^:dynamic *b* 5)
(defn printb []
*b*)
(binding [*b* 10]
(printb))
user=> 10

explicit about mutation
(def ^:dynamic *b* 5)
(defn printb []
*b*)
(binding [*b* 10]
(printb))
user=> 10

(def a (ref 0))
(def b (ref 0))
(alter a inc) ;; java.lang.IllegalStateException:
;; No transaction running
(dosync
(alter a inc)
(alter b inc))

(def a (ref 0))
(def b (ref 0))
(alter a inc) ;; java.lang.IllegalStateException:
;; No transaction running
(dosync
(alter a inc)
(alter b inc))
user=> 1

explicit about mutation
(def a (ref 0))
(def b (ref 0))
(alter a inc) ;; java.lang.IllegalStateException:
;; No transaction running
(dosync
(alter a inc)
(alter b inc))
user=> 1

(def c (agent 0))
(send c inc)

(def c (agent 0))
(send c inc)
user=> 1

explicit about mutation
(def c (agent 0))
(send c inc)
user=> 1

(def c (agent 0))
(defn f-agt [v]
(Thread/sleep (* v 1000))
(println (Thread/currentThread))
(inc v))
(send c f-agt)
;; (agent-errors c)
;; (restart-agent c 0)

(def atm (atom 0))
(swap! atm inc)

(def atm (atom 0))
(swap! atm inc)
user=> 1

explicit about mutation
(def atm (atom 0))
(swap! atm inc)
user=> 1

Reason #2
Concurrency abstractions

Namespace, Symbols
and Vars
• Symbol is a name bound to a Var
• (def v ...)
• Vars can be changed on a per-thread
basis
• Namespace is a map of symbols to Vars
• Namespace is similar to a fully-qualified
class name in Java

Clojure REPL

(defn handle-numbers [handler]
(fn []
(doseq [x (iterate inc 0)]
(println (handler x)
(Thread/sleep 1000)))))
(defn sample-handler [x] x)
(def th (Thread. (handle-numbers sample-handler)))
(.start th)
(defn sample-handler [x] (- x))
(.stop th)
(defn sample-handler [x] x)
(def th (Thread. (handle-numbers #'sample-handler)))
(.start th)

(import [javax.swing JFrame]
[java.awt.event ActionListener])
(def f (JFrame. "A window"))
(.setSize f 300 100)
(.setVisible f true)
(import [javax.swing JButton])
(def b (JButton. "Press me!"))
(.add f b)
(.pack f)
(.addActionListener b
(proxy [ActionListener] []
(actionPerformed [evt]
(println "I’ve been pressed"))))

Reason #3
Dynamic programming

Values in Clojure
• Strings are just instances of java.lang.String
user=> (.charAt “abc” 0)
• Numbers, characters, nil, true, false, and
keywords evaluate to themselves
user=> (Character/isLetter c)

Regular expressions
• #"pattern" - java.util.regex.Pattern
• (re-seq re s) lazy seq of matches of re in s
• (re-find m) the next regex match
• (re-matches re s) returns the match
• (re-matcher re s) gives j.u.regex.Matcher
• (re-groups m) returns the groups

user=> (def ptrn #"[0-9]+")
#'user/ptrn
user=> (class ptrn)
java.util.regex.Pattern
user=> (re-seq ptrn "abc 123 a 2 2 1")
("123" "2" "2" "1")

Java interop
• (.instanceMember instance args*)
• (.instanceMember Classname args*)
• (Classname/staticMethod args*)
• Classname/staticField

Java interop macros
• (.. instance-expr member+)
• (doto instance-expr
(instanceMethodName-symbol args*)*)
• (Classname. args*)

Reason #4
Easy Java interop

clojure.main
• Run scripts from the command line
• java -jar clojure.jar your-script.clj args*

AOT compilation
• Clojure compiles all code you load on-the-
fly into JVM bytecode
• Ahead-of-time (AOT) = before on-the-fly
at runtime
• Target of (compile) is namespace
• Each file, fn, and gen-class give new .class

:gen-class sample
(ns helloworld Classname

:gen-class sample
(ns helloworld
(:gen-class)) Execute AOT

:gen-class sample
(ns helloworld
(:gen-class))
(defn -main [& args] the main function

:gen-class sample
(ns helloworld
(:gen-class))
(defn -main [& args]
(println "Hello world!")) the main’s body

:gen-class sample
(ns helloworld
(:gen-class))
(defn -main [& args]
(println "Hello world!"))

AOT in Practice
• lein new [project-name]
• Add :main to project.clj
• lein uberjar
• java -jar [project-name-ver-standalone.jar]

Java EE web apps with Clojure
(Maven and Leiningen are there, too!)
http://blog.japila.pl/2012/03/java-ee-web-apps-with-clojure-maven-and-leiningen-are-there-too/

$ mvn archetype:generate
-DarchetypeArtifactId=maven-archetype-webapp
-DgroupId=com.mycompany.app
-DartifactId=my-webapp-demo

$ mvn archetype:generate
-DarchetypeArtifactId=maven-archetype-webapp
-DgroupId=com.mycompany.app
-DartifactId=my-webapp-demo
$ lein new my-webapp-demo-clj

$ mvn archetype:generate
-DarchetypeArtifactId=maven-archetype-webapp
-DgroupId=com.mycompany.app
-DartifactId=my-webapp-demo
$ lein new my-webapp-demo-clj
(ns my-webapp-demo-clj.core
(:gen-class
:methods [[hello [String] String]]))
(defn -hello
[this s]
(str "Hello, " s))

$ mvn archetype:generate
-DarchetypeArtifactId=maven-archetype-webapp
-DgroupId=com.mycompany.app
-DartifactId=my-webapp-demo
$ lein new my-webapp-demo-clj
public String hello(String)
(ns my-webapp-demo-clj.core
(:gen-class
:methods [[hello [String] String]]))
(defn -hello
[this s]
(str "Hello, " s))

(defproject my-webapp-demo-clj "1.0.0-SNAPSHOT"
:description "FIXME: write description"
:dependencies [[org.clojure/clojure "1.3.0"]]
:aot :all)

(defproject my-webapp-demo-clj "1.0.0-SNAPSHOT"
:description "FIXME: write description"
:dependencies [[org.clojure/clojure "1.3.0"]]
:aot :all)
$ lein install

(defproject my-webapp-demo-clj "1.0.0-SNAPSHOT"
:description "FIXME: write description"
:dependencies [[org.clojure/clojure "1.3.0"]]
:aot :all)
$ lein install
<dependency>
<groupId>my-webapp-demo-clj</groupId>
<artifactId>my-webapp-demo-clj</artifactId>
<version>1.0.0-SNAPSHOT</version>
</dependency>

<html>
<body>
<h2>Hello World!</h2>
</body>
<p>
<%= new my_webapp_demo_clj.core().hello("Jacek") %>
</p>
</html>

<html>
<body>
<h2>Hello World!</h2>
</body>
<p>
<%= new my_webapp_demo_clj.core().hello("Jacek") %>
</p>
</html>
$ mvn package

<html>
<body>
<h2>Hello World!</h2>
</body>
<p>
<%= new my_webapp_demo_clj.core().hello("Jacek") %>
</p>
</html>
$ mvn package

Reason #5
Easy Java interop both
ways

Leiningen
lein - a project automation tool

Starting a project
• lein new [project-name]
• Edit project.clj (mainly deps)
• Also plugin configuration, e.g. :main for
run (soon explained)

Custom project setup
defproject in project.clj customized

Dependencies
• lein deps
• lein search [library]

clojars
Maven repository for Clojure projects
http://clojars.org/

Ongoing development
• lein repl
• lein eclipse
• lein midje (“formerly” lein test)
• lein run
• lein jar
• Some require custom setup...

Unit testing
• clojure.test namespace
• the is macro
(is (= 5 (+ 2 2)) "Crazy arithmetic")
• the are macro
• the deftest macro
(deftest addition
(is (= 4 (+ 2 2)))
(is (= 7 (+ 3 4))))
• (run-tests & namespaces)

lein test [ns]
Runs project tests, optionally only from a ns

src/hi/core.clj
(ns hi.core)
(defn hi
([] "Hi!")
([name] (str "Hi " name "!")))

lein test
$ lein test
Copying 1 file to /Users/jacek/sandbox/hi/lib
Testing hi.test.core
FAIL in (replace-me) (core.clj:6)
No tests have been written.
expected: false
actual: false
Ran 1 tests containing 1 assertions.
1 failures, 0 errors.

test/hi/test/core.clj
(ns hi.test.core
(:use [hi.core])
(:use [clojure.test]))
(deftest hi-simple-test
(is (= (hi) "Hi!"))
(is (= (hi "Clojure") "Hi Clojure!")))

lein test
$ lein test
Testing hi.test.core
Ran 1 tests containing 2 assertions.
0 failures, 0 errors.

Modern unit testing
• Midje - a TDD library for Clojure that
supports top-down ('mockish') TDD
• https://github.com/marick/Midje
• midje.sweet namespace
• fact macro
• (fact "one plus one is two"
(+ 1 1) => 2)

Midje and Leiningen
• lein plugin install lein-midje 1.0.8
• :dev-dependencies [[lein-midje "1.0.8"]
[midje "1.3.1"]]
• lein midje
• lein midje --lazytest

TDD with Midje #0
• :repositories
["stuart" "http://stuartsierra.com/maven2"]
• :dev-dependencies
[com.stuartsierra/lazytest "1.2.3"]

TDD with Midje #1
$ lein midje --lazytest
======================================
At #<Date Tue Feb 21 13:07:52 CET 2012>
Reloading librarian-clojure.run, librarian-clojure.repl, librarian-clojure.test.core, librarian-clojure.core,
librarian-clojure.books, librarian-clojure.db
FAIL at (core.clj:10)
Expected: 2
Actual: 3
FAIL at (core.clj:10)
Expected: 2
Actual: 3
FAILURE: 1 fact was not confirmed. (But 1 was.)
Done.
======================================
At #<Date Tue Feb 21 13:08:11 CET 2012>
Reloading librarian-clojure.test.core
All claimed facts (2) have been confirmed.
Done.

TDD with Midje #2
• (fact "doubles odd numbers"
(my-func 3) => 6)
• (fact "triples even numbers"
(my-func 4) => 12)
• A solution?
http://www.lispplusplus.com/2012/02/tdd-in-midje-in-nutshell.html

TDD with Midje #3
• Which solution do you prefer?
• (defn my-func [n]
(if (odd? n)
(* 2 n)
(* 3 n))
• (defn my-func [n]
(let [multiplier (if (odd? n) 2 3)]
(* multiplier n))
• Monitor lein terminal

Reason #6
Familiar-looking project
tools

Ring
Clojure HTTP server applications
https://github.com/mmcgrana/ring

Compojure
A concise web framework for Clojure
https://github.com/weavejester/compojure

Ring up
jacek:~/oss/librarian-clojure
$ lein ring server
:ring {:handler librarian-clojure.core/app}

Reason #7
Web application libraries

Multimethods
• Runtime dynamic dispatch
• (defmulti say-count count)
(defmethod say-count 0 [_] "Zero")
(defmethod say-count 1 [_] "One")
(defmethod say-count :default [_]
"A Bunch")
• (say-count [1 2 3])
http://blog.fogus.me/2011/10/14/why-clojure-doesnt-need-invokedynamic-but-it-might-be-nice/

user=> (defmulti say-class class)
user=> (defmethod say-class (class {}) [_] "A map")
user=> (say-class {})
"A map"
user=> (say-class [])
java.lang.IllegalArgumentException: No method in multimethod
'say-class' for dispatch value: class clojure.lang.PersistentVector
(NO_SOURCE_FILE:0)
user=> (defmethod say-class (class []) [_] "A vector")
user=> (say-class [])
"A vector"

Reason #8
Multi-level dispatch

Are you still uncertain?
There’s more, but...
time flies by so fast :(