Clojure basics

CLOJURE BASICS

Kyle [email protected]@mudphone

Tuesday, March 19, 13

mailto:[email protected]

mailto:[email protected]

Clojure 1.5 was released on March 1st, 2013.

Read this to see changes:https://github.com/clojure/clojure/blob/master/changes.md

My examples use 1.4.0.


https://github.com/clojure/clojure/blob/master/changes.md

https://github.com/clojure/clojure/blob/master/changes.md

“Startups tend to be an all or nothing proposition. You either get rich, or you get nothing. In a startup, if you bet on the wrong technology, your competitors will crush you.”

Paul Graham


“When you choose technology, you have to ignore what other people are doing, and consider only what will work the best.”

Paul Graham


“In a big company, you can do what all the other big companies are doing. But a startup can't do what all the other startups do. I don't think a lot of people realize this, even in startups.”

Paul Graham


“So if you're running a startup, you had better be doing something odd. If not, you're in trouble.”

Paul Graham


“Lisp is so great not because of some magic quality visible only to devotees, but because it is simply the most powerful language available. And the reason everyone doesn't use it is that programming languages are not merely technologies, but habits of mind as well, and nothing changes slower.”

Paul Graham


“I'll begin with a shockingly controversial statement: programming languages vary in power.”

Paul Graham


http://pragprog.com/book/shcloj2/programming-clojure http://clojure.org


http://clojure.org/concurrent_programming




Rich Hickey is a genius. And, I’m just here to piss you off.

Clojure Concurrencyhttp://blip.tv/clojure/clojure-concurrency-819147

22:00 - 23:18

Simple Made Easyhttp://www.infoq.com/presentations/Simple-Made-Easy

15:30 - 17:15


http://blip.tv/clojure/clojure-concurrency-819147


http://www.infoq.com/presentations/Simple-Made-Easy

http://www.infoq.com/presentations/Simple-Made-Easy

Why you should take a look...

functional langs can more easily use multiple cores

purely functional is awkward when dealing with state

Clojure has refs, agents, atoms, dynamic binding

dynamic typing

Java invocation (not functional)

refs (STM)

JVM, calling Java is idiomatic


CLOJURE BASICS

Why is Clojure so cool necessary?

Basic Setup x2 or 3

Language Basics

Working with State (or without it)

Working with government forms Java

Macros

Webby Stuff

Testing

Clojure + Processing + Kinect/OpenNI


Why is Clojure necessary?


Multi-Core Future


Why use the JVM?

The JVM is advanced technology.

Java libraries... lots of them.

Widely deployed


Using the JVMFor example: https://github.com/mmcgrana/clj-redis

(require '[clj-redis.client :as redis])

(def db (redis/init))

(redis/ping db)=> "PONG"

(redis/set db "foo" "BAR")=> "OK"

(redis/get db "foo")=> "BAR"


https://github.com/mmcgrana/clj-redis


JVMFor example: https://github.com/mmcgrana/clj-redis

(ns clj-redis.client (:import java.net.URI) (:import (redis.clients.jedis Jedis JedisPool JedisPoolConfig JedisPubSub)) (:require [clojure.string :as str]) (:refer-clojure :exclude [get set keys type]))

(def ^{:private true} local-url "redis://127.0.0.1:6379")

(defn init ([] (init {})) ([{:keys [url timeout test-on-borrow] :as opts}] (let [uri (URI. (or url local-url)) tout (or timeout 2000) host (.getHost uri) port (if (pos? (.getPort uri)) (.getPort uri) 6379) uinfo (.getUserInfo uri) pass (and uinfo (last (str/split uinfo #":"))) config (JedisPoolConfig.)] (when test-on-borrow (.setTestOnBorrow config test-on-borrow)) (JedisPool. config host port tout pass))) ([k1 v1 & {:as opts}] (init (assoc opts k1 v1))))




JVMFor example: https://github.com/mmcgrana/clj-redis

(defn lease [^JedisPool p f] (let [j (.getResource p)] (try (f j) (finally (.returnResource p j)))))

(defn ping [p] (lease p (fn [^Jedis j] (.ping j))))

(defn get [p ^String k] (lease p (fn [^Jedis j] (.get j k))))

(defn set [p ^String k ^String v] (lease p (fn [^Jedis j] (.set j k v))))




Why is Clojure a secret weapon?

http://www.paulgraham.com/avg.html




Why is Clojure so cool?

Homoiconic

Modern LISP

Functional (but not purely functional)


Homoiconic

Lisp code is just lisp data

Revenge of the Nerds - Paul Graham

Macros == black magic

Reprogramming the language with the language


http://www.paulgraham.com/icad.html

http://www.paulgraham.com/icad.html

Modern

Fewer parentheses

Sequences

Reader macros for data structures

regex, map, set, vector, metadata

First-class data structures: [], {}, ‘()

Less Lipsy than other Lisps (ex: fns use [ ])

Commas are whitespace


List Comprehension

user> (take 40 (for [x (range) :when (and (> (* 2 x) 99) (= 0 (mod x 3)))] (* 2 x)))(102 108 114 120 126 132 138 144 150 156162 168 174 180 186 192 198 204 210 216222 228 234 240 246 252 258 264 270 276282 288 294 300 306 312 318 324 330 336)


Functional

Functions are first-class

Data is immutable

Functions are NOT pure


Why Functional?

Simple

Thread-safe

Parallelizable

Generic


Clojure’s approach to Functional Programming

Not purely functional

Has system for working with refs, agents, atoms, and dynamic binding

Dynamic typing

Java invocation is NOT functional


“Mutable objects are the new spaghetti code.”- Rich Hickey


Concurrency is difficult


You can’t stop the world



http://www.infoq.com/presentations/Value-Values








Concurrency is difficult

Persistent data structures

Programming with values

Immutable by default

Syntax for state:

Refs (STM), Agents, Atoms, Dynamic Vars

We’ll a bit about state later.


Enough chit chat.


Let’s get started

there are a few options

Emacs, Leiningen, nrepl

Emacs Live

LightTable


Leiningen

Clojure automation...https://github.com/technomancy/leiningen

1) Download the script:

https://raw.github.com/technomancy/leiningen/stable/bin/lein

2) Place it on your $PATH. (I like to use ~/bin)

3) Set it to be executable. (chmod 755 ~/bin/lein)

Start a new project:$ lein new <project name>$ lein repl


https://github.com/technomancy/leiningen

https://github.com/technomancy/leiningen



Emacs

Get version >= 24.X

Pick one (or more):

1) http://emacsformacosx.com

2) $ brew install emacs

3) https://github.com/overtone/emacs-live


Emacs https://gist.github.com/mudphone/4698169= install lein 2- Do this: https://github.com/technomancy/leiningen- download lein script, it will boot strap itself- install on path, rename to lein, chmod 755- run lein --version Leiningen 2.0.0 on Java 1.6.0_37 Java HotSpot(TM) 64-Bit Server VM = Emacs >= 24- Download latest version: http://emacsformacosx.com, if you want the GUI version- Or, for CLI, use homebrew- Or, do both = Emacs Starter Kit- look at my init.el- install latest: https://github.com/technomancy/emacs-starter-kit- install clojure-mode package-install <ret> clojure-mode <ret>- install nrepl" package-install <ret> nrepl <ret> = nrepl (already installed)- docs here: https://github.com/kingtim/nrepl.el- at a minimum, check out the keybindings = nrepl auto-complete- https://github.com/purcell/ac-nrepl (popup docs keybinding didn't work for me, so I'm not using it right now) = REFS:- this isn't required reading, but it works: http://www.kedrovsky.com/blog/clojure-emacs-nrepl-and-leiningen


https://gist.github.com/mudphone/4698169

https://gist.github.com/mudphone/4698169

Emacs

nREPL

M-x nrepl-jack-in

C-c M-n (to switch repl to this ns)

C-x C-c (eval buffer in repl)

M-C-x (eval form under point in repl)

C-c C-z (switch to repl buffer)


Clojure Basics


Getting Started

Symbols

Vars

Namespaces

use == require + refer

Help w/ doc, find-doc, source


Forms

Prefix notation

false and nil evaluate to false

maps are functions of keys, and keys are functions of maps

defrecord


defrecord

user> (defrecord Person [fname lname age favorites])user.Personuser> (defrecord Favorites [movie band])user.Favoritesuser> (def me (Person. "Kyle" "Oba" 37 (Favorites. "Lost in Translation" "Pantera")))#'user/meuser> (:fname me)"Kyle"

user> (-> me :favorites :movie)"Lost in Translation"

user> (assoc me :fname "That guy")#user.Person{:fname "That guy", :lname "Oba", :age 37, :favorites #user.Favorites{:movie "Lost in Translation", :band "Pantera"}}

user> (update-in me [:favorites :band] #(str "ZZ" % "ZZ"))#user.Person{:fname "Kyle", :lname "Oba", :age 37, :favorites #user.Favorites{:movie "Lost in Translation", :band "ZZPanteraZZ"}}


State http://clojure.org/state


http://clojure.org/vars

http://clojure.org/atoms

http://clojure.org/agents

http://clojure.org/refs


http://clojure.org/state

http://clojure.org/state











Imperative programming

single-threaded premise

world is stopped

requires mutexes and locks

difficult to get right / extremely complicated


Identity and Value

identity

value

name

Kyle

fav foods

{cheese donutsbacon}

today

March18th 2013


Typical OO

has imperative programming baked into it

identities are conflated with values

not necessarily, but usually, due to the language


Clojure’s approach

separates state from identity

move away from state as “the content of this memory block”

toward “the value currently associated with this identity”

identity is in different states at different times

but, the state at a point in time never changes value


Clojure’s approach

vars - root binding, refers to mutable storage location

vars w/ dynamic binding - per-thread binding

atoms

agents, asynchronous change via a function and values

refs, coordinate change with STM: software transactional memory


Actor Model (not Clojure)

distributed

more complex

see Erlang


Working with State

atoms

refs

dynamic binding

acting at a distance / aspect oriented programming

loss of purity

memoize example


Working with State


vars

user> (def x 1)#'user/x

user> x1

user> (def y 1)#'user/y

user> (+ x y)2

allow reference to mutable storage locations


dynamic binding

user> (def ^:dynamic x 1)#'user/x

user> (def ^:dynamic y 1)#'user/y

user> (+ x y)2

user> (binding [x 2 y 3] (+ x y))5

user> (+ x y)2


Changing State async synchronous

coordinated

independent atom

ref

agent


atoms

user> (def z (atom 5))#'user/z

user> z#<Atom@f2882ad: 5>

user> @z5

user> (swap! z inc)6

user> @z6

user> (swap! z (constantly 10))10

user> @z10

shared, synchronous, independent state


agents independent, asynchronous change

user> (def a (agent 1))#'user/a

user> a#<Agent@474d75ae: 1>

user> (send a inc)#<Agent@474d75ae: 2>

user> a#<Agent@474d75ae: 2>

user> @a2

user> (send a #(do (Thread/sleep 5000) (+ % 1)))#<Agent@474d75ae: 2>

user> @a2

user> @a3


refs (transactional references)shared use of mutable storage via STM

user> (def r (ref [1 2 3]))#'user/r

user> r#<Ref@369ca84f: [1 2 3]>

user> @r[1 2 3]

(dosync (alter r #(conj % 4)))[1 2 3 4]

user> @r[1 2 3 4]

user> (dosync (alter r (partial cons 0)))(0 1 2 3 4)

user> @r(0 1 2 3 4)


Java Interop


Working with Java

Calling Java

Java interop

Java collections


Java: Examples

user> (System/getProperty "java.vm.version")"20.14-b01-447"

user> (.toUpperCase "fred")"FRED"

user> (.getName String)"java.lang.String"

user> Math/PI3.141592653589793


Java: import and .

user> (import '[java.util Random])java.util.Random

user> (def r (Random.))#'user/r

user> (.nextInt r)458809484

user> (.nextInt r 100)42


Java: doto

user> (doto (new java.util.HashMap) (.put "a" 1) (.put "b" 2))#<HashMap {b=2, a=1}>


Java: set!

user> (def p (java.awt.Point.))#'user/p

user> (.x p)0

user> (set! (. p x) 5)5

user> p#<Point java.awt.Point[x=5,y=0]>


Macros


What’s a Macro?

#!/usr/bin/env ruby -wsay_hello = "puts \"hello\""

ruby_cmd = (0..9).map do |n| say_helloend

puts "ruby -e '#{ruby_cmd.join(";")}'"

$ ruby ruby_macro.rb | shhellohellohellohellohellohellohellohellohellohello

What if we could do this, while staying in the language?


Ruby-like “unless” implementation as a function...

This won’t work, because arguments are evaluated.

(defn unless [expr form] (if expr nil form))

user> (unless (= 1 1) (println "hi"))hinil


Arguments are evaluated first

(defn unless [expr form] (println "Doing unless...") (if expr nil form))

user> (unless (= 1 1) (println "hi"))hiDoing unless...nil


What we want

(unless expr form) -> (if expr nil form)


What we want

(defmacro unless [expr form] (list 'if expr nil form))

user> (unless true (println "yep"))nil

user> (unless false (println "yep"))yepnil


macroexpand-1

user> (macroexpand-1 '(when-not true (println "hi")))(if true nil (do (println "hi")))

user> (source when-not)(defmacro when-not "Evaluates test. If logical false, evaluates body in an implicit do." {:added "1.0"} [test & body] (list 'if test nil (cons 'do body)))nil


WAT

reader

compile

macros

text

data structures

bytecode

macrosevaluation


macroexpand

user> (.. System (getProperties) (get "os.name"))"Mac OS X"

user> (macroexpand-1 '(.. System (getProperties) (get "os.name")))(.. (. System (getProperties)) (get "os.name"))

user> (macroexpand '(.. System (getProperties) (get "os.name")))(. (. System (getProperties)) (get "os.name"))


Java Interop Bonus

user> (source ..)(defmacro .. "form => fieldName-symbol or (instanceMethodName-symbol args*)

Expands into a member access (.) of the first member on the first argument, followed by the next member on the result, etc. For instance:

(.. System (getProperties) (get \"os.name\"))

expands to:

(. (. System (getProperties)) (get \"os.name\"))

but is easier to write, read, and understand." {:added "1.0"} ([x form] `(. ~x ~form)) ([x form & more] `(.. (. ~x ~form) ~@more)))nil


One more macro...

user> (source and)(defmacro and "Evaluates exprs one at a time, from left to right. If a form returns logical false (nil or false), and returns that value and doesn't evaluate any of the other expressions, otherwise it returns the value of the last expr. (and) returns true." {:added "1.0"} ([] true) ([x] x) ([x & next] `(let [and# ~x] (if and# (and ~@next) and#))))nil


“Webby Stuff”


Areas of Interest:

ClojureScript to any old websitehttp://blip.tv/clojure/rich-hickey-unveils-clojurescript-5399498

ClojureScript + Three.js, to get at the WebGL bits

ClojureScript embedded in game systems

ClojureScript CLI

Pedestal: http://pedestal.io/documentation/hello-world-service/

It runs on Node.js.


http://blip.tv/clojure/rich-hickey-unveils-clojurescript-5399498

http://blip.tv/clojure/rich-hickey-unveils-clojurescript-5399498

http://pedestal.io/documentation/hello-world-service/


ClojureScript$ lein cljsbuild onceCompiling ClojureScript.Compiling "resources/public/hello.js" from "src/cljs"...Successfully compiled "resources/public/hello.js" in 8.542318 seconds.

$ tree.├── README.md├── doc│ └── intro.md├── docroot│ └── index.html├── project.clj├── resources│ └── public│ ├── hello.js│ └── index.html├── src│ ├── clj│ │ └── hello_world│ │ └── core.clj│ └── cljs│ └── hello.cljs└── test └── hello_world └── core_test.clj

10 directories, 9 files


Pedestal$ tree.├── README.md├── config│ └── logback.xml├── dev│ ├── dev.clj│ └── user.clj├── logs│ └── helloworld-2013-03-18.0.log├── project.clj├── src│ └── helloworld│ ├── server.clj│ └── service.clj├── target│ ├── classes│ └── stale│ └── extract-native.dependencies└── test └── helloworld └── service_test.clj

10 directories, 10 files

$ lein replnREPL server started on port 63132...helloworld.server=> (use 'dev)nilhelloworld.server=> (start)nilhelloworld.server=> (stop)nilhelloworld.server=> Bye for now!





Pedestalhttp://pedestal.io/documentation/application-introduction/

(defn count-model [old-state message] (condp = (msg/type message) msg/init (:value message) :inc (inc old-state)))

(defmulti render (fn [& args] (first args)))

(defmethod render :default [_] nil)

(defmethod render :value [_ _ old-value new-value] (dom/destroy-children! (dom/by-id "content")) (dom/append! (dom/by-id "content") (str "<h1>" new-value " Hello Worlds</h1>")))

(defn render-fn [deltas input-queue] (doseq [d deltas] (apply render d)))

(def count-app {:models {:count {:init 0 :fn count-model}}})

(defn receive-input [input-queue] (p/put-message input-queue {msg/topic :count msg/type :inc}) (.setTimeout js/window #(receive-input input-queue) 3000))

(defn ^:export main [] (let [app (app/build count-app)] (render/consume-app-model app render-fn) (receive-input (:input app)) (app/begin app)))

(ns hello-world(:require [io.pedestal.app.protocols :as p] [io.pedestal.app :as app] [io.pedestal.app.messages :as msg] [io.pedestal.app.render :as render] [domina :as dom]))




Pedestalhttp://pedestal.io/documentation/application-introduction/

(ns hello-world (:require [io.pedestal.app.protocols :as p] [io.pedestal.app :as app] [io.pedestal.app.messages :as msg] [io.pedestal.app.render :as render] [io.pedestal.app.render.push :as push] [domina :as dom]))

(defn count-model [old-state message] (condp = (msg/type message) msg/init (:value message) :inc (inc old-state)))

(defn render-value [renderer [_ _ old-value new-value] input-queue] (dom/destroy-children! (dom/by-id "content")) (dom/append! (dom/by-id "content") (str "<h1>" new-value " Hello Worlds</h1>")))

(def count-app {:models {:count {:init 0 :fn count-model}}})

(defn receive-input [input-queue] (p/put-message input-queue {msg/topic :count msg/type :inc}) (.setTimeout js/window #(receive-input input-queue) 3000))

(defn ^:export main [] (let [app (app/build count-app) render-fn (push/renderer "content" [[:value [:*] render-value]])] (render/consume-app-model app render-fn) (receive-input (:input app)) (app/begin app)))




Testing


(ns oudl.core-test (:use clojure.test oudl.core))

(deftest a-test (testing "FIXME, I fail." (is (= 0 1))))

user> (require '[clojure.test :as test])nil

user> (test/run-all-tests #"oudl.*-test")

Testing oudl.core-test

FAIL in (a-test) (core_test.clj:7)FIXME, I fail.expected: (= 0 1) actual: (not (= 0 1))

Ran 1 tests containing 1 assertions.1 failures, 0 errors.{:type :summary, :pass 0, :test 1, :error 0, :fail 1}

Free!


(require ‘[clojure.test :as test])

user> (doc test/run-all-tests)-------------------------clojure.test/run-all-tests([] [re]) Runs all tests in all namespaces; prints results. Optional argument is a regular expression; only namespaces with names matching the regular expression (with re-matches) will be tested.nil

user> (doc test/run-tests)-------------------------clojure.test/run-tests([] [& namespaces]) Runs all tests in the given namespaces; prints results. Defaults to current namespace if none given. Returns a map summarizing test results.nil


Things I Like


Some things

Clojure + Processing = Quil

Clojure + Kinect/OpenNI = Bifocals

LightTable


Clojure basics

Documents

Transcript of Clojure basics