Clojure: Towards The Essence of Programming

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!

Structural View

defn render-json env json-value

letresponse -> env :servlet-api :response

.setContentType response "application/json"

with-open writer .getWriter response

binding *out* writer

print-json json-value

Java: Complex Structure

int f = 9 * c / 5 + 32;

Higher precendence, then left to right: ((9 * c) / 5) + 32

32(+ (/ (* 9 c) 5) 32)

Clojure: Form Is

Structure16

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

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=> "A Clojure String""A Clojure String"user=> \space\spaceuser=> \A\Auser=> nilniluser=> :balance:balanceuser=> truetrueuser=> falsefalse

Java null

Numeric 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

BigInteger

BigDecimal

Java Interop: Function Calls

(.method-name receiver arguments…)

.setNamespaceAware(factory true)

(.. factory newSaxParser (parse src handler))

newSaxParser. ().parse(src,handler)

(( ))..

factory

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]

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=> (assoc m :company "TWD"){:company "TWD", :last-name "Lewis Ship", :first-name "Howard"}user=> m{:last-name "Lewis Ship", :first-name "Howard"}user=> (get m:ssn)nil

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=> (conj s "Howard")#{"Howard" "Jim" "Molly" "Suzanne"}user=> (conj s "Scott")#{"Howard" "Jim" "Molly" "Suzanne" "Scott"}

Functional Programming

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

My First Program

No it doesn't!

No Mutable

State29

No Side Effects

Purity31

Simplicity Predictability

Testability32

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 #(get % :open) portfolio)(204.50M 29.08M 21.83M)user=>

{ }:ticker AAPL

:last-trade 203.25

:last-trade 29.12

:last-trade 21.90

:open 21.83

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=> (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

:last-trade 29.12

:last-trade 21.90

:open 21.83

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=>

keywords acts as functions

(:keyword map) == (get map :keyword)

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 You52

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

Short Circuits

if (person.isPharaoh() && person.isDead() && constructPyramid()){ person.bury();}

(if (all-true (.isPharaoh person) (.isDead person) (construct-pyramid)) (.bury person))

&& stops with first false

all parameters to function all-true evaluated first

public static boolean allTrue(boolean... inputs){ for (boolean input : inputs) { if (!input) return false; }

return true;}

Caution: Head Exploding Zone

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

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

Control is the Essence of

Programming68

Evaluation69

IfWhenHow

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

Clojure: Towards The Essence of Programming

Technology

Clojure basics

A Journey Towards Essence of Mandukya Upanishad for a Theory of Time

The Ideas of Clojure - Things I learn from Clojure

Dancing towards the Essence

Clojure and Modularity

Clojure values

Clojure-Java Interop - QCon San Francisco 2018 | … · the plan 2 syntax plumbing Clojure calling Java objects, Clojure style Java calling Clojure design principles simplicity direct

Introducción a Clojure

Clojure Web Development

Clojure night

Clojure Intro

Storm and Clojure - Clojure Meetup January 2015

Stm in-clojure

Clojure #1

Clojure noir

Cracking clojure

Introduction to Clojure - Digital Digressions by Stuart … · Stuart Sierra Relevance, Inc. Clojure/core Clojure contributor Sunday, September 18, 2011 3

Clojure presentation

Clojure & Functional Programming? - LispCastlispcast.com/wp-content/uploads/2018/10/Clojure... · Functional Programming Clojure Clojure is a Lisp Lisp is a family of programming

Clojure forbeginners