Tuesday, July 23, 2013

OSCON Introduction to Clojure

The Introduction to Clojure page on the OSCON site.

Neal Ford (ThoughtWorks)
9:00am Tuesday, 07/23/2013
bit.ly/clojureinsideout

My notes from the Introduction to Clojure session.



Clojure is Functional, Dynamic, Hosted, Open Source, has an Atomic Succession Model, Lisp

The most enjoyable part of this presentation was that I was back in Lisp land again. Although I only spent 6 to 12 months working in Lisp I love the radically different structure and syntax of this language.

Data:
EDN Extensible Data Notation
data is immutable
nil - nil, null, nothing
booleans - true or false
strings - double quotes, can span multiple lines,, include \t \r \n
char - same as JVM
integer - same
double - same

Two syntaxes for naming things
symbols - e.g. variable names and namespaces, should map to something
keywords - like enumeration values, must start with :

Collections
lists - a sequence of values, zero or more elements within () like lisp
vectors - in [] like an array, supports random access
maps - key/value associations, looks like JSON, can have a vector as key, keys are unique
sets - {} collection of unique values

Clojure syntax is edn + language syntax
println("Hello World") becomes (println "Hello, world")

Operators: (+ 1 2 3 4 5)

Infix
int x = 40 - (5 + 10 * 2) becomes:
(def x (- 40 (* 2 (+ 5 10))))

Defining functions
(defn greet     <- name
"some text"  <-
[your-name]
(str "Hello, " your-name))

(defn larger [x y]
    (if (> x y) x y ))

Anonymous Functions
(map (fn [x] (* x 2)) (range 10))
i.e. pass functions as parameters
result (0 2 4 ... 18)
syntactic sugar for above:
(map #(* % 2) (range 10))

Namespaces
(ns com.example.foo)
- maps to JVM as you'd expect
Can wrap requires:
(:require...
Can add namespace meta data
Use :exclude to override (e.g. override + for vector math)
Don't use :use

Platform Interop
java Math.PI
Clojure sugar: Math/PI

java dot notation
person.getAddress().getZipCode() becomes:
(.. person getAddress getZipCode)

Clojure is a homoiconic language. i.e. it's a language that's represented by its data structure. Languages that you might have heard of that exhibit homoiconicity:
Curl
Julia
Lisp
Scheme (Lisp dialect)
Clojure (Lisp dialect)
Racket (Lisp dialect)
Mathematica
Prolog
SNOBOL
Tcl
XSLT

Functional Programming
- Easier to reason about - higher level of abstraction
- Easier to test
- Easier to compose
- Essential at scale

Persistent Data Structures
Composite values - immutable
'Change' is function of value to value
Collection maintains performance guarantees

uses Bit-partitioned hash tries

Constructing Values
Looping via recursion (recur)
prefer higher-order library fns when appropriate

Recursive Loops
No mutable locals in Clojure
No tail recursion optimization in the JVM
recur op does constant-space recursive loping
Rebinds and jumps to nearest loop or function frame

Loop alternatives
(loop
; reduce with adder fn
(reduce
;apply data constructor fn
(apply
;map into empty (or not) structure
(into
;get lucky
(zipmap

Benefits of Abstraction
Better to have 100 functions operate on one data structure than to have 10 functions operate on 10 data structures - Alan J. Perlis
All Clojure collections have (seq available.

Sequences
Abstraction of traditional Lisp lists
(seq coll)
(first seq)
(rest seq)

In Lisp the first and rest functions used to be called car and cdr.

Lazy Seqs
Evaluated at execution
Very similar to LINQ in C#, same type of syntax

Operations on sequences:
(drop
(take 9 (cycle
(interleave
; splits collection into param partitions
(partition 3
; create key values
(map vector
; use like String.Join():
(apply str (interpose \, "asdf"))
-> "a,s,d,f"
(reduce + (range 100)) -> 4950

(for
is a macro and not an imperative loop

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

Vectors
(def v [42 :rabbit [1 2 3]])
(v 1) -> :rabbit
(peek v) -> [1 2 3]
(pop v)
(subvec v 1)
(contains? v 0) -> true
(contains? v 42) -> false ; last param is index

Maps
(def m {:a 1 :b 2 :c 3})
(m :b) -> 2 ;also (:b m) will work
(keys m) -> (:a :b :c)
(assoc m :d 4 :c 42) ->
(dissoc m :d)
(merge-with

Nested Structures
(def jdoe {:name "John Does", :address {:zip 27705, ...}})
(get-in
(assoc-in
(update-in

Sets
(use clojure.set)
(def colors #["red" "green" "blue})
(disj
(difference
(intersection
(union

Addition
(def v [1 2 3]) ;vector
(def l '(1 2 3)) ;list
(conj v 42) -> [1 2 3 42]
(conj l 42 -> '(42 1 2 3)

(into v [99 :bottles])
(into l [99 :bottles])

Destruction
Pervasive Destructuring
DSL for binding names
Works with abstract structure
Available wherever names are made
sequential (vector) map (associative)

Special Forms
(def symbol init?)
(if test then else?)
;do returns the last value executed:
(do exprs*)
(quote form
(fn name? [params*] exprs*)

(let [binding
(loop
(recur
(throw
(try expr* catch-clause* finally-clause?]

Macros
Thread First ->
(-> 
Do everything from inside out - i.e. first statement is inside statement

Thread Last ->>
(->>

Boids
github.com/relevance/boids
Algorithm in Clojure
Cross compiled to ClojureScript

Example: perfect #

Break exercises
clojure.org - install clojure
leiningen.org - build tool
github.com/functional-koans/clojure-koans -> for beginners
projecteuler.net -> if you know the syntax of clojure

Second part of session

Leiningen
run a REPL etc.
"Maven meets Ant (withou the pain)"
RubyGems/Bundler/Rake

Compojure
Lightweight web framework - most popular
MVC based
github.com/abedra/shouter - example compojure app

Traditional OO
objects are mutable
encapsulate change & info
polymorphism lives inside object
extend via inheritance
interfaces are optional

Clojure
expose immutable data
encapsulate change (not data types)
polymorphism a la carte
interfaces are mandatory
extend by composition

defrecord
(defrecord Person [fname lname address])
(defrecord Address...
(def stu (Person. "Stu" "Halloway" (Address...

defrecord Details:
Type fields can be primitives
Value-based equality & hash
in-line methods defs can inline
keyword field looks can inline
protocols make interfaces

Protocols
(defprotocol AProtocol
     "A doc string for AProtocol abstraction"
      (bar [a b] "bar docs")
      (baz [a] "baz docs"))
named set of generic functions
polymorphic on type of first argument
no implementation
define fns in the same namespaces as protocols

Extending Protocols
(extend-type
Like extension methods in .Net but more extensible
(extend-protocol

ClojureScript extension
; extends JS array
 (extend-type array ISequable

Reify
(let [x 42 r (reify AProtocol ; implement 0 or more protocols or interfaces

deftype
use defrecord for information
use deftype

Concurrency - done at the same time
Parallelism - the execution of items in parallel

Values
immutable
maybe lazy
cacheable forever
can be arbitrarily large
share structure

What can be a value?
42
{:first-name "Stu"...}
anything...

References
refer to values or other references
permit atomic, functional succession
model time and identity
compatible with a wide variety of update parameters

API
(def counter (atom 0))
(swap! counter + 10)

Shared Abilities
@some-ref
(deref some-ref)
(add-watch...

Atoms
(def a (atom 0))
(swap! a inc)
=> 1
(compare-and-set! a 0 42)
=> false
(compare-and-set! a 1 7)
=> true

! - mutates
? - returns true or false

Software Transactional Memory (STM)
refs can change only within a transaction
provides the ACI in ACID (Atomic Consistent Isolated)
(defn transfer
   [from to amount]
   (dosync
     (alter from - amount)
     (alter to + amount)))

(alter from - 1)
=> IllegalStateException No transaction running

STM details
uses locks, latches internally to avoid churn
deadlock detection and barging
no read tracking
only Haskell and Clojure have transactional memory
readers never impede writers
nobody impedes readers

Pending references
work not done yet

Future
(def result (future...
(defef result 1000 or-else) ; timeout
@result deref result) ; wait without timeout

Delay
(def result (delay dont-need-yet))

Promise
(def result (promise)) ; no-org constructor

Java API
all work in Clojure
thin wrapper over Java API

Summary
Clojure is a 21st century Lisp
popular with framework designers
most advanced language constructs
most interoperable with underlying platform
powerful abstractions
active community
"a programming language beamed back from the near future" -Stuart Halloway

No comments:

Post a Comment