I know Java, why should I consider Clojure?

Introducing Clojure as a powerful JVM language
from a value-added perspective for those that
already know Java.

a.k.a.

“Okay, I know Java, why should I consider
Clojure?”

A little about me
● Avram Aelony
● My programming language evolution
● Notes about evangelism
● use the language you prefer “whenever,
wherever...” like Shakira says
● How I came to Clojure

Disclaimers
● Standing on the shoulders of giants, luminaries
● This is a HUGE topic
● The Good news:
● There are MUCH better (explained, comprehensive,
deeper) talks on this topic than mine
● I will reference them
● Should you remain unconvinced by this talk, there
are inumerable resources online that may be
somewhat more convincing

Audience survey
● Java ?
● Clojure ?
● Other functional language?
● Other JVM language?

Utility
● Why is Clojure useful if you know Java?
● It adds to what you know
● Provides simplicity, concision, more

l

Grand tour
● Idea is to go into the Rationale and introduce Clojure
along the way

● Mostly about the Why rather than the How
● ... some How as well...

Preliminaries and Similarities

Source: "Clojure-Java Interop: A Better Java than Java"
http://www.infoq.com/presentations/Clojure-Java-Interop

Rationale

"I wanted: A Lisp for Functional Programming
symbiotic with an established Platform
designed for Concurrency."

●

- Rich Hickey, creator of Clojure
http://clojure.org/rationale

Break down

1. A Lisp
2. for Functional Programming
3. symbiotic with an established platform
4. designed for Concurrency

A Lisp
● Dynamic typing
● Homoiconic: Uniform, elegant syntax
● Expression oriented: Symbolic expressions
● Lambda calculus: variable binding
● Macros
● Code as data
● Data as code

Clojure Data Structures
● Lists '( 1 2 3 4 )
● new insertions go to the front
● Vectors [ 1 2 3 4 ]
● new insertions go to the back
● Maps { :a 1 :b 2 :c 3 :d 4}
● Sets #{ :a :b :c :d }
● implemented as k/v where k=v.

Immutable Data
● So how can things change?
● New things can be created
● Underlying structure is shared wherever possible
● only connections change

Immutable Data + Structural Sharing

identical?
function that
returns true only
when symbols are
in fact the same
object.

Phillip Potter http://skillsmatter.com/podcast/scala/persistent-data-structures-in-clojure

Collections Abstraction
● Vectors, Maps, Sets can be thought of as Collections.
● Most functions that work on one data structure will
work on any other.
● Easy to change from Vector to Map to Set with minimal
refactoring of functions.

Sequences and Collections
● seqs are persistent and immutable
● seq function
● lazyiness, lazy application
● seq interface

Homo-iconic
Homo = Same, Iconic = representation

Fizz Buzz
Print the numbers from 1 to N
If a number is divisible by 3, print "Fizz" instead
If a number is divisible by 5, print "Buzz" instead
If a number is divisible by 3 and 5, print "FizzBuzz" instead

S-Expressions, data as code

as seen in The Joy of Clojure

S-Expressions, data as code
● John McCarthy
● assign symbolic names to clojure data
● trees of expressions, each of which returns a
value
● functions can be assigned to vars
● def, fn, defn

http://en.wikipedia.org/wiki/Symbolic_expression

Macros
● Why Macros?
● to arrange code differently
– Threading macros -> and ->>
– infix versus postfix
– dot and dot dot macros for Java interop
● to remove or reduce boilerplate code

“The whole language is always available. There is no real distinction
between read-time, compile-time, and runtime. You can compile or run code
while reading, read or run code while compiling, and read or compile code at
runtime.”

“Running code at read-time lets users reprogram Lisp's syntax; running code
at compile-time is the basis of macros; compiling at runtime is the basis of
Lisp's use as an extension language in programs like Emacs; and reading at
runtime enables programs to communicate using s-expressions, an idea
recently reinvented as XML. “

What Made Lisp Different
http://www.paulgraham.com/diff.htm

Compilation
● “Clojure compiles all code you load on-the-fly
into JVM bytecode, but sometimes it is
advantageous to compile ahead-of-time (AOT).”

http://clojure.org/compilation

Functional Programming
● tools to avoid mutable state, data
● referential transparency
● functions are first class objects
● emphasizes application of functions
● emphasizes recursive iteration
● encourages higher-order functions

http://clojure.org/functional_programming
http://en.wikipedia.org/wiki/Functional_programming
http://en.wikipedia.org/wiki/Referential_transparency_%28computer_science%29

Referential Transparency
● expressions can be replaced with their value without
changing the behavior of the program
● easier to reason about programs

“... can help in proving correctness,
simplifying an algorithm,
assisting in modifying code without breaking it,
or optimizing code by means of memoization,
common subexpression elimination or parallelization.”
-wikipedia
http://en.wikipedia.org/wiki/Referential_transparency_%28computer_science%29

Higher Order Functions
map is an example of a higher order function, since it
applies another function to a collection.

juxt is a higher order function that juxtaposes the values
that result from the application of one or more functions.

I know Java, why should I consider Clojure?

Not exactly what we want without
map

Higher order functions allow for great flexibility in re-shaping data.

JVM as host platform
● Interop as built-in syntax
● Java libraries easily used from Clojure
● e.g. Hadoop, Apache libraries, anything in a
Maven repo, etc..

Java Interop
Clojure Java
Constructor (Widget. “foo”) new Widget(“foo”)
Instance members (.nextInt rnd) rnd.nextInt()
chaining access (.. person getAddress getZipCode) person.getAddress().getZipCode()

(.getZipCode (.getAddress (person.)))

static member access Math/PI Math.PI

Host Platforms
● JVM
● CLR / .NET
● Javascript via Clojurescript

Break down
1. A Lisp
2. for Functional Programming
3. symbiotic with an established platform
4. designed for Concurrency

Designed for Concurrency
● “I don't usually share State, but when I do...”
● Must explicitly use special symbols, functions to
share mutable State.
● Easier to use concurrency safely in Clojure

Designed for Concurrency
● Asynchronous - the request to update is queued to happen in
another thread sometime later. The thread that made the request
can continue immediately.

● Coordinated - reads and writes to multiple refs can be made in a
way that guarantees no race conditions.

● Retriable - work is speculative and may have to be repeated.

Concurrency vs Parallelism
● Parallelism -
partitioning of one task into multiple parts, each that
run at the same time

● Concurrency -
execution of disparate tasks at roughly the same
time, sharing a common resource

mutation a la carte
● Available are
Shared? Asynchronous? Coordinated? Retriable?
Refs yes no yes yes
Agents yes yes no no
Atoms yes no no yes

Transactions
● Software Transactional Memory (STM)
● (dosync ... )
● STM uses Multiversion Concurrency Control
– marks the old data as obsolete and adds the newer
version

– http://en.wikipedia.org/wiki/Multiversion_concurrency_control

Refs
● mutable references to objects
● can only be changed within a transaction (TX)
● (dosync ...)
● no locks. no chance of a deadlock.
● MVCC ensures snapshot isolation, each TX gets its
own view of the data it is interested in.
● each TX is oblivious to other TX's.
● all ref modifications succeed or none do
● If TX2 commits a change while TX1 is working, it may
cause TX1 to be retried.

Refs

commute
This fn should be commutative, or, failing that, you must accept last-one-in-wins
behavior. commute allows for more concurrency than ref-set.

Atoms

swap!
reset!
compare-and-set! - sets atom to new value if and only if current value of
the atom is identical to the old value.

Tooling
● Libraries
● REPL programming
● Leiningen
● project.clj
● No IDE required, but many choices

Libraries
Web: Ring, Noir, HTML: Hiccup, Enlive
● Java libraries Hadoop: Cascalog, Statistics: Incanter
SQL: Korma, CQL, Riak: Welle
● Maven etc... Office Documents: docjure
& more...
● Clojure libraries
● clojars.org

REPL via Leiningen
] lein new clj-excel && cd clj-excel
now edit file “project.clj”

] lein deps && lein repl

REPL via Leiningen
] lein deps
] lein repl

Reading an Excel file
Excel file “sample.xlsx”

IDE's and editors
● Any editor with syntax highlighting will do

● Your favorite Java IDE likely has a Clojure
plugin

● What do most folks use?

1,372 responses were received over 7 days.
Anounced via Twitter & Clojure mailing list
(~6700 recipients)

http://cemerick.com/2012/08/06/results-of-the-2012-state-of-clojure-survey/

That was a whirlwind grand tour...

Thanks for listening!

(def email {:name “aaelony” :domain “@gmail.com”})

I know Java, why should I consider Clojure?

Recommended

More Related Content

What's hot (19)

Viewers also liked (6)

Similar to I know Java, why should I consider Clojure? (20)

Recently uploaded (20)

I know Java, why should I consider Clojure?