Clojure - An Introduction for Java Programmers

Clojure
A Dynamic Programming Language for the JVM

An Introduction for Java Programmers
Rich Hickey

Introduction
• Who are you?
• Know/use Lisp?
• Java/C#/Scala?
• ML/Haskell?
• Python, Ruby, Groovy?
• Clojure?
• Any multithreaded programming?

Agenda
• Fundamentals
• Syntax and evaluation model
• Sequences
• Java Integration
• Concurrency
• Q&A

Clojure Fundamentals
• Dynamic
• a new Lisp, not Common Lisp or Scheme
• Functional
• emphasis on immutability
• Hosted on the JVM
• Supporting Concurrency
• Open Source

Why use a dynamic
language?
• Flexibility
• Interactivity
• Concision
• Exploration
• Focus on your problem

Which dynamic language?
• Many options on the JVM

• allow you to leverage your existing
knowledge and code

• Ports to JVM

• JRuby

• Jython

• Native to JVM

• Groovy

• Clojure

Why Clojure?
• Expressive, elegant
• Good performance
• Useful for the same tasks Java is
• Wrapper-free Java access
• Powerful extensibility
• Functional programming and concurrency

Clojure is a Lisp
• Dynamic
• Code as data
• Reader
• Small core
• Sequences
• Syntactic abstraction

Dynamic development
• REPL - Read-eval-print-loop
• Deﬁne functions on the ﬂy
• Load and compile code at runtime
• Introspection
• Interactive environment

Atomic Data Types
• Arbitrary precision integers -12345678987654

• Doubles , BigDecimals
1.234 1.234M

• Ratios -22/7

• Strings -“fred”, Characters -a b c

• Symbols - fred ethel , Keywords - :fred :ethel

• Booleans - true false , Null -
nil

• Regex patterns #“a*b”

Data Structures
• Lists - singly linked, grow at front
• (1 2 3 4 5), (fred ethel lucy), (list 1 2 3)

• Vectors - indexed access, grow at end
• [1 2 3 4 5], [fred ethel lucy]

• Maps - key/value associations
• {:a 1, :b 2, :c 3}, {1 “ethel” 2 “fred”}

• Sets #{fred ethel lucy}

• Everything Nests

Syntax
• You’ve just seen it
• Data structures are the code
• Homoiconicity
• No more text-based syntax
• Actually, syntax is in the interpretation of
data structures

Traditional evaluation
Code
Text
characters
Effect

Compiler

bytecode

Executable
JVM
.class/.jar

Run java

Clojure Evaluation
Code
Text
characters
Effect

Reader

data structures

evaluator/
bytecode JVM
compiler

Interactivity
Code
Text
characters
Effect

Reader

data structures
characters

evaluator/
bytecode JVM
compiler

You

Programs writing Programs
Code
Text
characters
Effect

Reader

data structures
characters

evaluator/
bytecode JVM
compiler

data structures
You
Program

Syntactic Abstraction
Code
Text
characters
Effect

Reader

data structures
characters

evaluator/
bytecode JVM
compiler

data structures
You
Program data structures

Program
(macro)

Expressions
• Everything is an expression
• All data literals represent themselves
• Except:
• Symbols
• looks for binding to value, locally,
then globally
• Lists
• An operation form

Operation forms

• (op ...)

• op can be either:
• one of very few special ops
• macro
• expression which yields a function

Special ops
• Can have non-normal evaluation of arguments
• (def name value-expr)

• establishes a global variable
• (if test-expr then-expr else-expr)

• conditional, evaluates only one of then/
else
• fn let loop recur do new . throw try
set! quote var

Macros
• Supplied with Clojure, and deﬁned by user
• Argument forms are passed as data to the
macro function, which returns a new data
structure as a replacement for the macro call
• (or x y)
(let [or__158 x]
• becomes: (if or__158 or__158 y))
• Many things that are ‘built-in’ to other languages
are just macros in Clojure

Functions
• First-class values
(def five 5)
(def sqr (fn [x] (* x x)))
(sqr five)
25
• Maps are functions of their keys
(def m {:fred :ethel :ricky :lucy})
(m :fred)
:ethel

Syntax Summary
• Things that would be declarations, control
structures, function calls, operators, are all
just lists with op at front:
Java Clojure
int i = 5; (def i 5)
if(x == 0) (if (zero? x)
return y; y
else z)
return z;
x* y * z; (* x y z)
foo(x, y, z); (foo x y z)
foo.bar(x); (. foo bar x)

Sequences
• Abstraction of traditional Lisp lists
• (seq coll)

• if collection is non-empty, return seq
object on it, else nil
• (first seq)

• returns the ﬁrst element
• (rest seq)

• returns a seq of the rest of the elements,
or nil if no more

Sequence Library
(drop 2 [1 2 3 4 5]) -> (3 4 5)

(take 9 (cycle [1 2 3 4]))
-> (1 2 3 4 1 2 3 4 1)

(interleave [:a :b :c :d :e] [1 2 3 4 5])
-> (:a 1 :b 2 :c 3 :d 4 :e 5)

(partition 3 [1 2 3 4 5 6 7 8 9])
-> ((1 2 3) (4 5 6) (7 8 9))

(map vector [:a :b :c :d :e] [1 2 3 4 5])
-> ([:a 1] [:b 2] [:c 3] [:d 4] [:e 5])

(apply str (interpose , "asdf"))
-> "a,s,d,f"

(reduce + (range 100)) -> 4950

Java Interop
(. Math PI)
3.141592653589793

(.. System getProperties (get "java.version"))
"1.5.0_13"

(new java.util.Date)
Thu Jun 05 12:37:32 EDT 2008

(doto (JFrame.) (add (JLabel. "Hello World")) pack show)

;expands to:
(let* [G__1837 (JFrame.)]
(do (. G__1837 (add (JLabel. "Hello World")))
(. G__1837 pack)
(. G__1837 show))
G__1837)

Java Integration
• Clojure strings are Java Strings, numbers are
Numbers, collections implement Collection,
fns implement Callable and Runnable etc.
• Core abstractions, like seq, are Java interfaces
• Clojure seq library works on Java Iterables,
Strings and arrays.
• Implement and extend Java interfaces and
classes
• New primitive arithmetic support equals
Java’s speed.

Swing Example
(import '(javax.swing JFrame JLabel JTextField JButton)
'(java.awt.event ActionListener) '(java.awt GridLayout))
(defn celsius []
(let [frame (JFrame. "Celsius Converter")
temp-text (JTextField.)
celsius-label (JLabel. "Celsius")
convert-button (JButton. "Convert")
fahrenheit-label (JLabel. "Fahrenheit")]
(.addActionListener convert-button
(proxy [ActionListener] []
(actionPerformed [evt]
(let [c (. Double parseDouble (.getText temp-text))]
(.setText fahrenheit-label
(str (+ 32 (* 1.8 c)) " Fahrenheit"))))))
(doto frame
(setLayout (GridLayout. 2 2 3 3))
(add temp-text) (add celsius-label)
(add convert-button) (add fahrenheit-label)
(setSize 300 80) (setVisible true))))
(celsius)

Functional Programming
• Immutable data + ﬁrst-class functions
• Functions produce same output given same
input, and are free of side effects
• Could always be done by discipline/convention
• Pure functional languages tend to strongly static
types (ML, Haskell)
• Not for everyone, or every task
• Dynamic functional languages are rarer
• Clojure, Erlang

Why Functional Programming?

• Easier to reason about
• Easier to test
• Essential for concurrency (IMO)
• Java Concurrency in Practice - Goetz
• Additional beneﬁts for purely functional
languages (static analysis, proof, program
transformation), but not Clojure

Which Functional Language?
• Fewer choices on the JVM
• CAL
• Haskell-like, strong type system
• Scala
• Type system, but immutability optional
• Clojure
• Dynamic types, immutable data

Persistent Data Structures
• Immutable, + old version of the collection is
still available after 'changes'
• Collection maintains its performance
guarantees for most operations
• Therefore new versions are not full copies
• All Clojure data structures persistent
• Hash map and vector both based upon
array mapped hash tries (Bagwell)
• Sorted map is red-black tree

Structural Sharing
• Key to efﬁcient ‘copies’ and therefore
persistence
• Everything is ﬁnal so no chance of
interference
• Thread safe
• Iteration safe

Path Copying
HashMap
HashMap
int count 16
int count 15
INode root
INode root

Concurrency
• Interleaved/simultaneous execution
• Must avoid seeing/yielding inconsistent data
• The more components there are to the data,
the more difﬁcult to keep consistent
• The more steps in a logical change, the more
difﬁcult to keep consistent
• Opportunities for automatic parallelism
• Emphasis here on coordination

State - You’re doing it wrong
• Mutable objects are the new spaghetti code
• Hard to understand, test, reason about
• Concurrency disaster
• Terrible default architecture (Java/C#/
Python/Ruby/Groovy/CLOS...)
• Doing the right thing is very difﬁcult
• Languages matter!

Concurrency Methods
• Conventional way:

• Direct references to mutable objects

• Lock and worry (manual/convention)

• Clojure way:

• Indirect references to immutable persistent data
structures

• Concurrency semantics for references

• Automatic/enforced

• No locks!

Direct references to
Mutable Objects
?
?
42
?
6

Ensuring a consistent Object is on your head

Indirect references to
Immutable Objects
"fred"
"ethel"
42
17
6

Never an inconsistent Object

Persistent ‘Edit’
"fred"
"ethel"
42
17
6

"ricky"
"lucy"
42
17
6

Atomic Update
"fred"
"ethel"
42
17
6

"ricky"
"lucy"
42
17
6

Clojure References
• The only things that mutate are references
themselves, in a controlled way
• 3 types of mutable references
• Vars - Isolate changes within threads
• Refs - Share synchronous coordinated
changes between threads
• Agents - Share asynchronous
independent changes between threads

Refs and Transactions
• Software transactional memory system (STM)
• Refs can only be changed within a transaction
• All changes are Atomic and Isolated
• Every change to Refs made within a
transaction occurs or none do
• No transaction sees the effects of any
other transaction while it is running
• Transactions are speculative
• Will be retried automatically if conﬂict
• Must avoid side-effects!

Concurrency Demo
• Ant colony simulation

• World populated with food and ants

• Ants ﬁnd food, bring home, drop pheromones

• Sense pheromones, food, home

• Ants act independently, on multiple real threads

• Model pheromone evaporation

• Animated GUI
• < 250 lines of Clojure

And much more!
• Metadata
• Recursive functional looping
• Destructuring binding in let/fn/loop
• List comprehensions (for)
• Relational set algebra
• Multimethods
• Parallel computation
• Namespaces, zippers, XML ...

Thanks for listening!

http://clojure.org

Clojure - An Introduction for Java Programmers

Recommended

More Related Content

What's hot (18)

Viewers also liked (8)

Similar to Clojure - An Introduction for Java Programmers (20)

More from elliando dias (20)

Recently uploaded (20)

Clojure - An Introduction for Java Programmers