This document provides a summary of an introduction to the Clojure programming language. It discusses what Clojure is, its timeline and adoption, functional programming concepts, concurrency features using Software Transactional Memory, the Lisp ideology it is based on including homoiconicity and its macro system. It also provides an overview of getting started with Clojure including using the REPL, basic syntax like symbols and keywords, data types, sequences, functions, and Java interoperability. Resources for learning more about Clojure are also listed.

1. Introduction to Clojure
Programming
Silicon Valley Code Camp
October 8th, 2011
Abbas Raza

2. Myself
user => (def speaker {
:name “Abbas Raza”
:company “SuccessFactors”
:team “Platform Engineering”
:twitter “theceo”})

3. Clojure Foundation
Getting Started
Building Blocks

4. Advanced Topics
Comparing Languages
Comparing Paradigms

5. Thanks!
Rich Hickey
Clojure Creator

6. What is Clojure
General Purpose Language
Dynamic
Functional
Lisp Strengths
Java/CLR/Javascript

7. Clojure - Timeline
First released October 16, 2007
1.0 released 05/04/09
1.1 released 12/31/09
1.2 released 08/19/10
1.3 released 09/23/11
ClojureScript released July, 2011

8. Who’s using Clojure?
http://dev.clojure.org/display/community/Clojure+Success+Stories

9. Functional Programming

10. H/W Perf Free Lunch is over
http://www.gotw.ca/publications/concurrency-ddj.htm

11. Functional Programming
No side effects – immutable
Functions are first class citizens
Functions passed in as parameters
Functions return functions
Functions can be created at runtime

12. Software Transactional Memory
Provides transactional feature for application in
memory
Implements Multi Value Concurrency Control
(MVCC)
Atomic, Consistent, and Isolated

13. Lisp Ideology

14. LISP
Lisp is worth learning for the profound
enlightenment experience you will have when
you finally get it; that experience will make
you a better programmer for the rest of your
days, even if you never actually use Lisp itself
a lot.
- Eric Raymond, How to Become a Hacker

15. Homoiconicity
Code is data is code

16. Macro System
Extends language syntax

17. Java Integration

18. Java Interop
Plethora of libraries
Highly performant
Wide deployment
Calling Java from Clojure and vice
versa

19. What you get from Clojure
Power: JVM/CLR/JS
Robustness: functional
Concurrency: STM
Focus: lisp

20. Suggestion
Focus on the core.
Ignore the edges.

21. Suggestion
Go slow

22. Getting Started
Download clojure zip from
clojure.org/downloads
Run:
java –cp clojure.jar clojure.main

23. REPL
Interactive environment for faster development
Read-Eval-Print-Loop
ns expression
user => (+ 3 4)
7 result
user =>

24. Let’s code a bit

25. Namespace
Define modules
Avoid collision
Format:
(ns name & references)
Example:
(ns svcc)

26. Symbols
Symbols are used to name functions, values, etc.
Example:
str or concat

27. Keywords
A keyword is like a Symbol except that it begins
with a colon (:).
It resolves to itself.
Example:
:foo => :foo

28. S-expressions
Stands for "symbolic expression"
List-based data structures that represent semi-
structured data.
Example:
(def port 8080)

29. Form
Any s-expression that evaluates to a value
Example:
(+ 2 3 4)

30. Atomic Data Types
Clojure Example Java
string “hello” String
character a Character
integer 10 Int/Long/BigInteger
double 3.14159 Double
double 3.14159M BigDecimal
boolean true Boolean
nil nil null
symbol foo, + N/A
keyword :foo, ::foo N/A

31. Data Structures
Type Example Characteristics
list (2 4 6 8) • singly linked
• grows at front
vector [2 4 6 8] • indexed
• grows at end
map {:fname “Rich”, :lname • key/value pairs
“Hickey”} • unique key
set #{2 4 6 8} • unordered
• unique keys

32. Sequences
An abstraction over traditional lisp lists
Provides a view into the lists
Are lazy
Some functions on sequences:
(first seq): returns first element
(cons elem seq): prepends element

33. Syntax – (Prefix) Polish Notation
The operator appears before the operands
Format:
(operator operand operand)

34. Structure
list symbol string
(println “Hello World”)

35. Semantics
fn call argument
(println “Hello World”)

36. Function Definition
define fn fn name
(defn add-numbers
“Add two numbers” documentation
[x y] arguments
(println “result: ” (+ x y))) fn body

37. Comments
Comments start with a semi-colon
(do
;; line comment
;;; block comment
(println “Hello World”)
(println “GoodBye!”)
) ; end of line comment

38. Predicate
It is a function that returns a boolean.
The name ends with a ?.
Example:
even?

39. Higher Order Function
Functions that have functions are parameters.
Example:
map, reduce

40. Essence vs Ceremony
public class AddNumbers {
public static void main(String args[]) {
long sum = 0;
for (int i = 1; i < 1001; i++) {
sum += i;
}
System.out.println("The sum is: " + sum);
}
}

41. Essence vs Ceremony
(println (reduce + (range
1 1001)))

42. Useful Functions
count: returns number of items in a collection
– (count *4 “hello” c+) => 3
apply: applies a function on the arguments
– (apply – [10 5 2]) => 3

43. Program Flow
if, if-not
– (if test consequent alternative)
cond, condp
– (cond & clauses)
when, when-not
– (when test & body)

44. REPL: Doc
Documentation can be viewed with the doc
macro
user=> (doc +)
-------------------------
clojure.core/+
([] [x] [x y] [x y & more])
Returns the sum of nums. (+) returns 0.
nil

45. REPL: javadoc
Opens a browser with the javadoc for the
requested class
user=> (javadoc java.util.Random)
"http://java.sun.com/javase/6/docs/api/java/uti
l/Random.html"

46. REPL: source
Displays the source for the function
user=> (source even?)
(defn even?
"Returns true if n is even, throws an exception
if n is not an integer"
{:added "1.0"}
[n] (zero? (bit-and n 1)))
nil

47. REPL: inspector
Creates a Swing inspector on supplied object
user=> (use 'clojure.inspector)
nil
user=> (inspect (Math/PI))

49. Java Class Import
Importing java classes
Format: (import & import-symbols-or-lists)
Example:
(import
'(java.util Random)
'(java.util Date))

50. Instantiate Java Class
Format: (def instanceName (new ClassName))
Example:
(def sdf (new SimpleDateFormat “yyyy-mm”))
Another way:
(def sdf (SimpleDateFormat. “yyyy-mm”))

51. Java Member Access
Format: (.method instance arguments)
Example:
(.parse sdf date-string)

52. Java Static Access
Format: (Classname/staticMethod args*)
Example:
(Math/PI)

53. Calling Java from Clojure
(import '(java.util Random))
(def rnd (Random.))
(.nextInt rnd 10)

54. Calling Clojure from Java
public class ClojureGreeter {
public static void main(String[] args) {
RT.loadResourceScript("clojure_script.clj");
Var greet = RT.var("clj.sample", “say");
String result = (String) greet.invoke(“John");
System.out.println(“Greeting: " + result);
}
}

55. Error Handling
All exceptions thrown are Runtime Exceptions.
(try expr* catch-clause* finally-clause?)
Example:
(try (/ 1 0)
(catch Exception e (println "in catch"))
(finally (println "in finally")))

56. MultiMethods
Provides a general indirect dispatching
mechanism
Dispatches based on type values, attributes, and
metadata
defmulti creates new multimethods
defmethod create methods for defmulti

57. Compilation Flow

58. Abstract Syntax Tree

59. Clojure Compilation Flow

60. Clojure Compilation Macro

61. Macro System
Allows extending the
compiler
Lot of clojure features are
based on macros
Transform code

62. Macro Example
(defmacro def-print-fn [fn-name args & body]
`(defn ~fn-name ~args
(println "Invoking ...")
~@body))
(def-print-fn simple-call[]
(println "This is a simple call function."))

63. Concurrency
Mutation done in transaction
Readers do not block writers
Writers do not block readers
First one to commit succeeds

64. Concurrency
Mechanism Shared data Synchronous Coordinated Change
Ref Yes Yes Yes
Atom Yes Yes No
Agent Yes No No
Var No No No

65. Leinengin
Build tool
Commands – compile,
test, jar, install, pom,
repl

66. IDE Support
Eclipse Counterclockwise
IntelliJ IDEA La Clojure
Netbeans Enclojure
JEdit
Emacs
Vim
Clooj

67. Clojure and the Web
Compojure
Ring
Noir
Heroku support

68. Resources
http://www.clojure.org
http://dev.clojure.org
http://clojuredocs.org
http://planet.clojure.in
http://clojure-libraries.appspot.com
http://try-clojure.org
http://nealford.com

69. Cheat Sheet
http://clojure.org/cheatsheet

70. … and one last thing

71. Steve,
you’re
simply
Great!

72. Thank You!