This document provides an overview of the Clojure programming language, including its history, key features, and developer tools. Clojure was invented in 2007 by Rich Hickey as a modern Lisp dialect that runs on the JVM. It has immutable persistent data structures, supports concurrency, and its code is data due to its homoiconic nature. Clojure has a simple syntax based on S-expressions and its core library has no side effects. It has a large community that provides many resources for learning and using Clojure.

1. Clojure
Simple Made Easy
Adam Hill @adamhill
Senior Developer
Improving Enterprises

2. History
Invented by Rich Hickey around 2007. He wanted
a modern LISP that could leverage the JVM and
the Java library ecosystem
Cognitect - Commercial face of Clojure. Employs
many key developers. Sells support and a
database (Datomic) written in Clojure
Open Source with Contributor License Agreement

3. Clojure…
Is a LISP
Runs on / Interops with the JVM and CLR …and
now in Javascript with CLJS
Has a Read-Eval-Print-Loop (REPL) workflow

4. Clojure…
Has a simple syntax
Has simple data structures
Has immutable and persistent data structures by
default
Has higher order functions
Is homoiconic

5. Syntax
There is none! …reallly …well not quite :-) (see Stuart’s video)
EDN data
Like Json, but richer constructs (+ Maps, Sets Vectors)
Everything is an expression (S-expressions)
(operations argument)
You have symbols bound to values
Data is the code - No text based syntax
Things that we think of as syntax (control structures, declarations,
function calls) are just lists with operators and args

6. Simple Syntax
Operators can be special operations, macros or
functions
Special ops - def fn if-
fn is a special op to define a function
Functions are first class (Higher Order)
(def five 5)
(def add-1 (fn[x] ( + x 1))))
(add-1 five) => 6
Macros are like C & C++ but can use higher order functions

7. Simple Data Structures
Lists - (1 2 3 4 5)
Map - [:foo “bar” 4 2]
Vectors - [ a b c]
Sets - #{4 5}

8. Immutable by Default
Immutable values over time
Software Transactional Memory - Change binding in a
controlled and in an atomic fashion
Don’t change bound values, you get a new copy
Core library has no side effects
Key to Clojure’s ability to be concurrency safe
No locks in user code

9. More About Data Structs
Immutable
But…
Collections keep their performance guarantees
So the changed versions are not 100% ‘new’
Clever internals to keep copying to a minimum
Something called structural sharing + various clever
internal data structures (ex. HAMT)

10. Dev Environments
Command Line
REPL, nREPL
Build / project tools -
Leiningen, boot
Vim
Fireplace
IntelliJ
Cursive, LaClojure
Emacs
CIDER, Emacs-live
Eclipse
Counterclockwise
LightTable
Visual Studio - CLR
VSClojure

11. The Cool Bit
“Homoiconicity”
Big word that simply means:
“Code is data / Data is code”
Macro facilities to add capabilities (SOP in LISPs)
Core.async
Transducers -> Composable, algorithmic transformations
Core.logic -> Logic programing ala PROLOG
Want something cool? ADD IT!

12. Example of Coolosity
(dissoc
(assoc
{:name “John” :password “secret”}
:nickname “Jon”)
:password)
hard to read for humans
have to read it inside out

13. Thread First Macro (->)
(-> {:name “John” :password “secret”}
(assoc :nickname “Jon”)
(dissoc :password))
Macro’s to the rescue!
After all - code <==> data

14. Community Resources
clojure.org
Videos (ClojureTv on YouTube)
Any Rich Hickey video - ‘Simple Made Easy’ & ‘Hammock Driven
Development’
Stewart Halloway - ‘Introduction to Clojure’
Clojure Koans http://clojurekoans.com
Metablog http://planet.clojure.in/
Community Docs http://clojuredocs.org/
Grimoire - Cookbook / Examples http://grimoire.arrdem.com/
Web problems (a la Project Euler) http://www.4clojure.com/
Online REPL http://www.tryclj.com

15. Questions?
Adam Hill @adamhill
Senior Developer