Your SlideShare is downloading. ×
0
Clojure



               A new Lisp

    with excellent concurrency support

        and tight Java integration



      ...
Why Lisp?



         Simple – easy to learn

    Expressive – say a lot with a little

    Flexible – becomes what you wa...
Why Clojure?


        Advantages of Lisp, plus...

    Works with your existing Java code

     Uses your favorite Java l...
What made Lisp different 
           (Paul Graham)

1) Conditionals                6) Programs composed 
2) Function type ...
Simple Data          Compound Data
h                      “house”
74                      [1 2 3 4]
true                  ...
Expressions
74
(+ 1 1)
(str “The date is ” (new Date))
(println (str “The date is ” (new Date)))
(def  x  7)
(< 7 8)
(if  ...
Evaluation and the REPL
java ­cp clojure.jar clojure.lang.Repl
Evaluate one expression at a time
Good for experimental pro...
Functions
    (def add­six
         (fn [x] (+ 6 x)))
    (def hello 
         (fn [name1 name2]
              (str “Hello...
Advantages of Functions
Break code into smaller pieces
Easier to understand
Tests more precisely identify errors
Re­use ra...
Higher­Order Functions
    Functions can be used as input to other functions.


    (map  add­six  [0  4  10])     =>     ...
Macros
    Tired of patterns like this?
         (def add­six (fn [x] (+ x 6)))
    The defn macro in the standard library...
Macros for Web Development
    (ns  hello   
         (:require  [compojure.http.servlet  :as  servlet])
         (:requir...
Using Java Libraries
    (.toUpperCase “fred”)        =>     “FRED”
    (.getName String)              =>     “java.lang.S...
Extending Classes and Interfaces
    button.addActionListener(
         new ActionListener() {
             public void ac...
Creating Java Libraries
Using Clojure to create Java classes, compiled to 
*.class files
Recent feature (December 2008) so...
How It Will Be Used
    package aotexample;
    public class TestMultipliers {
        public static void main(String[] ar...
Java Version
    package aotexample;
    import java.io.Serializable;
    public class JavaMultiplier implements Serializa...
Clojure Version
    (ns aotexample.ClojureMultiplier
        (:import (java.io Serializable))
        (:gen­class
        ...
Compilation
    java ­cp src:classes:lib/clojure.jar clojure.lang.Script 
      src/aotexample/compilemultiplier.clj
    j...
Transactional Memory
Place any shared state inside a ref
Change refs only within a transaction
Read refs with or without t...
Transaction Example
    (defn transfer [from to amount]
      (dosync
         (when (> (ensure from) amount)
            ...
Agents
Each agent has a state.
You can read the agent's state, or add a watcher 
that responds to state changes.
You can a...
How to Get Started
http://clojure.org/getting_started
http://groups.google.com/group/clojure
Programming Clojure (Pragmati...
Upcoming SlideShare
Loading in...5
×

Clojure - A new Lisp

1,744

Published on

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

No Downloads
Views
Total Views
1,744
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
27
Comments
0
Likes
2
Embeds 0
No embeds

No notes for slide

Transcript of "Clojure - A new Lisp"

  1. 1. Clojure A new Lisp with excellent concurrency support and tight Java integration    
  2. 2. Why Lisp? Simple – easy to learn Expressive – say a lot with a little Flexible – becomes what you want    
  3. 3. Why Clojure? Advantages of Lisp, plus... Works with your existing Java code Uses your favorite Java libraries Makes concurrency easy    
  4. 4. What made Lisp different  (Paul Graham) 1) Conditionals 6) Programs composed  2) Function type of expressions 3) Recursion 7) A symbol type 4) Variables as pointers 8) Code as data 5) Garbage collection 9) Reader, compiler,  and evaluator  available to program    
  5. 5. Simple Data          Compound Data h “house” 74 [1 2 3 4] true (true false) :first­name {:first­name “Eric” :last­ 7/8 name “Lavigne”} ­5.4 #{“house” “office”  “museum”} nil    
  6. 6. Expressions 74 (+ 1 1) (str “The date is ” (new Date)) (println (str “The date is ” (new Date))) (def  x  7) (< 7 8) (if  (< x 8)  “less than 8”  “at least 8”)    
  7. 7. Evaluation and the REPL java ­cp clojure.jar clojure.lang.Repl Evaluate one expression at a time Good for experimental programming (+ 1 1)                                 =>     2 (def x 6)                              =>     #'user/x (if (< x 10) “less” “more”)     =>     “less”    
  8. 8. Functions (def add­six      (fn [x] (+ 6 x))) (def hello       (fn [name1 name2]           (str “Hello “ name1 “ and “ name2 “.”))) (add­six 4)                 =>     10   (hello “Jack” “Jill”)     =>     “Hello Jack and Jill.”  
  9. 9. Advantages of Functions Break code into smaller pieces Easier to understand Tests more precisely identify errors Re­use rather than repeat Less code, easier to read and write Improvements can be made in one place    
  10. 10. Higher­Order Functions Functions can be used as input to other functions. (map  add­six  [0  4  10])     =>     (6  10  16) (def sum      (fn [x] (reduce + 0 x))) (def product      (fn [x] (reduce * 1 x)))    
  11. 11. Macros Tired of patterns like this?      (def add­six (fn [x] (+ x 6))) The defn macro in the standard library allows you  to write this:      (defn add­six [x] (+ x 6)) Patterns are a sign that it's time for a function or  macro.  Don't repeat yourself :­)    
  12. 12. Macros for Web Development (ns  hello         (:require  [compojure.http.servlet  :as  servlet])      (:require  [compojure.http.routes  :as  routes])      (:require  [compojure.server.jetty  :as  jetty])) (servlet/defservlet  hello­servlet      (routes/ANY  "/*"  "Hello.")) (jetty/defserver  hello­server      {:port  80}      "/*"  hello­servlet)     (jetty/start  hello­server)
  13. 13. Using Java Libraries (.toUpperCase “fred”)        =>     “FRED” (.getName String)              =>     “java.lang.String” (System/getProperty  “java.vm.version”)               =>     “1.6.0_07­b06­57” Math/PI                              =>     3.14159... (import 'org.joda.time.Duration) (new Duration  (.longValue 5000))               =>     #<Duration PT5S>    
  14. 14. Extending Classes and Interfaces button.addActionListener( new ActionListener() { public void actionPerformed(ActionEvent evt) { System.out.println("Button Pressed");  } } ); (.addActionListener button (proxy [ActionListener] [] (actionPerformed [evt]     (println "Button Pressed"))))
  15. 15. Creating Java Libraries Using Clojure to create Java classes, compiled to  *.class files Recent feature (December 2008) so expect  additional improvements soon    
  16. 16. How It Will Be Used package aotexample; public class TestMultipliers { public static void main(String[] args) { System.out.println("Result of Java version is "  + new JavaMultiplier(3).multiply(2)); System.out.println("Result of Clojure version is "  + new ClojureMultiplier(new Integer(3)).multiply(2)); } }    
  17. 17. Java Version package aotexample; import java.io.Serializable; public class JavaMultiplier implements Serializable { private Integer a; public JavaMultiplier(Integer a) { this.a = a; } public Integer multiply(Integer b) { return a * b; } }    
  18. 18. Clojure Version (ns aotexample.ClojureMultiplier (:import (java.io Serializable)) (:gen­class :implements [java.io.Serializable] :methods [[multiply [Integer] Integer]] :state a   :init init­multiplier :constructors { [Integer] [] })) (defn ­init­multiplier [a] [[] a]) (defn ­multiply [this b]   (* (.a this) b))  
  19. 19. Compilation java ­cp src:classes:lib/clojure.jar clojure.lang.Script  src/aotexample/compilemultiplier.clj javac ­cp src:classes:lib/clojure.jar ­d classes  ./src/aotexample/JavaMultiplier.java javac ­cp src:classes:lib/clojure.jar ­d classes  ./src/aotexample/TestMultipliers.java java ­cp src:classes:lib/clojure.jar aotexample.TestMultipliers src/aotexample/compilemultiplier.clj:   (compile 'aotexample.ClojureMultiplier)  
  20. 20. Transactional Memory Place any shared state inside a ref Change refs only within a transaction Read refs with or without transaction deref vs ensure Optimistic locking and automatic retrying Only effects of transaction should be altering refs  and returning value. Anything else could be  overdone due to automatic retrying.    
  21. 21. Transaction Example (defn transfer [from to amount] (dosync (when (> (ensure from) amount) (alter from (fn [x] (­ x amount))) (alter to (fn [x] (+ x amount)))))) (def account1 (ref 2000)) (def account2 (ref 1000)) (transfer account1 account2 1000)   (dosync [(ensure account1) (ensure account2)])  
  22. 22. Agents Each agent has a state. You can read the agent's state, or add a watcher  that responds to state changes. You can asynchronously send a function to the  agent that will change the state. You can add a validator function to block state  changes.    
  23. 23. How to Get Started http://clojure.org/getting_started http://groups.google.com/group/clojure Programming Clojure (Pragmatic Programmers) http://ericlavigne.wordpress.com Ask Questions    
  1. A particular slide catching your eye?

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

×