clojure lisp for the real world - o'reilly mediaassets.en.oreilly.com/1/event/61/clojure_ lisp...

ClojureLisp for the Real World

@stuartsierra#clojure

1Friday, July 22, 2011

Bullet Points

• Values

• Code is data

• Generic data access

• Concurrency


Stuart SierraRelevance, Inc.

Clojure/core

Clojure contributor


Values


Values

3


Values

3 + 2 = 5


Values

3let x =


Values

3let x =

let x = 5


Values

3let = 5


Values

3define = 5


Values

3


Values

3Immutable


Values

3Immutable Persistent


He ll o, world!" "


H e ll o , w o r l d ! \0

greeting

char greeting[14];strcpy(greeting, "Hello, World!");


H e ll o , w o r l d ! \0

greeting

char* name = greeting + 7;

name


H e ll o , b o r e d ! \0

greeting

name[7] = 'b';name[10] = 'e';

name


String greeting = new String("Hello, world!");

H e ll o , w o r l d !

java.lang.String

greeting



java.lang.String

greeting

H e ll o , b o r e d !

java.lang.String

String alt = greeting.replace("world", "bored");

alt



java.lang.String

greeting

Immutable


In the real world,values don't change.


Clojure Values

3 Long

6.022e23 Double

"Hello, world!" String

3.0M BigDecimal

9223372036854775808N BigInt

2/3 Ratio


Clojure Values

even? Symbol

:last-name Keyword

(print 99 "bottles") List

[3.14 :pi] Vector

{:x 3 "y" 4} Map

#{7 9 "foo"} Set


Immutable Persistent

Clojure Values



java.lang.String

greeting

H e ll o , b o r e d !

java.lang.String

String alt = greeting.replace("world", "bored");

alt


Clojure Values

ListO(1) at the head

O(n) anywhere else

Vector O(log32n) access

Map O(log32n) access

Set O(log32n) contains?


...

...

...

...


321 = 32322 = 1024323 = 32,768324 = 1,048,576325 = 33,554,432326 = 1,073,741,824327 = 34,359,738,368


log32 1000 < 2log32 10,000 < 3

log32 1,000,000 < 4log32 10,000,000 < 5

log32 1,000,000,000 < 6


In the real world,log32n is fast enough.


Code is Data


#{ {:first "Stuart" :last "Sierra"} {:first "Luke" :last "VanderHart"} {:first "Michael" :last "Fogus"} }

Code is Data



Code is Data

A set of maps


(+ 3 4 5)List

Symbol


(+ 3 4 5)List

Symbol

Function call


(defn average [& nums] (/ (reduce + nums) (count nums)))

(average 3 4 5)

ListSymbols

VectorSymbols

Function call


Host Interop.

(def m (ConcurrentHashMap. 100))

(.put m "key" "value")

constructor

method call


You

Lexer/Parser

Characters

AbstractSyntax Tree

Compiler/Interpreter


Clojure Reader

ClojureCompiler

You Characters

Data Structures


Clojure Reader

You Characters

Data Structures

Macros

ClojureCompiler


(let [file ...initializer...] (try ... do something ... (finally (.close file))))


(defmacro with-open [bindings & body] `(let ~bindings (try ~@body (finally (.close ~(first bindings)))))


(let [file ...initializer...] (try ... do something ... (finally (.close file))))


(with-open [file ...initializer...] ... do something ...)


Generic data access



Generic data access

A set of maps


Author[] authors = ...

String names[] = new names[authors.length];for (int i = 0; i < authors.length; i++) { names[i] = authors[i].getFirstName();}


(defn get-first-name [author] (get author :first))

(map get-first-name authors)("Stuart" "Luke" "Michael")

Higher-orderfunction


(map (fn [a] (get a :first)) authors)("Stuart" "Luke" "Michael")

Anonymous function


(map #(get % :first) authors)("Stuart" "Luke" "Michael")

Anonymous function


(map #(% :first) authors)("Stuart" "Luke" "Michael")

Maps are functions


(map #(:first %) authors)("Stuart" "Luke" "Michael")

Keywords are functions!


(map :first authors)("Stuart" "Luke" "Michael")

Keywords are functions


(map :first authors)

String names[] = new names[authors.length];for (int i = 0; i < authors.length; i++) { names[i] = authors[i].getName();}

vs.


(map function set-of-maps)


(map function set-of-maps)(map function vector-of-sets-of-maps)(map function list-of-vectors)(map function map-of-maps)


(map function set-of-maps)

(map function (resultset-seq query))

(map function (line-seq file))(map function (xml-seq xml-tree))

(map function (file-seq directory))

(map function list-of-vectors)(map function map-of-maps)

(map function vector-of-sets-of-maps)


mapfilter

reducecountsome

removereplace

Sequence API

and lots more...

ListVectorMap

ResultSetStream

DirectoryIterator

XML

and lots more...

Sequence Generators


Polymorphism


Object-Oriented,The Good Parts


multimethod

method

method

method

method

method

dispatchfunction


protocolmethod

method

method

method

protocolmethod

method

method

method

Protocol


Existing Interfaces Your newprotocol here

Existing Types

Existing Method Implementations

Your new type here

and here!


• Sierra "Solving the Expression Problem with Clojure 1.2" IBM DeveloperWorks

• Chris Houser "Clojure's Solutions to the Expression Problem" Strange Loop 2010

The Expression Problem


https://www.ibm.com/developerworks/java/library/j-clojure-protocols/




http://www.infoq.com/presentations/Clojure-Expression-Problem




Concurrency


Concurrency

Parallelism

State


class Invoice { private Date date;

public Date getDate() { return this.date; }

public void setDate(Date date) { this.date = date; }}


class Date { public void setDay(int day); public void setMonth(int month); public void setYear(int year);}

Mutable!




public void setDate(Date date) { this.date = date; }} Better not

change it!




public void setDate(Date date) { this.date = date; }}

Better notchange it!

Better notchange it!


Programming with immutable values

means never having to say you're sorry.


July 25

today


July 25 July 26

today


July 25

Identity

State

July 26

today

Value Value


July 25

Identity

State

July 26

today

function

Value Value

function


July 25

Identity

State

Past

July 26July 24 function

Present Future

function

today


July 25

Identity

State

Past

July 26July 24 function

Present Future

function

today

The future is a function of the past.


Mutable References

Ref Atom

Var Agent


readers

Atomwriter

writer

abortretry


Atom(def tick (atom 1))(deref tick) 1

tick

1



(swap! tick inc)@tick 2

tick

1

2

inc



(swap! tick inc)@tick 2

(swap! tick + 10)@tick 12

tick

2

12

+10


value value value value



identity

identityidentity





identity

identityidentity


Refwriter

writer

readers

abortretryRef

transaction


Ref(def A (ref 1))(def B (ref 10))

A 1

10B



(dosync (alter A inc) (alter B + 10))

A 1

10

20

inc

+10

B

2

transaction



(dosync (alter A inc) (alter B + 10))

A

20

B

2

@A 2@B 20


AtomicConsistentIsolatedDurable

Database Transactions


AtomicConsistentIsolated

Clojure Transactions


Agentactionaction

readers

action queue

Agent Thread Pool


Agent(def A (agent 1))

A 1queue



(send A inc)@A 1

A 1inc

queue



(send A inc)@A 1

A 1inc

2@A 2

queue


Varroot

binding

thread-local

binding

thread-local

binding

other threads


Ref Atom

Var Agent

Concurrency


In the real world, JavaScript is everywhere


ClojureScript


Image Credits

More• Clojure: clojure.org

• Clojure/core: clojure.com

• Me: stuartsierra.com

• @stuartsierra

• openclipart.org

• pdtextures.blogspot.com

• Clojure logo by Tom Hickey99Friday, July 22, 2011

http://pdtextures.blogspot.com/








clojure lisp for the real world - o'reilly mediaassets.en.oreilly.com/1/event/61/clojure_ lisp...

Documents