JavaOne 2013 - Clojure for Java Developers

for Java developers
Clojure
jan.kronquist@jayway.com
onsdag 25 september 13

About me

About me
1986 - Basic

About me
1990 - 68K assembly
1986 - Basic

About me
1990 - 68K assembly1986 - Basic
1995 - OOP

1997 - University
About me
1995 - OOP

1997 - University
About me
2005 - IoC,Aspects, Mixins
1995 - OOP

2008 - Functional 1997 - University
About me
1995 - OOP

2012 - Lisp & dynamic typing
2008 - Functional
1997 - University
About me
1995 - OOP

This talk is not
A comprehensive introduction to Clojure
About idiomatic Clojure
Another talk about functional programming

Killer apps

Killer apps
Prismatic

Killer apps
Prismatic
Datomic
Storm
ClojureScript

What is Clojure?
Created 2007 by Rich Hickey
Lisp
Runs on JVM, CLR & JavaScript
Design for concurrency

Clojure example
(defn divisible? [n d]
(== 0 (mod n d)))
(defn divides [n]
(partial divisible? n))
(declare primes)
(defn prime? [n]
(not (some (divides n) (take-while #(< % n) primes))))
(def primes (lazy-cat
[2 3 5]
(filter prime? (drop 7 (range)))))

Why Clojure?

Why Clojure?
Lisp - Code as data & Syntactic abstraction

Why Clojure?
Functional - Declarative, Immutable

Why Clojure?
Interactive development environment

Why Clojure?
Great eco-system - dynamic helps compatibility

Why Clojure?
Wrapper-free Java access

Why Clojure?
Wrapper-free Java access
Less complexity

Common complaints

Common complaints
Lisp looks weird

Common complaints
Dynamic typing is scary
Lisp looks weird

Common complaints
Lisp looks weird
Just a toy language

Common complaints
Lisp looks weird
Macros? Are you crazy?
Just a toy language

Lispness

Clojure Atomic Data Types
Arbitrary precision integers: 12345678987654
Doubles: 1.234
BigDecimals: 1.234M
Ratios: 22/7
Strings: "fred" , Characters: a b c
Symbols: fred ethel , Keywords: :fred :ethel
Booleans: true false , Null: - nil
Regex patterns #"a*b"
Rich Hickey - Clojure for Java Programmers - http://www.youtube.com/watch?v=P76Vbsk_3J0

JavaScript Data Structures
Arrays
[1, 2, 3] ["fred", "ethel", "lucy"]
Objects
{name: "Jan Kronquist", age: 37}

Clojure Data Structures
Vectors
[1, 2, 3] ["fred", "ethel", "lucy"]
Maps
{:name "Jan Kronquist", :age 37}
move colon

Vectors
[1 2 3] ["fred" "ethel" "lucy"]
Maps
{:name "Jan Kronquist" :age 37}
commas are whitespace!

Vectors - indexed access
[1 2 3] ["fred" "ethel" "lucy"]
Maps
{:name "Jan Kronquist" :age 37}
Lists - singly linked
(1 2 3 4 5) (fred ethel lucy) (list 1 2 3)
Sets
#{fred ethel lucy}

Demo in REPL
user=> "hello"
"hello"
user=> 5
5
user=> [1 2 3]
[1 2 3]
user=> qwe
java.lang.RuntimeException: Unable to resolve symbol: qwe
user=> (def qwe "hello world")
#'user/qwe
user=> qwe
"hello world"

"Hello world")
The strangeness of Lisp
println(

"Hello world")
The strangeness of Lisp
println(
(operator operand1 operand2 ...)
Determines how the list is evaluated

(= (.toString (+ 1 2)) "3")
Example evaluation
(= (.toString (+ 1 2)) "3")

(= (.toString (+ 1 2)) "3")
Example evaluation

(= (.toString (+ 1 2)) "3")
Example evaluation
(= (.toString 3) "3")

(= (.toString (+ 1 2)) "3")
Example evaluation
(= (.toString 3) "3")
(= "3" "3")

(= (.toString (+ 1 2)) "3")
Example evaluation
(= (.toString 3) "3")
(= "3" "3")
true

int i = 5; (def i 5) OR (let [i 5] ...)
if (x > 5) {
return y;
} else {
return z;
}
(if (> x 5)
y
z)
x * y * z (* x y z)
foo(x, y, z) (foo x y z)
object.method(x, y) (.method object x y)
public String sayHello(String x) {
return "Hello " + x;
}
(defn sayHello [x]
(str "Hello " x))

Java Quiz
public static void main(String[] args) {
int bang = 1;
do while (bang>=1)
System.out.print(" bang is "+ bang);
while (bang>1);
}

Working with Java classes
(defn display [text]
(let [frame (new JFrame "MyFrame")]
(.add frame (new JLabel text))
(.setSize frame 300 200)
(.setVisible frame true)))
static void display(String text) {
JFrame frame = new JFrame("MyFrame");
frame.add(new JLabel(text));
frame.setSize(300, 200);
frame.setVisible(true);
}

}
(display "Hello World")

}
a pattern!

with (frame) {
.add(new JLabel(text));
.setSize(300, 200);
.setVisible(true);
}
}

(doto frame
(.add (new JLabel text))
(.setSize 300 200)
(.setVisible true))))
with (frame) {
.add(new JLabel(text));
.setSize(300, 200);
.setVisible(true);
}
}

(doto (new JFrame "MyFrame")
(.setSize 300 200)
(.setVisible true)))
}

(doto (new JFrame "MyFrame")
(.setSize 300 200)
(.setVisible true)))
}
Ok, nice,
but in practice you would
never want something like this?

static void write(String fileName, String text) throws IOException {
try (Writer writer = new FileWriter(fileName)) {
writer.write(text);
}
}
Trust me, you want macros

static void write(String fileName, String text) throws IOException {
try (Writer writer = new FileWriter(fileName)) {
writer.write(text);
}
}
Trust me, you want macros
(defn write [fileName text]
(with-open [writer (new FileWriter fileName)]
(.write writer text)))

Structure in
Modules - package
Abstraction - interface
Implementation - class

Structure in
Modules - package
Abstraction - interface
Implementation - class
Problems
mutable state?
static methods?
inheritance?
constants?

Structure in
Modules
namespace - ﬁrst-class, dynamic, import, aliasing
Abstraction
defprotocol - can be added later
Implementation
defrecord - immutable, equals, hashcode, etc
deftype - may mutate, only user functionilty
reify - singleton
gen-class & proxy - for Java interop

Records - creating
(ns my.namespace)
(defrecord Person [firstName lastName])
(new Person "Jan" "Kronquist")

Records - creating
; #my.namespace.Person{:firstName "Jan", :lastName "Kronquist"}
(ns my.namespace)

Records - field access
(ns my.namespace)
(def person (new Person "Jan" "Kronquist"))
(.firstName person)

Records - field access
(ns my.namespace)
(.firstName person)
; "Jan"

Records - named parameters
(ns my.namespace)
(.firstName person)
; "Jan"
(map->Person {:lastName "Kronquist" :firstName "Jan"})

Records and protocols
(defprotocol Nameable
(getName [this]))

(getName [this]))
(defrecord Person [firstName lastName]
Nameable
(getName [this] (str firstName " " lastName)))
(getName (new Person "Jan" "Kronquist"))
; "Jan Kronquist"
Person class implements
Nameable interface

(getName [this]))
(extend-protocol Nameable
Person
(getName [this] (str (.firstName this) " " (.lastName this))))
; "Jan Kronquist"
Nameable
; "Jan Kronquist"
Person class implements
Nameable interface
Person extended by
Nameable after deﬁnition!

(getName [this]))
Person
; "Jan Kronquist"
Nameable
(.getName (new Person "Jan" "Kronquist"))
; "Jan Kronquist"
Method getName
exists on Person class

(getName [this]))
Person
; IllegalArgumentException No matching field found: getName
Nameable
; "Jan Kronquist"
Method getName
exists on Person class
But not in this case!

Editors and IDEs?
Eclipse - Counterclockwise
IntelliJ - La Clojure
Light Table
Sublime
Textmate
Emacs

Eclipse Counterclockwise
✓Restrictive formatting
✓Paren coloring
✓Typing suggestions
✓Being Eclipse
https://code.google.com/p/counterclockwise/

Light table
✓Cool
✓Insta-REPL
http://www.lighttable.com/

Sublime
✓General purpose editor
✓Typing suggestions
http://www.sublimetext.com/

Repositories
Maven style
Maven central
http://clojars.org/repo

Build tools
Maven plugin
Gradle plugin
Leiningen

Leiningen
(defproject myproject "0.5.0-SNAPSHOT"
:description "A project for doing things."
:url "http://github.com/foo/bar"
:dependencies [[org.clojure/clojure "1.5.1"]
[ring/ring-core "1.2.0 "]]
:plugins [[lein-ring "0.4.5"]])

Dynamic typing

Dynamic typing?
Robert Smallshire - The Unreasonable Effectiveness of Dynamic Typing for Practical Programs

Compiler won’t ﬁnd errors
Limited tool support
Performance?

What made me think twice
Web server

Clojure makes dynamic typing ok
REPL
Immutable data structure
Pure functions
Automated tests

Dynamic typing and performance?
Clojure is compiled to bytecode
Generally good enough!

Dynamic typing and performance?
Clojure is compiled to bytecode
Generally good enough!
(defn len [^String x]
(.length x))

Studies
Stefan Hanenberg & Lutz Prechelt
Dynamic is more productive
No difference in reliability
Robert Smallshire - 2 % defects are type errors (GitHub)

Conclusion

Convinced?
Lisp looks weird
Just a toy language

Dynamic typing is usable
Convinced?
Lisp looks weird
Just a toy language
REPL
Pure functions
Automated tests

Lisp is consistent
Convinced?
Just a toy language
REPL
Pure functions
Automated tests
(operation operand1 operand2 ...)

Lisp is consistent
Convinced? REPL
Pure functions
Automated tests
Interesting language
Namespaces
Prototcols
Records

Lisp is consistent
Convinced? REPL
Pure functions
Automated tests
Lazy seqs STM Functional
Namespaces
Prototcols
Records

Macros? Maybe.......
Lisp is consistent
Convinced? REPL
Pure functions
Automated tests
Namespaces
Prototcols
Records
try (Writer writer = new FileWriter(fileName))
writer.write(text);
}

Macros? Maybe.......
Lisp is consistent
Convinced? REPL
Pure functions
Automated tests
Namespaces
Prototcols
Records
try (Writer writer = new FileWriter(fileName))
writer.write(text);
}
DSL Reuse Structure

Further resources
http://clojure.org/
http://tryclj.com/
http://www.4clojure.com
http://clojure-doc.org/

Questions?

JavaOne 2013 - Clojure for Java Developers

Recommended

More Related Content

What's hot (20)

Viewers also liked (17)

Similar to JavaOne 2013 - Clojure for Java Developers (20)

Recently uploaded (20)

JavaOne 2013 - Clojure for Java Developers