Your SlideShare is downloading. ×
0
GGeettttiinngg ssttaarrtteedd wwiitthh 
((CClloojjuurree)) 
- or how I learned to stop worrying 
and love the (function)
Its a strange kind of love... 
 Clojure is very different 
 Part of your brain may rebel !! 
 Homo-Iconic 
 List based...
What is Clojure 
 Functional programming on the JVM 
 A better Lisp ?
Why get functional ? 
 Clock speeds stopped getting faster around 
2005 
 Cant get around the speed of silicon switches ...
You may end up working 
here...
Why a better Lisp ? 
 Clojure is easier to understand 
 Nicer libraries 
 Great interoperability with Java 
platform 
...
Classic or Re-Imagined 
 Lisp  Clojure
Why create Clojure 
 Concurrency in Java / OO is challenging 
 Mutable state-full paradigm 
 Fast enough persistent dat...
Why use Clojure 
 Its a pure functional programming language 
 You can use existing Java code and platform 
 Simple syn...
The downside of Clojure 
( x )
The downside of Clojure (2) 
( ( x ) )
The downside of Clojure (3) 
( ( ( x ) ) )
The downside of Clojure (4) 
( ( ( ( x ) ) ) )
The downside of Clojure (...) 
( ( ( ( ( x ) ) ) ) )
Tool support 
 Emacs 
 clojure-mode, clojure-test, 
paredit-mode 
 Netbeans 
 enclojure 
 IntelliJ 
 La Clojure 
 E...
Lets look at Clojure code
We're not in Kansas any 
more... 
 Java 
package … ; 
class …; 
member variables; 
access retType methodName (param, para...
Its just a tree...
… a tree structure 
 Functions are data 
 Data structures are functions !!
Download 
 clojure.org 
 Or via buld tool 
 Maven 
 Leiningen 
 Cake 
 Java 
 At least version 5 
 Version 6 bette...
All hail the REPL 
 An interactive shell for clojure 
 Using Leiningen (Line – ing – en) 
https://github.com/technomancy...
Leiningen Clojure project 
lein new 
lein deps 
lein repl 
lein swank 
 Create a new clojure project 
 Download clojure ...
Leiningen project file 
(defproject my-jax-london-project "1.0.0-SNAPSHOT" 
:description "A meaningful description" 
:depe...
Loading code into the REPL 
(load-file "temp.clj") 
 Stuff too big to type 
 use an absolute path or a path relative to ...
Simplest possible examples 
(* 2 2) 
(+ 1 2 3) 
( 24 4 3 2) 
( 2 4) 
( 2.0 4) 
(+ (* 4 5) 22) 
(+ 4 (* 3 2) 7) 
(+ 3 (* 2 ...
Calling Java... ooooo!! 
(javax.swing.JOptionPane/ 
showMessageDialog nil "Hello World" )
Ratio 
 Basic data type 
 Allow delaying computation 
 Avoid loss of precision 
(/ 2 4) 
(/ 2.0 4) 
(/ 1 3) 
(/ 1.0 3) ...
Simple function example 
(defn hello-world [name] (println(str "Hello " 
name))) 
(hello-world "jr0cket")
What class is that... 
(class (str "Jr0cket")) 
java.lang.String 
(class (defn hello-world [name] (str "Hello cruel 
world...
str 
(str h e l l o)  Concatenate strings 
together 
 Can represent a 
character using
Booleans / Expressions 
(= 1 1.0) 
(= 1 2) 
(< 1 2) 
 True is a symbol, but 
also 
user=> (class true) 
java.lang.Boolean...
More examples 
(last [1 1 2 3 5 8]) 
(defn penultimate [x] 
(last (butlast x)) ) 
(penultimate [1 2 3 4 5]) 
 (doc last) ...
And more... 
(nth [1 1 2 3 5 8] 2) 
(count [1 1 2 3 5 8]) 
(reverse [1 1 2 3 5 8]) 
(defn palindrome? [x] 
(= x (reverse x...
Even more 
(flatten [[1 1] 2 [3 [5 8]]]) 
(compress "aaaabccaadeeee") 
(encode "aaaabccaadeeee") 
(replicate 10 "a")
Where to find out more... 
http://clojure.org/cheatsheet 
http://clojure.github.com/cloj 
ure/clojure.core-api.html
Your own functions 
 Define your own algorithms 
(defn square [x] (* x x))
Anonymous functions 
 (fn ) (# ) 
(def sqr #(* % %))
Overloading functions 
(defn make 
([ ] ; the make function that takes no arguments 
(struct vector 0 0)) 
([x y] ; ... ta...
Pure functions – no side effects 
 Clojure functions are pure 
 they have no side effects 
 Unless you define them as s...
Clojure data structures 
 ( Lists ) - Ordered collection of elements 
 (list 1 3 5) '(8 13 21) 
 { map } 
 
 [ Vector...
List operations 
(first 1 2 3) 
 The head of the list 
(last 7 8 9) 
 The last element of the list 
(rest 1 2 3 4 5) 
 ...
More data structures... 
(defstruct date :day :month :year) 
(struct date) 
 as we did not specify any parameters, we jus...
maps 
 { :a 1 :b 2} 
 user=> { :a 1 :b 2} 
 {:a 1, :b 2} 
 user=> { :a 1 :b } 
 java.lang.ArrayIndexOutOfB 
oundsExce...
Vectors 
 [:neo :morpheus :trinity :smith] 
 [:matrix-characters [:neo :morpheus :trinity 
:smith]] 
 (first [:neo :mor...
Your own data structures 
 Special forms 
(def johnny {:first-name "John", :last-name 
"Stevenson"}) 
(defstruct person :...
Memory use 
 Once all references to an immutable structure 
disappears it can be garbage collected. 
 Loops that create ...
macros 
 Define extensions to the language 
 Clojure only has 7 primitive functions 
 Everything else in the language i...
Special forms 
 Recognized by the Clojure compiler and not 
implemented in Clojure source code. 
 A relatively small num...
if 
user=> (doc if) 
------------------------- 
if 
Special Form 
Please see http://clojure.org/special_forms#if 
nil
Sequences 
 Sequences are logical views of collections 
 Logical lists 
 Java collections, Clojure-specific collections...
Working with Sequences 
 first 
 rest 
 cons
Software Transactional 
Memory 
 Works like transactional databases 
 Provides safe, concurrent access to memory 
 Agen...
Sharing mutable data 
 Use mutable references to immutable data 
 Reference Types 
 synchronous access to multiple piec...
Name-spaces 
 Define a namespace 
(ns name-space-name) 
 Include namespace code 
(use 'names-space-name) 
 Like a packa...
Clojure Libraries 
(use 'clojure.contrib.str-utils) 
' 
 Dont treat the next thing as a function 
 Open source libraries...
Recursive functions 
 Functions that call 
themselves 
 Fractal coding 
 Tail recursion 
 Avoids blowing the 
heap 
 ...
Tail recursion 
(defn factorial [x] 
(if (= x 0) 
1 
(* x (factorial (- x 1)) 
))) 
 Dont blow your stack 
!!
TDD with Clojure is nice 
 Clojure test 
(deftest test-name 
(is (= value (function params))) )
Simple test 
(ns simple-test 
(:use clojure.test) 
(:use simple)) 
(deftest simple-test 
(is (= (hello) "Hello world!")) 
...
Working with Java 
 Java Classes 
 fullstop after class name 
 (JFrame. ) 
 (Math/cos 3) ; static method call 
 Java ...
Importing 
(ns drawing-demo 
(:import [javax.swing JPanel JFrame] 
[java.awt Dimension]))
Working with Java (2) 
 Clojure gives you clean, simple, direct access 
to Java 
 call any Java API directly 
 (System/...
Calling Clojure from Java 
 Export the clojure to a .jar 
 Add the jar to the classpath 
 Import the library in your co...
Errors are inevitable 
 In the REPL 
(printStackTrace *e) 
 *e holds the last exception raised 
 Clojure exceptions are...
Managing State in Immutable 
world 
 Mutable data structures to share between 
threads (Software Transactional Memory) 
...
Mutable functions 
 Swap! 
 
 Name functions that have side effects with an 
exclamation mark 
 Naming convention
Deployment 
 lein jar 
 lein uberjar
Documentation 
(doc function-name) 
(javadoc class-name) 
(defn function-name 
“A meaningful 
description of the 
function...
Example documentation 
(doc str) 
Use doc to print the documentation for str: 
user=> (doc str) 
-------------------------...
find-doc 
(find-doc “reduce”) 
user=> (find-doc "reduce" ) 
------------------------- 
clojure/areduce 
([a idx ret init e...
Autodoc 
 Generate a website for your API's 
 http://tomfaulhaber.github.com/auto 
doc/ 
 Add dependency to your build ...
Where next 
 Coding dojo – London / start your own 
 www.londonjavacommunity.co.uk 
 Books – Programming Clojure (Pragm...
Credits 
No parentheses 
were harmed in the 
making of this 
presentation....
TThhaannkk yyoouu 
 HHaavvee ffuunn 
lleeaarrnniinngg !!!! 
JJoohhnn@@jjrr00cckkeett..ccoomm 
@@jjrr00cckkeett 
jjoohhnn....
Getting started with Clojure
Upcoming SlideShare
Loading in...5
×

Getting started with Clojure

373

Published on

A simple introduction to the Clojure programming language. A talk given at the Spring 2011 edition of the JAX London conference.

Published in: Technology
0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
373
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
12
Comments
0
Likes
2
Embeds 0
No embeds

No notes for slide
  • Clojure has a programmatic macro system which allows the compiler to be extended by user code
    You can add your own language features with macros. Clojure itself is built out of macros such as defstruct:
    (defstruct person :first-name :last-name)
    If you need different semantics, write your own macro. If you want a variant of structs with strong typing and configurable null-checking for all fields, you can create your own defrecord macro, to be used like this:
    (defrecord
    person [String :first-name String :last-name]
    :allow-nulls false)
    This ability to reprogram the language from within the language is the unique advantage of Lisp. You will see facets of this idea described in various ways:
    Lisp is homoiconic - Lisp code is just Lisp data. This makes it easy for programs to write other programs.
    The whole language is there, all the time. Paul Graham’s essay “Revenge of the Nerds” explains why this is so powerful. http://www.paulgraham.com/icad.html
    Lisp syntax also eliminates rules for operator precedence and associativity, with fully parenthesized expressions, there is no possible ambiguity
  • Hickey&amp;apos;s primary interest was concurrency — he wanted the ability to write multi-threaded applications, but increasingly found the mutable, stateful paradigm of object oriented programming to be part of the problem
    The idea of a functional Lisp integrated with a commercially accepted host platform just seemed like chocolate and peanut butter. Coming up with persistent data structures that were fast enough was the tipping point for my considering it viable.
    functions as first-class objects, meaning that functions can be placed into data structures, passed as arguments to other functions, evaluated in comparisons, even returned as the return value of another function. Moreover, functions do not have &amp;quot;side effects&amp;quot; — the ability to modify program state or data. This paradigm focuses on computation in the mathematical sense, rather than procedural algorithms, and is a completely different approach to programming.
    Clojure does provide persistent data structures For application developers, the most significant distinction is that Clojure defaults to making all data structures immutable
    developers must use one of four special mutable structures that are explicitly designed to be shared between threads: refs, vars, atoms, and agents. Clojure uses software transactional memory (STM) to coordinate changing these mutable structures while keeping them in a consistent state, much like a transactional database. This model makes it considerably simpler to write thread-safe code than it is in object oriented languages. No locks are required, therefore there are no deadlocks or race conditions.
  • Throw away your knowledge about OO and try something different
  • The downside of Lisp’s simple, regular syntax, at least for beginners, is Lisp’s fixation on parentheses and on lists as the core data type. Clojure offers an interesting combination of features that makes Lisp more approachable for non-Lispers.
  • The downside of Lisp’s simple, regular syntax, at least for beginners, is Lisp’s fixation on parentheses and on lists as the core data type. Clojure offers an interesting combination of features that makes Lisp more approachable for non-Lispers.
  • The downside of Lisp’s simple, regular syntax, at least for beginners, is Lisp’s fixation on parentheses and on lists as the core data type. Clojure offers an interesting combination of features that makes Lisp more approachable for non-Lispers.
  • The downside of Lisp’s simple, regular syntax, at least for beginners, is Lisp’s fixation on parentheses and on lists as the core data type. Clojure offers an interesting combination of features that makes Lisp more approachable for non-Lispers.
  • The downside of Lisp’s simple, regular syntax, at least for beginners, is Lisp’s fixation on parentheses and on lists as the core data type. Clojure offers an interesting combination of features that makes Lisp more approachable for non-Lispers.
  • Note: prefix notation
  • What are the 7 primitive functions?
  • When you require a library named clojure.contrib.str-utils, Clojure looks for
    a file named clojure/contrib/str-utils.clj on the CLASSPATH
    To avoid having to use the namespace for your library, you have to use refer, like so - (refer &amp;apos;examples/introduction)
    The use function does both require refer, like so –
    (use &amp;apos;examples.introduction)
    o force a library to reload:
    (use :reload-all &amp;apos;examples.introduction)
    The :reload-all flag is useful if you are making changes and want to see results without restarting the REPL.
  • This is barfing because the evaluator has to keep around state for each call due to the expression (* x (factorial (- x 1))) . We need to make this function tail recursive.
    recur can be thought of as the Clojure operator for looping. Think of it like a function call for the nearest enclosing let or function definition supplied with new variables. Naively we can switch over to using this by doing:
    user&amp;gt; (defn factorial2 [x]
    (if (= x 0)
    1
    (* x (recur (- x 1)))))
    But this is a compile-time error (which in itself is pretty neat!).
    java.lang.UnsupportedOperationException: Can only recur from tail position (NO_SOURCE_FILE:4)
    An accumulator parameter is an extra parameter to a function that&amp;apos;s used to gather intermediate parts of the calculation. If we do this, we can make sure that the recur call is in the tail position. Using an anonymous function we get:
    (defn factorial3 [x]
    ((fn [x y]
    (if (= x 0)
    y
    (recur (- x 1) (* x y)))) x 1))
    Now when recur is used, it doesn&amp;apos;t need to keep any of the previous stack frame around. This means we can finally calculate factorial 1000000, which begins with 282 and ends with lots of zeros!
  • Use doc to print the documentation for str:
    user=&amp;gt; (doc str)
    -------------------------
    clojure.core/str
    ([] [x] [x &amp; ys])
    With no args, returns the empty string. With one arg x, returns
    x.toString().
    (str nil) returns the empty string.
    With more than one arg, returns the concatenation of the str values of the args.
    The first line of doc’s output contains the fully qualified name of the
    function.
    The next line contains the possible argument lists, generated directly from the code. (Some common argument names and their uses are explained in the sidebar on the following page.)
    Finally, the remaining lines contain the function’s doc-string, if the function definition included one.
  • Transcript of "Getting started with Clojure"

    1. 1. GGeettttiinngg ssttaarrtteedd wwiitthh ((CClloojjuurree)) - or how I learned to stop worrying and love the (function)
    2. 2. Its a strange kind of love...  Clojure is very different  Part of your brain may rebel !!  Homo-Iconic  List based  Immutable state  Dynamically typed  Tiny syntax  Infinitely extensible with Macros
    3. 3. What is Clojure  Functional programming on the JVM  A better Lisp ?
    4. 4. Why get functional ?  Clock speeds stopped getting faster around 2005  Cant get around the speed of silicon switches  Moores law still in effect  More cores added every 18 months  Laptops with 128 cores by 2020 ??  Concurrency at the hardware level  Not just multi-threading
    5. 5. You may end up working here...
    6. 6. Why a better Lisp ?  Clojure is easier to understand  Nicer libraries  Great interoperability with Java platform  Closer to pure functional language  Explicitly define mutable state  STM – transactional memory
    7. 7. Classic or Re-Imagined  Lisp  Clojure
    8. 8. Why create Clojure  Concurrency in Java / OO is challenging  Mutable state-full paradigm  Fast enough persistent data structures made it viable  Functions as first class  Functions part of data structure  Functions do not have “side effects”  Focus on computation (maths) rather than procedural algorithms
    9. 9. Why use Clojure  Its a pure functional programming language  You can use existing Java code and platform  Simple syntax  It gets you thinking differently !!!  An excuse to learn Emacs properly ??
    10. 10. The downside of Clojure ( x )
    11. 11. The downside of Clojure (2) ( ( x ) )
    12. 12. The downside of Clojure (3) ( ( ( x ) ) )
    13. 13. The downside of Clojure (4) ( ( ( ( x ) ) ) )
    14. 14. The downside of Clojure (...) ( ( ( ( ( x ) ) ) ) )
    15. 15. Tool support  Emacs  clojure-mode, clojure-test, paredit-mode  Netbeans  enclojure  IntelliJ  La Clojure  Eclipse  Counterclockwise plugin  Build tools  Leiningen  Emacs + Slime  Cake  Maven
    16. 16. Lets look at Clojure code
    17. 17. We're not in Kansas any more...  Java package … ; class …; member variables; access retType methodName (param, param) {…}  Clojure (ns name-space-name) (defstruct my-data-struture :label-name) (functionName param (fn param)) ; param's can be functions too !!
    18. 18. Its just a tree...
    19. 19. … a tree structure  Functions are data  Data structures are functions !!
    20. 20. Download  clojure.org  Or via buld tool  Maven  Leiningen  Cake  Java  At least version 5  Version 6 better performance and reporting
    21. 21. All hail the REPL  An interactive shell for clojure  Using Leiningen (Line – ing – en) https://github.com/technomancy/leiningen/ lein lein repl
    22. 22. Leiningen Clojure project lein new lein deps lein repl lein swank  Create a new clojure project  Download clojure  Start the interactive shell  Start repl server for emacs
    23. 23. Leiningen project file (defproject my-jax-london-project "1.0.0-SNAPSHOT" :description "A meaningful description" :dependencies [[org.clojure/clojure "1.2.1"] [org.clojure/clojure-contrib "1.2.0"]] :dev-dependencies [[swank-clojure "1.2.1"] [org.clojars.rayne/autodoc "0.8.0- SNAPSHOT"]] :autodoc { :name "London Clojure dojo", :page-title "Dojo API"} ;; Only re-fetch deps when they change in project.clj or when :library-path directory is empty. :checksum-deps true :license {:name "Eclipse Public License - v 1.0"
    24. 24. Loading code into the REPL (load-file "temp.clj")  Stuff too big to type  use an absolute path or a path relative to where you launched the REPL  Use Emacs or other IDE when you're ready
    25. 25. Simplest possible examples (* 2 2) (+ 1 2 3) ( 24 4 3 2) ( 2 4) ( 2.0 4) (+ (* 4 5) 22) (+ 4 (* 3 2) 7) (+ 3 (* 2 (- 7 2) 4) (/ 16 4))
    26. 26. Calling Java... ooooo!! (javax.swing.JOptionPane/ showMessageDialog nil "Hello World" )
    27. 27. Ratio  Basic data type  Allow delaying computation  Avoid loss of precision (/ 2 4) (/ 2.0 4) (/ 1 3) (/ 1.0 3) (class (/ 1 3)
    28. 28. Simple function example (defn hello-world [name] (println(str "Hello " name))) (hello-world "jr0cket")
    29. 29. What class is that... (class (str "Jr0cket")) java.lang.String (class (defn hello-world [name] (str "Hello cruel world"))) clojure.lang.Var
    30. 30. str (str h e l l o)  Concatenate strings together  Can represent a character using
    31. 31. Booleans / Expressions (= 1 1.0) (= 1 2) (< 1 2)  True is a symbol, but also user=> (class true) java.lang.Boolean (if 0 (println “True”)) (if nil (println “True”)) (if “” (println “True”))
    32. 32. More examples (last [1 1 2 3 5 8]) (defn penultimate [x] (last (butlast x)) ) (penultimate [1 2 3 4 5])  (doc last)  (doc butlast)
    33. 33. And more... (nth [1 1 2 3 5 8] 2) (count [1 1 2 3 5 8]) (reverse [1 1 2 3 5 8]) (defn palindrome? [x] (= x (reverse x)) )  Proposition – naming convention
    34. 34. Even more (flatten [[1 1] 2 [3 [5 8]]]) (compress "aaaabccaadeeee") (encode "aaaabccaadeeee") (replicate 10 "a")
    35. 35. Where to find out more... http://clojure.org/cheatsheet http://clojure.github.com/cloj ure/clojure.core-api.html
    36. 36. Your own functions  Define your own algorithms (defn square [x] (* x x))
    37. 37. Anonymous functions  (fn ) (# ) (def sqr #(* % %))
    38. 38. Overloading functions (defn make ([ ] ; the make function that takes no arguments (struct vector 0 0)) ([x y] ; ... takes x and y keywords as arguments (struct vector x y)) )
    39. 39. Pure functions – no side effects  Clojure functions are pure  they have no side effects  Unless you define them as such  Pure functions are easy to develop, test, and understand  Aim for pure functions where possible
    40. 40. Clojure data structures  ( Lists ) - Ordered collection of elements  (list 1 3 5) '(8 13 21)  { map }   [ Vectors ] - Optimised for random access  [:tom :dick :harry]  Lists are for code, Vectors for data  (nth [:tom :dick :jane :harry ] 2)
    41. 41. List operations (first 1 2 3)  The head of the list (last 7 8 9)  The last element of the list (rest 1 2 3 4 5)  Everything but the head (cons :new-list '(1 2 3 4 5))  New list, given head and tail
    42. 42. More data structures... (defstruct date :day :month :year) (struct date)  as we did not specify any parameters, we just get nil values  things in curly brackets are hash maps - the usual Java hashmaps
    43. 43. maps  { :a 1 :b 2}  user=> { :a 1 :b 2}  {:a 1, :b 2}  user=> { :a 1 :b }  java.lang.ArrayIndexOutOfB oundsException: 3  user=> { :a 1 :b 2}  {:a 1, :b 2}  user=> { :a 1 :b 3} ; this should make the repl complain in clojure 1.2, fine in 1.1  {:a 1, :b 3}  user=> {:a {:a 1}}  {:a {:a 1}}  user=> {{:a 1} :a}  {{:a 1} :a}  ; idiom - put :a on the left
    44. 44. Vectors  [:neo :morpheus :trinity :smith]  [:matrix-characters [:neo :morpheus :trinity :smith]]  (first [:neo :morpheus :trinity :smith])  (nth [:matrix :babylon5 :firefly :stargate] 2)  (concat [:neo] [:trinity])  (def my-vector  (vector? x)
    45. 45. Your own data structures  Special forms (def johnny {:first-name "John", :last-name "Stevenson"}) (defstruct person :first-name :last-name) (defrecord person [String :first-name String :last-name] :allow-nulls false)
    46. 46. Memory use  Once all references to an immutable structure disappears it can be garbage collected.  Loops that create intermittent structures are garbage collected every turn of the loop. ;;Memory : 0 (let [a (range 50000)]) ;; Memory: "big" while the let is "executing" ;;Memory : 0 -- no reference to a anymore !
    47. 47. macros  Define extensions to the language  Clojure only has 7 primitive functions  Everything else in the language is created with macros  Allows the language to be extended easily without changes to the compiler
    48. 48. Special forms  Recognized by the Clojure compiler and not implemented in Clojure source code.  A relatively small number of special forms  New ones cannot be implemented  catch, def, do, dot ('.'), finally, fn, if, let, loop, monitor-enter, monitor-exit, new, quote, recur, set!, throw, try and var
    49. 49. if user=> (doc if) ------------------------- if Special Form Please see http://clojure.org/special_forms#if nil
    50. 50. Sequences  Sequences are logical views of collections  Logical lists  Java collections, Clojure-specific collections, strings, streams, directory structures and XML trees.  New Clojure collections created efficiently  Creates a sort of branch (delta) in the data structure tree
    51. 51. Working with Sequences  first  rest  cons
    52. 52. Software Transactional Memory  Works like transactional databases  Provides safe, concurrent access to memory  Agents allow encapsulated access to mutable resources
    53. 53. Sharing mutable data  Use mutable references to immutable data  Reference Types  synchronous access to multiple pieces of shared data ("coordinated") by using STM  Atoms  synchronous access to a single piece of shared data.  Agents  asynchronous access to a single piece of shared data
    54. 54. Name-spaces  Define a namespace (ns name-space-name)  Include namespace code (use 'names-space-name)  Like a package statement in Java
    55. 55. Clojure Libraries (use 'clojure.contrib.str-utils) '  Dont treat the next thing as a function  Open source libraries - http://clojars.org/
    56. 56. Recursive functions  Functions that call themselves  Fractal coding  Tail recursion  Avoids blowing the heap  A trick as the JVM does not support tail recursion directly :-(
    57. 57. Tail recursion (defn factorial [x] (if (= x 0) 1 (* x (factorial (- x 1)) )))  Dont blow your stack !!
    58. 58. TDD with Clojure is nice  Clojure test (deftest test-name (is (= value (function params))) )
    59. 59. Simple test (ns simple-test (:use clojure.test) (:use simple)) (deftest simple-test (is (= (hello) "Hello world!")) (is (= (hello "test") "Hello test!")))
    60. 60. Working with Java  Java Classes  fullstop after class name  (JFrame. )  (Math/cos 3) ; static method call  Java methods  fullstop before method name  (.getContentPane frame) ;;method name first  (. frame getContentPane) ;;object first
    61. 61. Importing (ns drawing-demo (:import [javax.swing JPanel JFrame] [java.awt Dimension]))
    62. 62. Working with Java (2)  Clojure gives you clean, simple, direct access to Java  call any Java API directly  (System/getProperties)  -> {java.runtime.name=Java(TM) SE Runtime Environment
    63. 63. Calling Clojure from Java  Export the clojure to a .jar  Add the jar to the classpath  Import the library in your code  Call it like any other method
    64. 64. Errors are inevitable  In the REPL (printStackTrace *e)  *e holds the last exception raised  Clojure exceptions are Java exceptions
    65. 65. Managing State in Immutable world  Mutable data structures to share between threads (Software Transactional Memory)  refs, vars, atoms, agents  No locks required for thread safe code, no deadlocks or race conditions  Atomically apply changes
    66. 66. Mutable functions  Swap!   Name functions that have side effects with an exclamation mark  Naming convention
    67. 67. Deployment  lein jar  lein uberjar
    68. 68. Documentation (doc function-name) (javadoc class-name) (defn function-name “A meaningful description of the function” params )  Show fn description  Show javadoc in browser  Write documentation for your own functions
    69. 69. Example documentation (doc str) Use doc to print the documentation for str: user=> (doc str) ------------------------- clojure.core/str ([] [x] [x & ys]) With no args, returns the empty string. With one arg x, returns x.toString(). (str nil) returns the empty string. With more than one arg, returns the concatenation of the str values of the args.  Fully qualified namespace  Arguments  Details
    70. 70. find-doc (find-doc “reduce”) user=> (find-doc "reduce" ) ------------------------- clojure/areduce ([a idx ret init expr]) Macro ... details ... ------------------------- clojure/reduce ([f coll] [f val coll]) ... details ...  Search for functions you dont know  Keyword parameter
    71. 71. Autodoc  Generate a website for your API's  http://tomfaulhaber.github.com/auto doc/  Add dependency to your build file  http://clojars.org/org.clojars.rayne/autodoc  lein deps  lein autodoc
    72. 72. Where next  Coding dojo – London / start your own  www.londonjavacommunity.co.uk  Books – Programming Clojure (Pragmatic)  Website – clojure.org dev.clojure.org  Full Disclojure vimeo.com/channels/fulldisclojure  clojure.jr0cket.co.uk  99 problems in clojure
    73. 73. Credits No parentheses were harmed in the making of this presentation....
    74. 74. TThhaannkk yyoouu  HHaavvee ffuunn lleeaarrnniinngg !!!! JJoohhnn@@jjrr00cckkeett..ccoomm @@jjrr00cckkeett jjoohhnn..jjrr00cckkeett..ccoo..uukk cclloojjuurree..jjrr00cckkeett..ccoo..uukk
    1. A particular slide catching your eye?

      Clipping is a handy way to collect important slides you want to go back to later.

    ×