Codemash-Clojure.pdf

Clojure: Functional Concurrency for the JVM

Howard M. Lewis ShipTWD Consultinghlship@gmail.com

Clojure: Why Functional Programming Matters

Clojure: Towards the Essence of Programming

essence |ˈesəns|nounthe intrinsic nature or indispensable quality of something, esp. something abstract, that determines its character : conflict is the essence of drama.

Mainstream Programming

Operating System

Language

Libraries

Frameworks

Applications

Ceremony vs.

Essence6

Is your language ...

… holding you back?

Java: Data Encapsulated in Objects

Stockticker: AAPL

lastTrade: 203.25open: 204.50shares: 100

Stockticker: MSFT

Stockticker: ORCL

public static void sortByLastTrade(List<Stock> portfolio) { Comparator<Stock> c = new Comparator<Stock>() { public int compare(Stock o1, Stock o2) { return o1.getLastTrade() - o2.getLastTrade(); } };

Collections.sort(portfolio, c); }

public static void sortByOpen(List<Stock> portfolio) { Comparator<Stock> c = new Comparator<Stock>() { public int compare(Stock o1, Stock o2) { return o1.getOpen() - o2.getOpen(); } };

Collections.sort(portfolio, c); }

Clojure: Data in Maps and Lists

user=> portfolio[{:ticker "AAPL", :last-trade 203.25M, :open 204.50M, :shares 100} {:ticker "MSFT", :last-trade 29.12M, :open 29.08M, :shares 50} {:ticker "ORCL", :last-trade 21.90M, :open 21.83M, :shares 200}]user=> (sort-by :last-trade portfolio)({:ticker "ORCL", :last-trade 21.90M, :open 21.83M, :shares 200} {:ticker "MSFT", :last-trade 29.12M, :open 29.08M, :shares 50} {:ticker "AAPL", :last-trade 203.25M, :open 204.50M, :shares 100})user=> (sort-by :shares portfolio)({:ticker "MSFT", :last-trade 29.12M, :open 29.08M, :shares 50} {:ticker "AAPL", :last-trade 203.25M, :open 204.50M, :shares 100} {:ticker "ORCL", :last-trade 21.90M, :open 21.83M, :shares 200})user=>

{ }:ticker AAPL

:last-trade 203.25

:open 204.50 { }:ticker MSFT

:last-trade 29.12

:open 29.08 { }:ticker ORCL

:last-trade 21.90

:open 21.83

:shares 100 :shares 50 :shares 200

Functional JavaScript

var portfolio = [ { ticker: "AAPL", lastTrade: 203.25, open: 204.50}, { ticker: "MSFT", lastTrade: 29.12, open: 29.08 }, { ticker: "ORCL", lastTrade: 21.90, open: 21.83 } ]

portfolio.sortBy(function (stock) { return stock.lastTrade }).toJSON()[{"ticker": "ORCL", "lastTrade": 21.9, "open": 21.83}, {"ticker": "MSFT", "lastTrade": 29.12, "open": 29.08}, {"ticker": "AAPL", "lastTrade": 203.25, "open": 204.5}]

Clojure: The Language

(defn render-json "Renders JSON content (typically, a map or a seq) as the response. The response content type is set to \"application/json\". Returns true." [env json-value] (let [response (-> env :servlet-api :response)] (.setContentType response "application/json") (with-open [writer (.getWriter response)] (binding [*out* writer] (print-json json-value)))) true)

Reading Lisp

(defn render-json "Renders JSON content (typically, a map or a seq) as the response. The response content type is set to \"application/json\". Returns true." [env json-value] (let [response (-> env :servlet-api :response)] (.setContentType response "application/json") (with-open [writer (.getWriter response)] (binding [*out* writer] (print-json json-value)))) true)

Aargh!

Code is Data

'(1 2 3)

(biggest 5 42)

(defn biggest "Find the maximum of two numbers" [x y] (if (> x y) x y))

Quoted list of numbers

Function call

Function definition

Java: Complex Structure

int result = a * b - start + offset;

Higher precendence, then left to right: ((a * b) - start) + offset

offset(+ (- (* a b) start)) offset)

Clojure: Form Is

Structure16

Read Eval Print Loop

user=> (defn biggest "Find the maximum of two numbers" [x y] (if (> x y) x y))#=(var user/biggest)user=> (biggest 5 42)42user=> (doc biggest)-------------------------user/biggest([x y]) Find the maximum of two numbersniluser=> '(1 2 3)(1 2 3)user=> '(biggest 5 42)(biggest 5 42)user=> (first '(biggest 5 42))biggestuser=> (eval '(biggest 5 42))42

Operating System

Java Libraries

User Classes

ClojureRepl Input

Clojure Source Files

Java Compiler

Source Code

Evaluator

REPL and Compilation

Clojure Literals

user=> 4242user=> "A Clojure String""A Clojure String"user=> \space\spaceuser=> \A\Auser=> nilniluser=> :balance:balanceuser=> truetrueuser=> falsefalse

Clojure Literals

user=> 55user=> 5.0015.001user=> 22/722/7user=> (* 2 22/7)44/7user=> (* 100000 100000 100000)1000000000000000user=> (+ 5. 0.000000000000000001)5.0user=> (+ 5.0M 0.000000000000000001M)5.000000000000000001M

Java Interop: Function Calls

(.setNamespaceAware factory true)

(.method-name receiver arguments…)

(.parse (.newSAXParser factory) src handler)

(.. factory newSAXParser (parse src handler))

factory.newSAXParser().parse(src, handler);

Clojure Collections: Lists

user=> (def lst '(1 2 3))#=(var user/lst)user=> lst(1 2 3)user=> (first lst)1user=> (rest lst)(2 3)user=> (conj lst 4)(4 1 2 3)user=> (cons 4 lst)(4 1 2 3)

Clojure Collections: Vectors

user=> (def v [:moe :larry :curly])#=(var user/v)user=> v[:moe :larry :curly]user=> (first v):moeuser=> (rest v)(:larry :curly)user=> (conj v :shemp)[:moe :larry :curly :shemp]user=> (cons :shemp v)(:shemp :moe :larry :curly)user=> v[:moe :larry :curly]user=> (v 1):larry

vector is a function of its indexes

Clojure Collections: Maps

user=> (def m {:first-name "Howard" :last-name "Lewis Ship"})#=(var user/m)user=> m{:last-name "Lewis Ship", :first-name "Howard"}user=> (get m :last-name)"Lewis Ship"user=> (m :last-name)"Lewis Ship"user=> (assoc m :company "TWD"){:company "TWD", :last-name "Lewis Ship", :first-name "Howard"}user=> m{:last-name "Lewis Ship", :first-name "Howard"}user=> (:first-name m)"Howard"user=> (:ssn m)nil

map is a function of its keys

Keywords are functions, too!

Clojure Collections: Sets

user=> (def s #{"Howard" "Suzanne" "Molly" "Jim"})#=(var user/s)user=> s#{"Howard" "Jim" "Molly" "Suzanne"}user=> (contains? s "Howard")trueuser=> (contains? s "howard")falseuser=> (s "Howard")"Howard"user=> (s "Rhys")niluser=> (conj s "Howard")#{"Howard" "Jim" "Molly" "Suzanne"}user=> (conj s "Scott")#{"Howard" "Jim" "Molly" "Suzanne" "Scott"}

set is a function of its elements

Functional Programming

10 X = 120 PRINT X30 X = X + 140 GOTO 20

My First Program

No it doesn't!

No Mutable

State28

No Side Effects

Purity30

Simplicity Predictability

Testability31

Functional Programming in Java

public void saveOrUpdate(final Employee employee){ HibernateCallback callback = new HibernateCallback() { public Object doInHibernate(Session session) throws HibernateException,SQLException { session.saveOrUpdate(employee); return null; } }; hibernateTemplate.execute(callback);}

SwingUtilities.invokeLater(new Runnable() { public void run() { progressBar.setValue(progressBar.getValue() + 1); } });

Outer function controls the context:• Thread• Exception handling• Parameters

Functional Java Collections

return CollectionUtils.filter(new Predicate<String>(){ public boolean accept(String value) { return !value.startsWith("."); }}, names);

public static <T> Collection<T> filter(Predicate<T> pred, Collection<T> coll){ Collection<T> out = new ArrayList<T>();

for (T item : coll) { if (pred.accept(item)) out.add(item); }

return out;}

public interface Predicate<T>{ boolean accept(T value);}

Essence

Functional Clojure Collections

(filter #(not (.startsWith % ".")) names)

Member access form

user=> (def names ["fred" "barney" ".hidden" "wilma"])#=(var user/names)user=> (filter #(not (.startsWith % ".")) names)("fred" "barney" "wilma")user=> (remove #(.startsWith % ".") names)("fred" "barney" "wilma")user=>

Anonymous function

Function parameter

(defn require-extension [ext] (fn [file-name] (= ext (last (split-string file-name ".")))))

Composing Functions (filter #(not (.startsWith % ".")) names)

function as parameter to function

(filter (require-extension "gz") names)

function as return value

composing functions

!Closure Oriented Programming"

Java: Iterative Steps

Java: Data Encapsulated in Objects

public static List<Double> getOpens(List<Stock> portfolio){ List<Double> result = new ArrayList<Double>();

for (Stock stock : portfolio) { result.add(stock.getOpen()); }

return result;}

Stockticker: AAPL

Stockticker: MSFT

Stockticker: ORCL

Clojure: Flow of Transformations

Clojure: Data in Transformable Collections

user=> portfolio[{:ticker "AAPL", :last-trade 203.25M, :open 204.50M, :shares 100} {:ticker "MSFT", :last-trade 29.12M, :open 29.08M, :shares 50} {:ticker "ORCL", :last-trade 21.90M, :open 21.83M, :shares 200}]user=> (map :open portfolio)(204.50M 29.08M 21.83M)user=> (apply + (map #(* (:last-trade %) (:shares %)) portfolio))26161.00Muser=> (map #(assoc % :delta (- (% :last-trade) (% :open))) portfolio)({:delta -1.25M, :ticker "AAPL", :last-trade 203.25M, :open 204.50M, :shares 100} {:delta 0.04M, :ticker "MSFT", :last-trade 29.12M, :open 29.08M, :shares 50} {:delta 0.07M, :ticker "ORCL", :last-trade 21.90M, :open 21.83M, :shares 200})user=>

{ }:ticker AAPL

:last-trade 203.25

:open 204.50 { }:ticker MSFT

:last-trade 29.12

:open 29.08 { }:ticker ORCL

:last-trade 21.90

:open 21.83

:shares 100 :shares 50 :shares 200

Lazymap

user=> (map :open portfolio)(204.5 29.08 21.83)user=> (defn last-trade-value [stock] (* (:last-trade stock) (:shares stock)))#'user/last-trade-valueuser=> (map last-trade-value portfolio)(20325.00M 1456.00M 4380.00M)user=>

:open acts as a function

Laziness is a Virtue

user=> (take 20 (iterate inc 1))(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20)user=> (take 20 (map * (iterate inc 1) (iterate inc 1)))(1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 400)

Lazymap

user=> (map #(assoc %1 :sort-index %2) (reverse (sort-by :last-trade portfolio)) (iterate inc 0))({:sort-index 0, :ticker "AAPL", :last-trade 203.25M, :open 204.50M, :shares 100} {:sort-index 1, :ticker "MSFT", :last-trade 29.12M, :open 29.08M, :shares 50} {:sort-index 2, :ticker "ORCL", :last-trade 21.90M, :open 21.83M, :shares 200})user=>

N seqs # N parameters

reduce

user=> (map #(* (% :last-trade) (% :shares)) portfolio)(20325.00M 1456.00M 4380.00M)user=> (reduce + (map #(* (% :last-trade) (% :shares)) portfolio))26161.00Muser=>

(reduce + (map #(* (% :last-trade) (% :shares)) portfolio))

(reduce + '(20325.00M 1456.00M 4380.00M))

(+ (+ 20325.00M 1456.00M) 4380.00M)

(+ 21781.00M 4380.00M)

26161.00M

reduce

user=> (def input-string "Clojure is a fascinating language with unique capabilities and total integration with Java.")#'user/input-stringuser=> (seq input-string) (\C \l \o \j \u \r \e \space \i \s \space \a \space \f \a \s \c \i \n \a \t \i \n \g \space \l \a \n \g \u \a \g \e \space \w \i \t \h \space \u \n \i \q \u \e \space \c \a \p \a \b \i \l \i \t \i \e \s \space \a \n \d \space \t \o \t \a \l \space \i \n \t \e \g \r \a \t \i \o \n \space \w \i \t \h \space \J \a \v \a \.)user=> (reduce (fn [m k] (update-in m [k] #(inc (or % 0)))) {} (seq input-string)) {\space 12, \a 12, \b 1, \C 1, \c 2, \d 1, \e 5, \f 1, \g 4, \h 2, \i 11, \J 1, \j 1, \l 4, \. 1, \n 7, \o 3, \p 1, \q 1, \r 2, \s 3, \t 8, \u 4, \v 1, \w 2}user=>

Optional initial value

Lazyfilter / remove

user=> (remove #(< 100 (% :shares)) portfolio)({:ticker "AAPL", :last-trade 203.25, :open 204.5, :shares 100} {:ticker "ORCL", :last-trade 21.9, :open 21.83, :shares 57})user=> (filter #(< 100 (% :shares)) portfolio)({:ticker "MSFT", :last-trade 29.12, :open 29.08, :shares 125})user=>

Lazyfor: list comprehension

user=> (for [suit [:hearts :clubs :spades :diamonds] value (range 1 4)] [suit value])([:hearts 1] [:hearts 2] [:hearts 3] [:clubs 1] [:clubs 2] [:clubs 3] [:spades 1] [:spades 2] [:spades 3] [:diamonds 1] [:diamonds 2] [:diamonds 3])user=> (for [x (range 0 4) y (range 0 (inc x))] [x y])([0 0] [1 0] [1 1] [2 0] [2 1] [2 2] [3 0] [3 1] [3 2] [3 3])user=> (for [x (range 0 9) :when (odd? x) y (range 1 (inc x))] [x y])([1 1] [3 1] [3 2] [3 3] [5 1] [5 2] [5 3] [5 4] [5 5] [7 1] [7 2] [7 3] [7 4] [7 5] [7 6] [7 7])user=>

!Somehow the idea of reusability got attached to object-oriented programming in the 1980s, and no amount of evidence to the contrary seems to be able to shake it free."

Paul Graham

Language Ownership

Who Owns the Java Language?

James Gosling Mark Reinhold

Not You51

Control of the Compiler

Operating System

Java Libraries

User Classes

ClojureRepl Input

Clojure Source Files

Java Compiler

Source Code

Evaluator

Who Owns Clojure?

Rich Hickey

Clojure: written in Clojure

Clojure Macros

Reader

Evaluator

Bytecode Generation

macro expansion

(and a b c d)

short circuit at first false/nil

and macro

(let [and__4422__auto__ a] (if and__4422__auto__ (and b c d) and__4422__auto__))

Recursively expanded

Macros # Special Forms

Code Forms

Macro Expansion

Bytecode Generation

def if let fn ….

(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." ([] true) ([x] x) ([x & next] `(let [and# ~x] (if and# (and ~@next) and#))))

Macros are Special Functions

• `(…) — Syntax Quote (allowing replacements)

• and# — Generate a new unique symbol

• ~x — Unquote x

• ~@next — Unquote next and splice in multiple values

(defmacro and ([] true) ([x] x) ([x & next] `(let [and# ~x] (if and# (and ~@next) and#))))

Macros are Special Functions

(and a b c d)

• x # a

• next # '(b c d)

• Inside syntax quote:

• and# # and__4422__auto__

• ~x # a

• ~next # '(b c d)

• (and ~@next) # (and b c d)

Simplifying Boilerplate Code

(deftest test-link (with-mocks [request HttpServletRequest response HttpServletResponse] (:train (expect .getContextPath request "/ctx") (expect .encodeURL response "/ctx/accounts/list" "*encoded*")) (:test (is (= (link request response list-accounts-with-loop) "*encoded*")))))

public void testLink(){ IMocksControl control = EasyMock.createControl(); HttpServletRequest request = control.newMock(HttpServletRequest.class); HttpServletResponse response = control.newMock(HttpServletResponse.class); EasyMock.expect(request.getContextPath()).andReturn("/ctx"); EasyMock.expect(response.encodeURL("/ctx/accounts/list")).andReturn("*encoded*"); control.replay();

assertEquals(…, "*encoded*");

control.verify();}

(defview root-index [env] :html [ :head [ :title [ "Cascade Blog" ] ] :body [ :h1 [ "Cascade Blog" ]

:ul { :class "recent-postings" } [ (template-for [posting (recent-postings env)]

:li [ (render-link env show-posting (posting :id) (posting :title)) ])

] ] ])

Embedded DSLs

:title

"Cascade Blog"

(template-for …)

Macro Expansions

(defn list-items [coll] (template (format "%d items" (count coll)) :ul {:class :item-list} [ (template-for [item coll] :li [item])))

(defn list-items [coll] (cascade.internal.viewbuilder/combine (format "%d items" (count coll)) (cascade.dom/element-node :ul {:class :item-list} (cascade.internal.viewbuilder/combine (for [item coll] (cascade.dom/element-node :li nil (cascade.internal.viewbuilder/combine item)))))))

Expand simple placeholder to

executable code

Extend Clojure language from within Clojure

!More than anything else, I think it is the ability of Lisp programs to manipulate Lisp expressions that sets Lisp apart … when I hear people complain about Lisp's parentheses, it sounds to my ears like someone saying: "I tried one of those bananas, which you say are so delicious. The white part was ok, but the yellow part was very tough and tasted awful.""

Paul Graham

Wrap Up

Clojure

• 1.1 release: Dec 31 2009

• Simple, regular syntax

• Improves on Lisp: vectors, maps, sets

• Fully integrates with Java

• Impressive functional & concurrency support

• Many features not covered here

http://www.clojure.org

Stuart Halloway

Pragmatic Bookshelf

http://pragprog.com/titles/shcloj/programming-clojure

http://java.ociweb.com/mark/clojure/article.html

http://tapestryjava.blogspot.com

Object Oriented

Functional

Codemash-Clojure.pdf

Documents

Transcript of Codemash-Clojure.pdf

Introduction to Clojure - RWTH Aachen Universityhpac.rwth-aachen.de/teaching/sem-lsc-13/Clojure.pdf · 2014-02-06 · Introduction •Appeared in 2007 under Eclipse Public License

Learning the Three Types API Academy of …mamund.com/talks/2019-01-codemash/2019-01-codemash-three...Stateless Microservices Simple processors (converters, translators, etc.) No dependence

Java.Next: Java 8 Overview - Meetupfiles.meetup.com/1401221/Java8Overview-CleJUG.pdf · CODEMASH V 2.0.1.4 2 The following is intended to outline our general product direction. It

Get Rid of Visual SourceSafe Codemash 2010

NoSQL @ CodeMash 2010

Commutication - CodeMash 2017

Python Through the Back Door: Netflix Presentation at CodeMash 2014

Langage Update (Clojure) - ll.jus.or.jpll.jus.or.jp/2010/slide/01-LanguageUpdate/LLTiger-Clojure.pdf · Clojure? • new Lisp dialect –not CommonLisp , Scheme –run on JVM •

Codemash 2007 - Scm with subversion

Introducing Domain Driven Design - codemash

What the heck is Kanban? - CodeMash 2014

Ci for i-os-codemash-01.2013

Spring 3 MVC CodeMash 2009

CodeMash - Building Rich Apps with Groovy SwingBuilder

Strategic Testing (CodeMash 2016)

Easy & Effective Usability Testing at CodeMash 2012

Codemash - Building Custom node.js Modules

Clojure - MathUniPDbaldan/Global/Clojure.pdf · Clojure A (not-so-pure) functional approach to concurrency Paolo Baldan Linguaggi per il Global Computing AA 2016/2017

Marcel Klinzing - RWTH Aachen Universityhpac.rwth-aachen.de/teaching/sem-lsc-12/Clojure.pdf · Introduction Basics Concurrency Conclusion Clojure Marcel Klinzing December 13, 2012

CodeMash 2.0.1.5 - Practical iOS App Attack & Defense