Clojure

Created by Andrew Scott

What We'll Cover

- Lisp - Data Handling in Clojure

Lisp

List Processing

Code is Data. Data is Code.

Metaprogramming?

Homoiconicity

Homoiconicity Example


(+ 2 4)
; => 6


(def example (list '+ (+ 1 1) (+ 2 2)))
; => (+ 2 4)


(eval example)
; => 6


(read-string "(+ 2 4)")
; => (+ 2 4)


(eval (read-string "(+ 2 4)"))
; => 6

Why is this useful?

Macros and Clojure

'when' macro


(when (true) (println “hello”))
; => “hello”


(macroexpand ‘(when (true) (println “hello”)))
; (if (true) (do (println “hello”)))


(defmacro when
    "Evaluates test. If logical true, evaluates body in an implicit do."
    {:added "1.0"}
    [test & body]
    (list 'if test (cons 'do body)))

Aren't macros just functions?

Functions	Macros
Execute at runtime	Execute at compile-time
Take and produce data (values)	Take and produce code

Questions

So Clojure is a Lisp... What else?

Data Manipulation Guarantees

- The old version remains accessible - The new version can be produced efficiently - Both versions satisfy the complexity guarantees

How?

- Data structures are hash array mapped tries - Shallow with high branching factors - Structural Sharing

What does this mean?

Structure of your program

C#, Java, etc.	Clojure
Direct references to things that can change	Indirect references to thing that never change
Concurrency is all convention, all manual	Concurrency semantics are built in

Traditionally composed of direct references to things that can change. As soon as you've done that, you are stuck with locking and managing synchronization. Why is this bad? Everything is manual and everything is convention (we're locking A before B, we're locking alphabetically, there's a lock over here for these 3 things, don't forget to lock before you do this). Where does all this go? Contrast with Clojure: Rather than having things actually change, you have indirect references to things that can never change. But those references can be made to refer to other things over the course of the application. Gives the same effect of changing over time. Clojure has concurrency semantics for these references. Because they are indirect, your program isn't just twiddling them, your program has to use functions to make them point to different things. And those functions have concurrency semantics. Which means that they're automatic, the language helps you change the things to point to other things and not mess that up, and it's enforced. For instance, some references can only be changed inside a transaction; if you try to change it outside a transaction it throws an exception. Big difference - all convention, all manual. Clojure - things never change. If you dereference one of the references, you get an immutable object. If someone makes that reference point to something else while you're doing calculations, do you care? No. There are also no locks in the application program.

##Review - Lisp (List Processing) - Structural Sharing - Concurrency differences

##References - Code is Data: [https://dzone.com/articles/code-data-data-code#!](https://dzone.com/articles/code-data-data-code#!) - Macros: [https://dzone.com/articles/macro-lifecycle-clojure#!](https://dzone.com/articles/macro-lifecycle-clojure#!) - [https://en.wikipedia.org/wiki/Homoiconicity](https://en.wikipedia.org/wiki/Homoiconicity) - Presentation: [https://github.com/hakimel/reveal.js](https://github.com/hakimel/reveal.js) - Structural Sharing: [https://www.youtube.com/watch?v=wASCH_gPnDw](https://www.youtube.com/watch?v=wASCH_gPnDw) - Concurrency: [https://www.youtube.com/watch?v=dGVqrGmwOAw](https://www.youtube.com/watch?v=dGVqrGmwOAw)