A rundown of the new features for Clojure v1.1 and expected features for v1.2 and beyond.

1. Clojure 1.1 and
Beyond

2. Deprecations
watchers
add-classpath
^
clojure.parallel
clojure.lang.Repl, clojure.lang.Script

3. Watchers
Functions add-watcher and remove-watcher are gone.
Replaced by add-watch and remove-watch.
(def x (ref 0))
(add-watch x :change (fn [key r old new]
(println old " -> " new)))
(dosync (alter x inc))
; 0 -> 1
;=> 1
(remove-watch x :change)
(dosync (alter x inc))
;=> 2
highlight: clojure

4. add-classpath
Used to be able to do insane things like:
(add-classpath "http://github.com/fogus/polyglot/raw/master/reading/onlisp/")
(require '[prolog :as pro])
(pro/fact painter reynolds joshua english)
(pro/db-query 'painter)
;=> ((reynolds joshua english))
highlight: clojure
You should feel unclean by this.
^
Deprecated, use meta instead:
(def x (with-meta [1 2] {:in-love? true}))
^x
;=> {:in-love? true}
(meta x)
;=> {:in-love? true}
highlight: clojure
This is so that ^ can eventually become the type hint reader macro.

5. clojure.parallel
clojure.parallelis being re-worked to use the Java 7 fork-join library. You can
track progress or contribute on Clojure's par branch.
http://github.com/richhickey/clojure/tree/par
REPL and Scripts
clojure.lang.Repl and clojure.lang.Script have been replaced by clojure.main.
java -cp clojure.jar clojure.main # REPL
java -cp clojure.jar clojure.main -i script.clj -r # REPL, load script.clj on startup
java -cp clojure.jar clojure.main script.clj # Run script
java -cp clojure.jar clojure.main -e '(+ 1 41)' # Eval string
java -cp clojure.jar clojure.main - # Run with stdin
highlight: clojure

6. Additions
Primitive Array Generation and Casting
Chunked Sequences
Futures
Promises
Transients
Function pre- and post- conditions
User-controlled Thread Bindings (not discussed)
Ref History (not discussed)
New Namespaces
Miscellaneous

7. Primitive Array Generation
boolean-array, byte-array, char-array, and short-array
(def x (byte-array [(byte 0x71) (byte 0x75) (byte 0x78)]))
(String. x)
;=> "qux"
highlight: clojure
Primitive Array Casting
booleans, bytes, chars, shorts

8. Chunked Sequences
Making sequence operations more efficient since v1.1!
What is the Granularity of Laziness and Sequential Processing?
Prior to 1.1 the answer was 1 element at a time.
For 1.1 and beyond the answer is 1 chunk at a time.

9. A Chunk at a Time

10. Advantages of Chunkiness
Still works on the 1-at-a-time model
Aligns with the underlying data structures
Amortizes the overhead of sequential access
Once every 32 times
Still avoids full realization
Disadvantage
Eliminates full laziness
Although an API for 1-at-a-time laziness is in the works
More Information
http://bit.ly/chunked

11. Futures
Asynchronous computations occuring in other threads that will block if the
expression has not finished. All subsequent dereferencing will return the
calculated value.
(let [x (future (do (Thread/sleep 5000) (+ 41 1)))]
@x) ; ... 5 seconds later
;=> 42
highlight: clojure
Also useful: future-call, future?, future-done?, future-cancel, future-cancelled?.
Promise / Deliver
A hand-off reference used to deliver a value from one thread to another. Any
attempt to dereference will block until "delivery".
(def x (promise))
(.start (Thread. #(do (Thread/sleep 5000) (deliver x "Dear John"))))
@x
; ... 5 seconds later
;=> "Dear John"
highlight: clojure

12. Transients
Provides a mutable subset of functions to use on transient versions of the
standard collection types.
Used on locals only and only on vectors, hash-maps, and hash-sets
Support the read-only functions
transient, persistent!, conj!, assoc!, dissoc!, pop!, disj! to mutate
Thread-safe. Modification attempt in a different thread throws an execption
Here is a transient version of concat:
(defn zen-cat [x y]
(loop [src y, ret (transient x)]
(if src
(recur (next src) (conj! ret (first src)))
(persistent! ret))))
(zen-cat [1 2 3] [4 5 6])
;=> [1 2 3 4 5 6]
highlight: clojure
Rememeber to call persistent! before returning your transient only if you
intend to give out a mutable version:
(persistent! (conj! (zen-cat [1 2 3] [4 5 6]) 7)) ;; assume just ret on return
;=> [1 2 3 4 5 6 7]
highlight: clojure

13. :pre and :post
Sets constraints on the input and output of a function.
(defn constrained-fn [f x]
{:pre [(pos? x)]
:post [(= % (* 2 x))]}
(f x))
(constrained-fn #(* 2 %) 2)
;=> 4
(constrained-fn #(* 2 %) -2)
; java.lang.AssertionError: Assert failed: (pos? x)
(constrained-fn #(* 3 %) 2)
; java.lang.AssertionError: Assert failed: (= % (* 2 x))
highlight: clojure

14. New Namespaces
clojure.test
clojure.test.junit
clojure.stacktrace
clojure.walk
clojure.template

15. Misc.
juxt
((juxt a b c) x) => [(a x) (b x) (c x)]
((juxt + *))
;=> [0 1]
((juxt - /) 2)
;=> [-2 1/2]
highlight: clojure

16. Clojure 1.2 (probably)
reify
deftype
defprotocol
Fine-grained locals clearing
Agent error handlers
Clojure 1.?
Clojure in Clojure
IO streams (not discussed)
Chunked sequence API (not discussed)
Program verification via Datalog (not discussed)
Finger trees (read The Joy of Clojure)

17. Reify -- aka newnew
Like proxy, except:
Only protocols or interfaces
Method bodies are true methods and not external functions
No dynamic swapping of methods
Must be AOT'd
Deftype
Dynamically generates bytecode for an anonymous class with some fields and a type slot
Might also generate methods for protocols or interfaces
Can be AOT'd for extra benefits
Like defstruct, except:
Generates a class with fields, no map lookups
Faster field lookup
Has a proper type slot
Fields can be primitive and hinted
Can implement any number of protocols or interfaces
More Information
http://bit.ly/clj-types

18. Protocols
The best of interfaces
Signatures only
Multiple implements
Without the mold
Which interfaces to implement are defined along with the type
Avoids isa/instanceof and heirarchies
And Even Better
Allows independent extension
Single dispatch on type
More Information
http://bit.ly/clj-protocols

19. Fine-grained Locals Clearing
(let [r (range 1e9)] [(first r) (last r)])
; java.lang.OutOfMemoryError: Java heap space
highlight: clojure
No need for strict tail-position adherence!
More Information
http://bit.ly/luz-ur-head

20. Agent Error Queues
Since agent actions are run in other thread(s), what happens if exceptions are
thrown?
Currently
Exceptions are stored in the agent itself and accessed/cleared by agent-
errors/ clear-agent-errors
Future
Callbacks provided a queue of errors and react based on :continue and :fail
error modes
More information
http://bit.ly/clj-aeh

21. Clojure in Clojure (cinc)
Clojure is three parts:
1. The compiler -- JAVA
2. The data structures -- JAVA (mostly)
3. clojure.core+ -- CLOJURE
Clojure in Clojure is the effort to replace the Java bits above with Clojure
without losing the JVM.

22. Toward Clojure in Clojure
reify is of the utmost importance
We could use proxy and gen-class but too slow
The compiler and reader could be written in Clojure today
But first types and protocols should be rolled out

23. Why Clojure in Clojure?
Porting
No need to port the structures
Only (relatively) tiny bits of the compiler
Description of Clojure's special forms
Using the JVM to bootstrap other platform targets
But What is Clojure?
Too philosophical for this talk.
More Information
http://blog.n01se.net/?p=41

24. Questions?
http://joyofclojure.com
http://manning.com/fogus
Order today with code 'j1337' and get a whopping 37% off!