LearnXinYminutes-Clojure.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learn Clojure in Y minutes\n",
    "\n",
    "Adapted from [LearnXinYminutes clojure](https://learnxinyminutes.com/docs/clojure/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comments start with semicolons.\n",
    "Clojure is written in \"forms\", which are just lists of things inside parentheses, separated by whitespace.\n",
    "\n",
    "The clojure reader assumes that the first thing is a function or macro to call, and the rest are arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello world !"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ";; this is a comment\n",
    "\"Hello world !\";; replace with values of other types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "one can get the class of a value by using the `class` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "class java.lang.Double"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(class 1.) ;; replace with values of other types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`str` will create a string out of all its arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello World 1"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(str \"Hello\" \" \" \"World\" \\space 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "keywords are [interned strings](https://en.wikipedia.org/wiki/String_interning) which guarantees that equal keywords are identical, so that testing for equality is done much more efficiently by testing for identity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(identical? (keyword (str \"a\" \\- \"keyword\")) :a-keyword)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arithmetic operators are just functions, which might not be nice on the eye, but is much more simple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(+ 1 1) ;; try other functions and other numbers of arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course the function calls can be composed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "class clojure.lang.Ratio"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(class (/ 2 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Equality can be tested with [=](https://clojuredocs.org/clojure.core/%3D) or [==](https://clojuredocs.org/clojure.core/%3D%3D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(= 1 1.) ;; What about ==  ? What about 1.M ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testing if objects are identical is also useful. Boolean predicates in clojure have a name ending with `?` by convention."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(identical? \"a string\" (str \\a \\space \"string\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(identical? (keyword \"a string\") (keyword (str \\a \\space \"string\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`false` and `nil` are false values when testing for truthiness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":f"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(if nil :t :f) ;; btw what is (class nil) ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any other value is true, even if it is a `Boolean` equals (but not identical !) to `false` !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":t"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ";; (= (Boolean. false) false)\n",
    " (if (Boolean. false) :t :f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To convert the `Boolean` value to `true` or `false`, you can use the [boolean](https://clojuredocs.org/clojure.core/boolean) function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":f"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(if (boolean (Boolean. false)) :t :f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, you have the expected boolean functions [and](https://clojuredocs.org/clojure.core/and) [or](https://clojuredocs.org/clojure.core/or) , [not](https://clojuredocs.org/clojure.core/and)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(not (and true false))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Homoiconicity** means that or code is made of lists, which, while not very pleasing on the eye at first, will be immensely useful for macros. Function calls are represented by lists, the first element being the funtcion and the rest being the arguments. However, one can also write a list as a list and prevent it from being evaluated by prefixing it with a single quote `'` quite is a shorthand for the [quote](https://clojuredocs.org/clojure.core/quote) form. (Why can't `quote` be a function ?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(+ 1 2)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(str '(+ 1 2));; str for display purposes only in the note book. What is (class '(+ 2 3)) ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(+ 1 2)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(str (quote (+ 1 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you want to evaluate a list, you can call [eval](https://clojuredocs.org/clojure.core/eval) on it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(eval (quote (+ 2 3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Collections and sequences\n",
    "### Lists\n",
    "As we saw, lists have to be quoted if we are to use them as data structures instead of code.\n",
    "One can efficiently prepend on a list using the [cons](https://clojuredocs.org/clojure.core/cons) function.\n",
    "The [first](https://clojuredocs.org/clojure.core/first) function returns the first element of a list and the [rest](https://clojuredocs.org/clojure.core/rest) function returns all but the first element of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(eval (cons + '( 2 3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can also be created with the [list](https://clojuredocs.org/clojure.core/list) function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(eval (list + 1 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(rest '(+ 2 3));; btw what is the class of '(+ 2 3) ? And what is the class of (rest '(+ 2 3)) ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectors\n",
    "Vectors allow efficient random access (with [nth](https://clojuredocs.org/clojure.core/nth) or\n",
    "[get](https://clojuredocs.org/clojure.core/get) depending whether we want to throw an exception or return `nil` on\n",
    "out of bounds indices)\n",
    "and efficiently appending with [conj](https://clojuredocs.org/clojure.core/conj).\n",
    "\n",
    "Vectors can be declared inline with `[]` or the [vector](https://clojuredocs.org/clojure.core/vector) function.\n",
    "\n",
    "\n",
    "*Note*: [conj](https://clojuredocs.org/clojure.core/conj) can also be used on other collections such as lists and always\n",
    "adds the element at the most efficient place. So for lists it would be at the beginning like [cons](https://clojuredocs.org/clojure.core/cons)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, a string]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(conj [0 1 2 3] \"a string\");; what is the class of [] ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Collections\n",
    "Lists and vectors (among other data structures) are collections (as can be tested with the predicate [coll?](https://clojuredocs.org/clojure.core/coll?), which means that we can call the following functions\n",
    "on them :\n",
    " * [=](https://clojuredocs.org/clojure.core/=)\n",
    " * [count](https://clojuredocs.org/clojure.core/count)\n",
    " * [conj](https://clojuredocs.org/clojure.core/conj)\n",
    " * [empty](https://clojuredocs.org/clojure.core/empty)\n",
    " * [seq](https://clojuredocs.org/clojure.core/seq) → for sequences, cf. infra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(= [1 2 3] '(1 2 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sequences\n",
    "[Sequences](https://clojure.org/reference/sequences) are an abstraction over data that can be iterated on using [first](https://clojuredocs.org/clojure.core/first) and [rest](https://clojuredocs.org/clojure.core/rest) or prepended to using [cons](https://clojuredocs.org/clojure.core/count).\n",
    "\n",
    "Lists are already sequences, and so are results of various functions. One can make a sequence over the elements of any collections with the [seq](https://clojuredocs.org/clojure.core/seq) function and test if a value is a sequence using the [seq?](https://clojuredocs.org/clojure.core/seq?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(seq? [1 2]);; what about a list ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(let[xs '(1 2 3)]          ;; what about a vector ?\n",
    " (identical? (seq xs) xs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some sequences are lazy and can be infinite (you don't want to print them !)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5, 6, 7, 8, 9, 10, 11]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(drop 2 (take 12 (range))) ;; check that (range) returns a sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can [concat](https://clojuredocs.org/clojure.core/concat) collections "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 10, 20, 30, 40, 1]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(concat '(1 2 3) [10 20 30 40] '(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions on sequences or collections\n",
    "### Filter\n",
    "One can [filter](https://clojuredocs.org/clojure.core/filter) values according to a predicate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(take 5 (filter odd? (range)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Map\n",
    "Not to be confused with the map data structure (cf. infra) that is an association table, one can [map](https://clojuredocs.org/clojure.core/map) a function on a sequence or collection of values. The result is lazy so it is possible to [map](https://clojuredocs.org/clojure.core/map) on an infinite (lazy) sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, -9, 4]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(map inc [0 -10 3]) ;; what is the class of the result ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, -9, 4]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(inc 0) (inc -10) (inc 3)];; "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to `map` a function taking more than one arguments on the same number of sequences/collections."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 8]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(map + [1 2 3] '(-1 2 5))  ;;what if they don't have the same size ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## On lazy sequences\n",
    "Clojure allows to create an use lazy sequence, so they can be infinite. `map` is lazy so it is possible to `map` on an infinite sequence. The functions will only be called when the sequence is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def infinite-range (range))\n",
    "(take 10 infinite-range)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def twice-infinite-range (map #(* 2 %) infinite-range))\n",
    "(vec (take 10 twice-infinite-range));; what if we do not convert to a vector ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"Elapsed time: 0.197391 msecs\"\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "done?"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(time (map #(do(println \"sleeping for \" % \"s\")(Thread/sleep (* 1000 %)) (* 2 %)) (range 10)))\n",
    "\"done?\" ;; what if you remove this expression ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reduce\n",
    "[reduce](https://clojuredocs.org/clojure.core/reduce) repeatedly calls a function on the same first argument taking the second argument values from the given sequence / collection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(reduce conj [] [0 1 2 3]) ;; What if the given first argument is a list ? What if the second is a list ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(conj (conj (conj (conj [] 0) 1) 2) 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Reducing function can also `conj` in a collection result, so `reduce` could be considered the most generic / fundamental buildnig block. However, the `reduce` cannot be lazy. In order to be completely generic, one would have to use [transducers](https://clojure.org/reference/transducers)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "[fn](https://clojuredocs.org/clojure.core/fn) declare an anonymous function, parameters are written in a vector\n",
    ", the function returns the last value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "beaker_clojure_shell_8d14e6a1_754c_4888_b929_716ee9e3d70e$eval244$fn__245@b233553"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(fn[] \"Hello world !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The declared finction can be called as usual"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello world!"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((fn[] \"Hello world!\")) ;; note the surrounding ()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello Rich !"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((fn[name] (str \"Hello \" name \" !\")) \"Rich\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Closure : captured bindings\n",
    "Functions can close over their lexical scope to capture bindings. This allows to keep some data used by functions available for later executions of the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def adder (fn [to-add] ;; we'll se a nicer way to define a function and bind it to an identifier \n",
    "                #(+ % to-add))) ;; just a toy example, should use 'partial' function instead\n",
    "(def adding-two (adder 2))\n",
    "(def adding-five (adder 5))\n",
    "\n",
    "(adding-two 1)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## let : local bindings\n",
    "In the same way that arguments bind to the values passed to the function call, it is possible to bind local *symbols*\n",
    "to values with [let](https://clojuredocs.org/clojure.core/let), so as to decompose expressions and reuse sub-expressions and/or name sub-expressions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#'beaker_clojure_shell_8d14e6a1-754c-4888-b929-716ee9e3d70e/roots"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def roots (fn [ a b c]\n",
    "            (let[delta (- (* b b) (* 4 a c))]\n",
    "                (when (>= delta 0)\n",
    "                      (let[sqrt-delta (Math/sqrt delta)\n",
    "                           denominator (* -2 a)]\n",
    "                        [(/ (+ b sqrt-delta) denominator)\n",
    "                         (/ (- b sqrt-delta) denominator)])))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1.618033988749895, 0.6180339887498949]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(roots 1 1 -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vars\n",
    "One defines a global [var](https://clojure.org/reference/vars) with [def](https://clojuredocs.org/clojure.core/def)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#'beaker_clojure_shell_8d14e6a1-754c-4888-b929-716ee9e3d70e/pi"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def pi 3.1415927535) ;; use Math/pi instead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.1415927535"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A var can be bound to a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello Rich !"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def greeting (fn [name] (str \"Hello \" name \" !\")))\n",
    "(greeting \"Rich\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[defn](https://clojuredocs.org/clojure.core/defn) is a shorter way to defined a function and bind a var to it at once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello Rich !"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(defn greeting [name] \n",
    "    (str \"Hello \" name \" !\"))\n",
    "(greeting \"Rich\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anonymous functions can also be defined with a [syntactic sugar](https://en.wikipedia.org/wiki/Syntactic_sugar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Hello Rich !, Hello Linus !]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(map #(str \"Hello \" %1 \" !\") [\"Rich\" \"Linus\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can define multi-variadic functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello World"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(defn hello3\n",
    "  ([] \"Hello World\")\n",
    "  ([name] (str \"Hello \" name)))\n",
    "(hello3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello Rich"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(hello3 \"Rich\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can pack the remaining arguments, if any, in a sequence using `&` at the end of the argument list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "You passed 3 args: (1 2 3)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(defn count-args [& args]\n",
    "  (str \"You passed \" (count args) \" args: \" args))\n",
    "(count-args 1 2 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hello Richard, you passed 3 extra args"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(defn hello-count [name & args]\n",
    "  (str \"Hello \" name \", you passed \" (count args) \" extra args\"))\n",
    "(hello-count \"Richard\" 1 2 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can (should !) add a docstring to the function definition. This documentation can be retrieved with the [doc](https://clojuredocs.org/clojure.repl/doc) function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------\n",
      "beaker_clojure_shell_8d14e6a1-754c-4888-b929-716ee9e3d70e/with-doc\n",
      "([])\n",
      "  A documentation explaining the function.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(defn with-doc\n",
    "  \"A documentation explaining the function.\"\n",
    "  []\n",
    "  (println \"hello world !\"))\n",
    "(require 'clojure.repl)\n",
    "(clojure.repl/doc with-doc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not only are the function documented, but the source code is also available with the [source](https://clojuredocs.org/clojure.repl/source) function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(defn str\n",
      "  \"With no args, returns the empty string. With one arg x, returns\n",
      "  x.toString().  (str nil) returns the empty string. With more than\n",
      "  one arg, returns the concatenation of the str values of the args.\"\n",
      "  {:tag String\n",
      "   :added \"1.0\"\n",
      "   :static true}\n",
      "  (^String [] \"\")\n",
      "  (^String [^Object x]\n",
      "   (if (nil? x) \"\" (. x (toString))))\n",
      "  (^String [x & ys]\n",
      "     ((fn [^StringBuilder sb more]\n",
      "          (if more\n",
      "            (recur (. sb  (append (str (first more)))) (next more))\n",
      "            (str sb)))\n",
      "      (new StringBuilder (str x)) ys)))\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(clojure.repl/source str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When that makes sense, it is possible to add [type hints](https://clojure.org/reference/java_interop#typehints), for performance reasons (not type safety)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Reflection warning, null:3:1 - reference to field length can't be resolved.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"Elapsed time: 8321.358669 msecs\"\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4000000"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(set! *warn-on-reflection* true)\n",
    "(defn len [x]\n",
    "  (.length x))\n",
    "(time (reduce + (map len (repeat 1000000 \"asdf\"))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"Elapsed time: 279.788342 msecs\"\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4000000"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(defn len2 [^String x]\n",
    "  (.length x))\n",
    "(time (reduce + (map len2 (repeat 1000000 \"asdf\"))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Maps\n",
    "Maps are associative collections. Any type ca be used as key or value, but keywords make for very efficient keys (thanks to interning). They can be written using curly braces `{}` or with the [array-map](https://clojuredocs.org/clojure.core/array-map) or the [hash-map](https://clojuredocs.org/clojure.core/hash-map) functions. Hash maps are more efficient for large maps and are created as needed for large maps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "class clojure.lang.PersistentArrayMap"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(class {1 \"one\" :two 2. false 3})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "class clojure.lang.PersistentHashMap"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def test-map (hash-map 0 false \"one\" :one))\n",
    "(class test-map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "maps can be used as functions on a key to retrieve the associated value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":one"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(test-map \"one\") ;; what if the key is missing ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keywords can be used as functions to retrieve value from a map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, 2]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def a-map {:a [1] :c [] :b [2] :e [-1 2]})\n",
    "(:e a-map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[assoc](https://clojuredocs.org/clojure.core/assoc) can \"add\" keys and values to a map (actually, returning a new immutable map) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f60a224a-b6e6-4ff1-b6d4-d58285ca6030",
       "version_major": 2,
       "version_minor": 0
      },
      "method": "display_data"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "(assoc a-map :f [0 1]) ;; can you add more than one pair of key / value ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The data structure is not changed (it is *immutable*), `assoc` (efficiently) returned a new one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "83c34285-d88c-45f3-9e67-6e6d2e5334fb",
       "version_major": 2,
       "version_minor": 0
      },
      "method": "display_data"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a-map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c968748b-61e2-471e-9b78-1758668db913",
       "version_major": 2,
       "version_minor": 0
      },
      "method": "display_data"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "(dissoc a-map :b) ;; what if you have more than one key as arguments after the map ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviously, `dissoc` does not change the map either, it just returned a new map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fa99ce10-19e8-40f1-bc2b-b1bcf7e03f89",
       "version_major": 2,
       "version_minor": 0
      },
      "method": "display_data"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a-map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets\n",
    "Sets are collections that remove dupplicates and allow for efficiently testing if the collection contains a given value. They can be written with curly braces prefixed by a hash `#{}` or with the [hash-set](https://clojuredocs.org/clojure.core/hash-set) or the [sorted-set](https://clojuredocs.org/clojure.core/sorted-set) functions or the [sorted-set-by](https://clojuredocs.org/clojure.core/sorted-set-by) variant that allows to specify a comparison function. The [set](https://clojuredocs.org/clojure.core/set) function takes a collection as an argument instead of values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "class clojure.lang.PersistentHashSet"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(class #{1 2 3})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 2]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(hash-set 1 2 3 1 2 3 3 2 1 3 2 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "class clojure.lang.PersistentHashSet"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(class (set [1 2 3 1 2 3 3 2 1 3 2 1]));;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with other collections, one can add a value (actually, returning a new set with the added value, because/thanks to immutability) with [conj](https://clojuredocs.org/clojure.core/conj)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 3, 2]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(conj #{1 2 3} 4) ;; what if the value was already in the set ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can remove (actually, return a new set with the value removed, because/ thanks to immutability) with [disj](https://clojuredocs.org/clojure.core/sorted-set-by)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(disj #{1 3 2} 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can use the set as a function that will test is the argument is contained by the set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(#{1 3 2} 3) ;; what is returned when the value is in the set ? What is returned when it is not ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Destructuring\n",
    "Oftentimes,sequences (e.g vectors) or maps are used as arguments or returned values and we want to extract\n",
    "the content of these data structures to bind arguments or local bindings (cf `(let[])`).\n",
    "\n",
    "[Destructuring](https://clojure.org/guides/destructuring) allows us to do that by using a data-structure literal\n",
    "(`[]` for sequences and `{}` for maps) when writing the bindings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3/2"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def seq-data [2 -1 4])\n",
    "(defn my-fun [a-vector]\n",
    "  (let[d (get a-vector 0)\n",
    "       a1 (get a-vector 1)\n",
    "       a2 (get a-vector 2)]\n",
    "    (/ (+ a1 a2) d)))\n",
    "\n",
    "(my-fun seq-data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3/2"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(defn my-fun [[d a1 a2]] ;; destructuring from a sequence, what if we pass an other type of sequence ?\n",
    "   (/ (+ a1 a2) d))\n",
    "(my-fun seq-data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Super Co.\n",
       "Philadelphia - The worldwide leader in plastic tableware."
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def client {:name \"Super Co.\"\n",
    "             :location \"Philadelphia\"\n",
    "             :description \"The worldwide leader in plastic tableware.\"})\n",
    "(defn my-fun [client-data]\n",
    "    (let [name (:name client)\n",
    "          location (:location client)\n",
    "          description (:description client)]\n",
    "        (str name \\newline location \" - \" description)))\n",
    "\n",
    "(my-fun client)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Super Co.\n",
       "Philadelphia - The worldwide leader in plastic tableware."
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(defn my-fun [{name :name\n",
    "       location :location\n",
    "       description :description}]\n",
    "       (str name \\newline location \" - \" description))\n",
    "(my-fun client)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Super Co.\n",
       "Philadelphia - The worldwide leader in plastic tableware."
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(defn my-fun [{:keys [name location description]}] ;; :keys because we use keywords as keys, :strs for string, :syms for symbols\n",
    "    (str name \\newline location \" - \" description))\n",
    "(my-fun client)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Forms\n",
    "Besides functions call code can take other forms.\n",
    "### if\n",
    "`if` is a funtional test akin to the ternary operator of languages like C or Java."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(if false \"a\" \"b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(if false \"a\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### let\n",
    "`let` allows for local (i.e. lexical scope) bindings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(let [a 1\n",
    "      b 2]\n",
    "  (> a b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### do\n",
    "`do` allows to group multiple expressions together and evaluates to the value of the last expression. It is mostly useful for expressions with side-effects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello"
     ]
    },
    {
     "data": {
      "text/plain": [
       "World"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(do\n",
    "  (print \"Hello\")\n",
    "  (.flush *out*)\n",
    "  \"World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions and `let` have an implicit `do` and can contain multiple expressions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saying hello to  Jeff"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Hello Jeff"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(defn print-and-say-hello [name]\n",
    "  (print \"Saying hello to \" name)\n",
    "  (.flush *out*)\n",
    "  (str \"Hello \" name))\n",
    "(print-and-say-hello \"Jeff\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saying hello to  Urkel\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Hello Urkel"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(let [name \"Urkel\"]\n",
    "  (println \"Saying hello to \" name)\n",
    "  (.flush *out*)\n",
    "  (str \"Hello \" name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Macros\n",
    "*Macros* look like functions but they are executed **before** run time on the **code** as written to transform it into other code (that would have been more tedious to write by hand).\n",
    "### when\n",
    "[when](https://clojuredocs.org/clojure.core/when) packs `if` and `do` in order to allow multiple expressions after an `if`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "doing something\n",
      "doing something else\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "test was true !"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(when (< 1 2)\n",
    "(println \"doing something\")\n",
    "(println \"doing something else\")\n",
    "(.flush *out*)\n",
    "\"test was true !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[macroexpand](https://clojuredocs.org/clojure.core/macroexpand) allows you to get the result of expanding a macro instead of just using the macro to write your program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(if (< 1 2) (do (println \"doing something\") (println \"doing something else\") (.flush *out*) \"test was true !\"))"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(str (macroexpand '(when (< 1 2)   ;; why do we need to quote the expression for macroexpand ?\n",
    "                    (println \"doing something\")\n",
    "                    (println \"doing something else\")\n",
    "                    (.flush *out*)\n",
    "                    \"test was true !\"))) ;; the str was only for disply purposes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### cond and condp\n",
    "[cond](https://clojuredocs.org/clojure.core/cond) and [condp](https://clojuredocs.org/clojure.core/condp) are the functional equivalent of `switch` statements in imperative languages like C.\n",
    "\n",
    "Remarkably, the can be implemented as macro instead of requiring any special language support."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "B"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(let [grade 85]\n",
    "    (cond\n",
    "    (>= grade 90) \"A\"\n",
    "    (>= grade 80) \"B\"\n",
    "    (>= grade 70) \"C\"\n",
    "    (>= grade 60) \"D\"\n",
    "    :else \"F\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(if (>= grade 90) \"A\" (clojure.core/cond (>= grade 80) \"B\" (>= grade 70) \"C\" (>= grade 60) \"D\" :else \"F\"))"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(str\n",
    "(macroexpand '(cond\n",
    "                (>= grade 90) \"A\"\n",
    "                (>= grade 80) \"B\"\n",
    "                (>= grade 70) \"C\"\n",
    "                (>= grade 60) \"D\"\n",
    "                :else \"F\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "two"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(defn translate [value]\n",
    "    (condp = value\n",
    "             1 \"one\"\n",
    "             2 \"two\"\n",
    "             3 \"three\"\n",
    "             (str \"unexpected value, \\\"\" value \\\")))\n",
    "(translate 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(let* [pred__384 = expr__385 value] (if (pred__384 1 expr__385) \"one\" (if (pred__384 2 expr__385) \"two\" (if (pred__384 3 expr__385) \"three\" (str \"unexpected value, \\\"\" value \\\")))))"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(str ;; only to display proprely in the notebook\n",
    "(macroexpand '(condp = value\n",
    "             1 \"one\"\n",
    "             2 \"two\"\n",
    "             3 \"three\"\n",
    "             (str \"unexpected value, \\\"\" value \\\"))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ")### Threading macros\n",
    "Nesting functions can be cumbersome to write and read (left to right) because the fuction calls are \"inside first\" :\n",
    "\n",
    "\n",
    "with `(f (g (h x)))` one read `f`, `g` and `h` while `h` is called first, then `g`, then `f`.\n",
    "Theading macros allow to write code in the execution order and have it nested in the correct evaluation order automatically.\n",
    "\n",
    "`->` inserts the result as the first argument of functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(-> {:a 1 :b 2} (assoc :c 3) (dissoc :b) :a (- 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`->>` does the same thing as `->` but threads the (provided / returned) value as the *last* argument of functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(->>\n",
    "   (range)\n",
    "   (take 10)\n",
    "   (map inc)     ;=> (map inc (range 10)\n",
    "   (filter odd?) ;=> (filter odd? (map inc (range 10))\n",
    "   (into []))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`as->` allows you to name the value and then use that name as a placeholder to control which argument will be replaced by the threaded value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5, 6, 4, [8, 9, 10]]"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(as-> [1 2 3] input\n",
    "  (map inc input);=> You can use last transform's output at the last position\n",
    "  (nth input 2) ;=>  and at the second position, in the same expression\n",
    "  (conj [4 5 6] input [8 9 10])) ;=> or in the middle !\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Input / Output\n",
    "### Output\n",
    "[spit](https://clojuredocs.org/clojure.core/spit) allows to write some data in a file. One can use an `OutputStream` instead of a file name but the underlying stream is closed at the end, so using `*out*` (bound to `System.out`) to print would close it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(spit \"toto.txt\" \"Data in a file\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input\n",
    "[slurp](https://clojuredocs.org/clojure.core/slurp) allows to read from a file, from an URL or from an `InputStream` (`*in*` refers to `System.in` but is not useful in a notebook). Of course, [other options are available](https://nakkaya.com/2010/06/15/clojure-io-cookbook/) to read line by line instead of the whole file at once and/or binary data instead of text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Data in a file"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(slurp \"toto.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "# Clojure, Made Simple\n",
       "\n",
       "* **Speaker: Rich Hickey**\n",
       "* **Event: [JavaOne Conference]**\n",
       "* **Date: June 2015**\n",
       "* **Video: [https://www.youtube.com/watch?v=VSdnJDO-xdg](https://www.youtube.com/watch?v=VSdnJDO-xdg)**\n",
       "\n",
       "[Time 0:00:00]\n",
       "\n",
       "```\n",
       "slide:\n",
       "\n",
       "     Clojure,\n",
       "    Made Simple\n",
       "\n",
       "    Rich Hickey\n",
       "```\n",
       "\n",
       "I want to thank everybody for coming.  The title of this talk is\n",
       "\"Clojure, Made Simple\".  On the brochure they left out the comma.  So\n",
       "it is not \"Clojure Made Simple,\" in other words a tutorial on Clojure\n",
       "or an easy explanation of Clojure.  It is not actually a comprehensive\n",
       "explanation of Clojure at all, but a look at a slice of what Clojure\n",
       "is about.  A way of thinking about why you might want to use it.\n",
       "\n",
       "\n",
       "[Time 0:00:25]\n",
       "\n",
       "```\n",
       "slide title: Me\n",
       "\n",
       "+ Creator of Clojure\n",
       "\n",
       "+ Designer of Datomic\n",
       "\n",
       "+ CTO/Co-Founder Cognitect, Inc.\n",
       "\n",
       "+ Two decades delivering commercial\n",
       "  production apps in C++/Java/C#\n",
       "```\n",
       "\n",
       "So I am the person who made Clojure.  I currently work on a database\n",
       "called Datomic, which is kind of a functional database.  It is written\n",
       "in Clojure.  It runs on the JVM architecture.  I am a co-founder of\n",
       "Cognitect, which builds Datomic and sponsors the development and\n",
       "stewardship of Clojure.\n",
       "\n",
       "But the main point I wanted to make about myself to this audience was\n",
       "-- because in this talk I might seem somewhat skeptical of Java and\n",
       "object-oriented programming -- is that I have done an absolute ton of\n",
       "that.  That is what I did for two decades before I said, \"If I still\n",
       "want to be a programmer, I do not want to do it this way anymore.\"  So\n",
       "I know exactly how apps are built using Java and C++ and C#, because\n",
       "that is what I used to do.  That does not mean what I think about them\n",
       "is correct, but that is my experience.\n",
       "\n",
       "\n",
       "[Time 0:01:23]\n",
       "\n",
       "```\n",
       "slide title: You\n",
       "\n",
       "+ (dis)contented Java dev?\n",
       "\n",
       "+ Clojure tinkerer?\n",
       "\n",
       "  'wish I could use it at work'\n",
       "\n",
       "+ Clojure user\n",
       "\n",
       "+ Couldn't get into Brian Goetz' talk\n",
       "```\n",
       "\n",
       "But I am wondering about you.  How many people program in Java here?\n",
       "How many people are happy about that?  How many of you are actively\n",
       "unhappy about that, and looking for alternatives?  OK, great.\n",
       "\n",
       "How many people have tried Clojure at all?  Great.  How many people\n",
       "have never heard of Clojure and are in the wrong room?  OK.  How many\n",
       "people have tried Clojure and are trying to get to use it at work, but\n",
       "not yet?  A few.  Maybe this talk will give you some ways of talking\n",
       "about Clojure's value proposition that could help you.\n",
       "\n",
       "How many people actively use Clojure, and somehow are accidentally at\n",
       "JavaOne?  OK.  And the rest could not get into Brian Goetz's talk.  I\n",
       "should not even mention that Brian Goetz has talk right now, because\n",
       "we could have people filing out.  Or maybe you are just tired of Brian\n",
       "Goetz talking about immutability, in which case you are definitely in\n",
       "the wrong room.  No, I like him.  Brian's a good friend and his talks\n",
       "are great, so I appreciate your bringing this one.\n",
       "\n",
       "\n",
       "[Time 0:02:22]\n",
       "\n",
       "```\n",
       "slide title: Clojure\n",
       "\n",
       "+ Programming language for JVM, JavaScript et al\n",
       "\n",
       "+ Released in 2007\n",
       "\n",
       "+ Lisp, functional, data-oriented etc (more later)\n",
       "```\n",
       "\n",
       "So there were very few people who had never heard of Clojure, so I am\n",
       "not going to spend a lot of time on it.\n",
       "\n",
       "Oh, I had one more question.  How many people have seen my talk\n",
       "\"Simple Made Easy\"?  How many people have not?  OK, a few, so I may\n",
       "spend a minute describing what I mean when I say simple.\n",
       "\n",
       "Clojure is a programming language.  It runs in the JVM and JavaScript,\n",
       "and pretty much a substantial subset of Clojure runs on JavaScript.\n",
       "So it is a programming language with which you can target both.  But\n",
       "originally it only targeted the JVM and the CLR.  There is still a\n",
       "port to the CLR that is maintained, but does not see wide use.\n",
       "\n",
       "I released it first in 2007.  It has had surprising adoption,\n",
       "especially from my perspective, since then, given its characteristics.\n",
       "Because it is a Lisp, it is functional, it is data oriented.  And it\n",
       "has a lot of things that make it seem not like the kind of language\n",
       "that would succeed.  And this talk will really be about the data\n",
       "orientation of Clojure.\n",
       "\n",
       "\n",
       "[Time 0:03:27]\n",
       "\n",
       "```\n",
       "slide: \n",
       "\n",
       "\"A lot of the best programmers and the\n",
       "most productive programmers I know are\n",
       "writing everything in ______ and swearing\n",
       "by it, and then just producing ridiculously\n",
       "sophisticated things in a very short time.\n",
       "And that programmer productivity matters.\"\n",
       "\n",
       "            Adrian Cockcroft -\n",
       "Battery Ventures, formerly Cloud Architect, Netflix\n",
       "```\n",
       "\n",
       "So a lot of the best programmers and the most productive programmers I\n",
       "know are writing everything in blank and swearing by it, and then just\n",
       "producing ridiculously sophisticated things in a very short time and\n",
       "that programmer productivity matters.  So Adrian Cockcroft was cloud\n",
       "architect at Netflix.  Now he is at Battery Ventures.\n",
       "\n",
       "How many people think Java goes in the blank?  OK.  So we know.  We\n",
       "know this.  There is something about Java that makes it not suitable\n",
       "for this blank.  So maybe we can tease that apart.\n",
       "\n",
       "\n",
       "[Time 0:04:04]\n",
       "\n",
       "```\n",
       "slide: \n",
       "\n",
       "\"A lot of the best programmers and the\n",
       "most productive programmers I know are\n",
       "writing everything in _Clojure_ and swearing\n",
       "by it, and then just producing ridiculously\n",
       "sophisticated things in a very short time.\n",
       "And that programmer productivity matters.\"\n",
       "\n",
       "            Adrian Cockcroft -\n",
       "```\n",
       "[https://thenewstack.io/the-new-stack-makers-adrian-cockcroft-on-sun-netflix-clojure-go-docker-and-more/](https://thenewstack.io/the-new-stack-makers-adrian-cockcroft-on-sun-netflix-clojure-go-docker-and-more/)\n",
       "\n",
       "Yes, of course, he was saying Clojure.  And this talk is about maybe\n",
       "why.  Like how could this be true?  What is it that makes Clojure\n",
       "different and possibly a better fit for that blank?\n",
       "\n",
       "\n",
       "[Time 0:04:19]\n",
       "\n",
       "```\n",
       "slide title: Programming is an\n",
       "             Economic Activity\n",
       "\n",
       "+ Cost/benefit\n",
       "\n",
       "+ ROI\n",
       "\n",
       "+ Time to market\n",
       "\n",
       "+ Profit\n",
       "```\n",
       "\n",
       "So the first thing I want to talk about is that: I think we have this\n",
       "tendency in programming to think about ourselves just a ton, and our\n",
       "languages, and our tools, and our techniques, and me, me, me, me, me,\n",
       "us.  What we are doing, whatever.\n",
       "\n",
       "We lose track of the fact that we are all working for somebody else\n",
       "who is, or for ourselves, but for a business or an organization that\n",
       "is trying to accomplish something in the world.  And the software is\n",
       "completely secondary to that task.  It should be measured always in\n",
       "terms of the cost-benefit ratio, the return on investment.  How\n",
       "quickly can we get a product to market?  And is what we are doing\n",
       "profitable?  If we are not doing that, we are not really being good\n",
       "participants in our businesses or organizations.\n",
       "\n",
       "\n",
       "[Time 0:05:05]\n",
       "\n",
       "```\n",
       "slide title: Stakeholders Want\n",
       "\n",
       "+ Something good\n",
       "\n",
       "+ Soon\n",
       "```\n",
       "\n",
       "So what do the stakeholders want?  They really want two things.  They\n",
       "want something good, and they want it soon.\n",
       "\n",
       "\n",
       "[Time 0:05:18]\n",
       "\n",
       "```\n",
       "slide title: Something Good\n",
       "\n",
       "+ --Passes all tests-- [strikethrough]  _Programmer-centric_\n",
       "\n",
       "+ --Type checks-- [strikethrough]        _means, not ends_\n",
       "\n",
       "+ Does what it is supposed to do\n",
       "\n",
       "+ Meets operational requirements\n",
       "\n",
       "+ Is flexible enough to accommodate change\n",
       "```\n",
       "\n",
       "So something good.  We think we know what is something good.  We know\n",
       "how to make things good, right?  We have these techniques, and things\n",
       "are good when the techniques are successful with them.  So when our\n",
       "types check and our tests pass, we have something good.\n",
       "\n",
       "But of course we all know that with our best efforts in those things,\n",
       "which are -- I am not saying they are bad activities, by the way --\n",
       "but no matter what we do there, we end up with programs that do not\n",
       "work.  We all know we have programs that type check, and tests pass,\n",
       "and they do not work.\n",
       "\n",
       "And they do not work from the perspective of the stakeholder.  In\n",
       "other words, they do not do what the program was supposed to do, and\n",
       "what it is supposed to do was something that was conveyed between\n",
       "people, or through documentation, or papers, or things that are not in\n",
       "programming languages.\n",
       "\n",
       "They have to meet operational requirements.  And they have to be\n",
       "flexible.  Now there are some times where people just want something\n",
       "soon, and they do not want something good.  There are actually better\n",
       "languages than Clojure for that.  Just give me something fast that I\n",
       "am absolutely definitely going to throw away.  It will not grow, will\n",
       "not expand, will not take me further.\n",
       "\n",
       "So these first two things are means, right?  They are good, but they\n",
       "are only good insofar as they help ensure the latter three things.\n",
       "\n",
       "\n",
       "[Time 0:06:34]\n",
       "\n",
       "```\n",
       "slide title: Does what it is\n",
       "             Supposed To Do?\n",
       "\n",
       "+ From the perspective of the _stakeholders_\n",
       "\n",
       "+ Very difficult to determine if a large,\n",
       "  elaborate stateful program does what it is\n",
       "  supposed to do\n",
       "\n",
       "+ Very difficult to determine if _large_ _or_\n",
       "  _elaborate_ _or_ _stateful_ programs do what\n",
       "  they are supposed to do\n",
       "```\n",
       "\n",
       "So if we break it down, what is it supposed to do?  Again, it is a\n",
       "perspective thing.  If the stakeholder thinks it is doing what it is\n",
       "supposed to do, they are fine.  And of course, they are going to have\n",
       "expressed concerns about software, what it is supposed to do.  It\n",
       "should do this when I push this button.\n",
       "\n",
       "And they are going to have unexpressed presumed things like: it should\n",
       "be secure.  It should not cause the computers to go on fire because it\n",
       "is so slow.  It should not require three new data centers.  It should\n",
       "keep running, and not stop for an hour every day.  Those are sort of\n",
       "the unstated presumptions of something being good.\n",
       "\n",
       "But it ends up that if you build large elaborate stateful programs it\n",
       "is _extremely_ difficult to ascertain whether or not they are going to\n",
       "do what they are supposed to do.\n",
       "\n",
       "And in fact, if you build any one of those things, if you just build a\n",
       "very large program, or a very elaborate program, or a very stateful\n",
       "program, it will be as hard to figure out if it is going to do what it\n",
       "is supposed to do.\n",
       "\n",
       "So one of the things Clojure is oriented at is making it easier to\n",
       "understand whether or not your program is going to do what it is\n",
       "supposed to do, mostly by making it substantially smaller, and also by\n",
       "making it more functional.\n",
       "\n",
       "\n",
       "[Time 0:07:43]\n",
       "\n",
       "```\n",
       "slide title: Meets Operational\n",
       "               Requirements\n",
       "\n",
       "+ Deployment/environment   [first two bullets circled in red]\n",
       "                           Shared with Java/JavaScript host\n",
       "+ Security\n",
       "\n",
       "+ Performance\n",
       "\n",
       "+ Etc.\n",
       "```\n",
       "\n",
       "In terms of operational requirements, there is a boatload of things.\n",
       "There are a boatload of unstated requirements of software.  Two are:\n",
       "can I deploy it in the normal way with all my stuff, with the people\n",
       "who know how to run my machines and everything else?\n",
       "\n",
       "And that is one of the targets of Clojure.  Clojure was meant to be\n",
       "hosted.  It is just a JAR.  It runs in the environment.  It is easy to\n",
       "sneak in.  Let us just add this.  One more JAR.  And then we are\n",
       "running.\n",
       "\n",
       "But it is not a small thing.  If you wanted to adopt Common Lisp, say,\n",
       "or Haskell, you would be asking your ops team and your deployment team\n",
       "to start manipulating something completely alien, whose\n",
       "characteristics they do not understand.\n",
       "\n",
       "In terms of security, everything that is available from the JVM for\n",
       "security is available via Clojure.  And there are performance and\n",
       "other concerns.\n",
       "\n",
       "A very important thing, though, is that now we can also reach the\n",
       "browser.  So I think -- how many people write applications where some\n",
       "part of the overall system touches a browser?  Yeah.  So right now you\n",
       "use two different things.  Almost definitely, you use two different\n",
       "things.  And I think it is a strength of Clojure that we are\n",
       "delivering the same value proposition in both places, both on the\n",
       "server and in the client.  And even if they are separate devs the\n",
       "value proposition is necessary.  And almost more so in the browser,\n",
       "which is one of the most complex places ever.\n",
       "\n",
       "\n",
       "[Time 0:09:10]\n",
       "\n",
       "![0:09:10](ClojureMadeSimple/benchmarksgame-chart.png)\n",
       "\n",
       "[http://benchmarksgame.alioth.debian.org/u64q/benchmark.pgp?test=all&lang=all&data=u64q](http://benchmarksgame.alioth.debian.org/u64q/benchmark.pgp?test=all&lang=all&data=u64q)\n",
       "\n",
       "[ The URL is obsolete as of 2018-Feb-10, and even about a year before\n",
       "that, as the Benchmarks Game web site stopped including Clojure\n",
       "programs in its published data. ]\n",
       "\n",
       "In terms of performance, a lot of times you might look at a dynamic\n",
       "language and say, \"how could it be ...\" whatever?  But Clojure is right\n",
       "down there with the fast languages, on admittedly, the benchmark game,\n",
       "which is a benchmark and a game.  But it says we can reach that.\n",
       "\n",
       "\n",
       "[Time 0:09:30]\n",
       "\n",
       "![0:09:30](ClojureMadeSimple/todomvc-benchmark-chart.png)\n",
       "```\n",
       "Om (ClojureScript lib) on browser ToDoMVC Benchmark\n",
       "```\n",
       "[http://vuejs.org/perf/](http://vuejs.org/perf/)\n",
       "\n",
       "[ As of 2018-Feb-10 that page no longer shows measurement results.  It\n",
       "has some text explaining why they took down the measurements.  It was\n",
       "not any reason that was specific to Om or any of the other frameworks.\n",
       "They seemed to believe that the measurements were not as relevant to\n",
       "the experience that browser users saw, as they originally intended to\n",
       "measure. ]\n",
       "\n",
       "On JavaScript we have a very interesting result here.  Om is a\n",
       "ClojureScript library.  ClojureScript is Clojure on JavaScript,\n",
       "and Om is a library that actually wraps React, which is the new\n",
       "hotness.\n",
       "\n",
       "What is the really interesting things here?  Om wraps React, and then\n",
       "spanks it in performance.  How is that possible?  It ends up that Om's\n",
       "use of persistent data structures, which I will talk about in a\n",
       "minute, make it faster than React, because the big part of React is\n",
       "doing change detection.  And change detection for immutable things is\n",
       "identity comparison, so it is super fast.\n",
       "\n",
       "And in fact, they are re-architecting their whole thing to use\n",
       "persistent data structures in JavaScript now.  The React dev came up\n",
       "to me at Strange Loop, shook my hand and said, \"You are saving us a\n",
       "ton of money, because we are switching to that strategy.\"\n",
       "\n",
       "\n",
       "[Time 0:10:29]\n",
       "\n",
       "```\n",
       "slide title: Flexibility\n",
       "\n",
       "+ Ability to accommodate _inevitable_ change\n",
       "\n",
       "+ _Loose coupling_ is key\n",
       "```\n",
       "\n",
       "So the other part of the value proposition I said was flexibility.\n",
       "People that have a stake in software know that they are building a\n",
       "system now, but tomorrow things are going to change.  Requirements are\n",
       "going to change.  We are going to have to do something different.\n",
       "Change is inevitable.  So can we change the program?  Can we make it\n",
       "more flexible?\n",
       "\n",
       "And it ends up there is a lot we can learn from bigger system design,\n",
       "in the small, to make the sub components of systems more flexible.\n",
       "And of course this is the oldest thing, right?  Loose coupling.  But\n",
       "we talk and talk and talk about it, and we continue to use techniques\n",
       "that thwart it.  Like, every single day, you pull out a technique.\n",
       "You do something that makes this harder.\n",
       "\n",
       "So what makes it easier?\n",
       "\n",
       "\n",
       "[Time 0:11:16]\n",
       "\n",
       "```\n",
       "slide: \n",
       "\n",
       "\"With Clojure we get to market faster and with\n",
       "better quality.  We avoid unintended interruptions\n",
       "in Java apps when code in one area impacts the\n",
       "            application in another.\"\n",
       "\n",
       "\"Clojure shrinks our code base to about one-fifth\n",
       "the size it would be if we had written in Java.\"\n",
       "\n",
       "              Anthony Marcar -\n",
       "        Senior Architect, WalmartLabs\n",
       "```\n",
       "\n",
       "So my talk was done, and somebody said, \"You know, I have this quote\n",
       "from Walmart Labs guy.  You might want to put it in your talk.\"  And\n",
       "it was like: wow, this is great!  Because he is telling my story.\n",
       "\n",
       "With Clojure we get to market faster and with better quality.  We\n",
       "avoid unintended interruptions in Java apps from code in one area\n",
       "impacts the application in another.  Clojure shrinks our code base to\n",
       "about one-fifth the size it would have, had we written in Java.\n",
       "\n",
       "And these are the points of my talk.  This is what I want.  This is a\n",
       "stakeholder saying, \"this is what we get by choosing Clojure.\"  Faster\n",
       "time to market, better quality.  We avoid coupling problems that make\n",
       "it difficult for us to change.  And we have a smaller code base.\n",
       "\n",
       "\n",
       "[Time 0:12:05]\n",
       "\n",
       "```\n",
       "slide title: How?\n",
       "\n",
       "+ Data orientation\n",
       "\n",
       "+ Simplicity\n",
       "\n",
       "What matters is not just what a programming\n",
       "language makes possible, but what it makes\n",
       "         _practical_ and _idiomatic_.\n",
       "```\n",
       "\n",
       "So how does Clojure do this?  There are many, many different\n",
       "characteristics to Clojure, but I only want to talk about sort of two\n",
       "today, and mostly one.\n",
       "\n",
       "One is, and because this is the one I think that sets Clojure apart.\n",
       "It makes it somewhat different, is that it has data orientation,\n",
       "through and through.  And the other is simplicity.\n",
       "\n",
       "So when I say simplicity, I mean the opposite of complexity.  I do not\n",
       "mean ease.  I do not mean Clojure is an easy language.  That is easy,\n",
       "you type and everything magically happens, or some sort of easiness\n",
       "metric.\n",
       "\n",
       "Complex things are intertwined, and simple things are not.  They are\n",
       "more independent.  They are separate.  Even if they have as many\n",
       "things going on, this is simpler than this.  Four things like this is\n",
       "complex, and four things like this is simple. [probably gesturing with\n",
       "his hands, but it does not show in the video]\n",
       "\n",
       "So that is what I mean when I say simple.  Unentangled.\n",
       "\n",
       "So the thing is, that you know all these languages can do everything.\n",
       "We can do the same stuff.  And people are like: I know I can do the\n",
       "same stuff in C# and Java and Scala and Clojure, and any\n",
       "general-purpose language.  You can accomplish the same things at the\n",
       "end of the day.\n",
       "\n",
       "So what differentiates languages is what they make practical and what\n",
       "they make idiomatic.  And in Clojure we focused on making something\n",
       "idiomatic that I think is _not_, and should be more so.\n",
       "\n",
       "\n",
       "[Time 0:13:31]\n",
       "\n",
       "```\n",
       "slide title: Data Processing\n",
       "\n",
       "+ Not a dirty word (nor two)\n",
       "\n",
       "+ Most programs acquire, transform, store,\n",
       "  search, manage, transmit data\n",
       "\n",
       "+ Data is raw, immutable information\n",
       "\n",
       "+ Many langs turn into something much more\n",
       "  elaborate - with types, 'methods' etc\n",
       "\n",
       "  esp. OO conflates _process_ constructs and\n",
       "  _information_ constructs\n",
       "```\n",
       "\n",
       "That is this.  Before we had all this high falutin' opinions of\n",
       "ourselves as programmers and computer scientists and stuff like that,\n",
       "programming used to be called data processing.\n",
       "\n",
       "How many people actually do data processing in their programs?  You\n",
       "can raise your hands.  We all do, right?  This is what most programs\n",
       "do.  You take some information in, somebody typed some stuff, somebody\n",
       "sends you a message, you put it somewhere.  Later you try to find it.\n",
       "You put it on the screen.  You send it to somebody else.\n",
       "\n",
       "That is what most programs do most of the time.  Sure, there is a\n",
       "computational aspect to programs.  There is quality of implementation\n",
       "issues to this, but there is nothing wrong with saying: programs\n",
       "process data.  Because data is information.  Information systems ...\n",
       "this should be what we are doing, right?\n",
       "\n",
       "We are the stewards of the world's information.  And information is\n",
       "just data.  It is not a complex thing.  It is not an elaborate thing.\n",
       "It is a simple thing, until we programmers start touching it.\n",
       "\n",
       "So we have data processing.  Most programs do this.  There are very\n",
       "few programs that do not.\n",
       "\n",
       "And data is a fundamentally simple thing.  Data is just raw immutable\n",
       "information.  So that is the first point.  Data is immutable.  If you\n",
       "make a data structure, you can start messing with that, but actual\n",
       "data is immutable.  So if you have a representation for it that is\n",
       "also immutable, you are capturing its essence better than if you start\n",
       "fiddling around.\n",
       "\n",
       "And that is what happens.  Languages fiddle around.  They elaborate on\n",
       "data.  They add types.  They add methods.  They make data active.\n",
       "They make data mutable.  They make data movable.  They turn it into an\n",
       "agent, or some active thing.  And at that point they are ruining it.\n",
       "At least, they are moving it away from what it is.\n",
       "\n",
       "And in object orientation I think this is rampant, because our\n",
       "fundamental construct, the object, conflates two things.  It does not\n",
       "give us two separate ways to talk about _process_, for which objects\n",
       "are an OK approach, and _information_, for which they are a terrible,\n",
       "terrible, terrible approach.\n",
       "\n",
       "But every time we have a problem, we pull out an object.  We make a\n",
       "new object.  We make a new class.  We make a new instantiation of\n",
       "something.  And this makes our programs more about themselves again,\n",
       "and less about the information.  Programs are more increasingly about\n",
       "code, and decreasingly about data.  And I think that is a mistake.\n",
       "\n",
       "\n",
       "[Time 0:16:04]\n",
       "\n",
       "```\n",
       "slide title: Data\n",
       "\n",
       "+ Clojure embraces data\n",
       "\n",
       "+ Data literals\n",
       "\n",
       "+ Code is data\n",
       "\n",
       "+ Majority of functions take/return data\n",
       "\n",
       "+ _Information_ is represented in Clojure\n",
       "  systems as _plain data_\n",
       "```\n",
       "\n",
       "So Clojure embraces data.  That is like the simplest idea behind\n",
       "Clojure.  It is just: there is nothing wrong with data.  Data has\n",
       "these great properties.  Let us use it.  In fact, let us make it a\n",
       "really important, first class, in your face kind of thing.\n",
       "\n",
       "So Clojure embraces it first and foremost by having strong data\n",
       "literals, which I will show you in a minute.  And they are plain.\n",
       "Plain.  It just means flat, level, unadorned, no extra stuff.\n",
       "\n",
       "Code, and this is an old Lisp thing, in Clojure is represented as\n",
       "data.  That is important for a lot of reasons.  It enables macros and\n",
       "a lot of sophisticated program transformation things.  But it also\n",
       "means that you do not have different stuff.\n",
       "\n",
       "The majority of functions in Clojure just take data, and by data I\n",
       "mean immutable, unadorned stuff, and they return that same thing.  A\n",
       "giant library of functions.  Hundreds and hundreds and hundreds of\n",
       "data manipulation functions, ready to go.  They take data.  They\n",
       "return data.\n",
       "\n",
       "So if you have anything that is data, you can use all those functions\n",
       "on it, which tends to press you towards making everything data.\n",
       "Because then you have this giant library, which you learn once, and\n",
       "you can apply to every problem you have.  And in particular, every\n",
       "time we encounter information in Clojure systems -- because there are\n",
       "different parts of systems.  There is a part of your system that\n",
       "manipulates information.  There is a part of your system that is sort\n",
       "of plumbing, or the machinery of your program, like a socket or\n",
       "communications endpoint -- is more like a machine than it is like\n",
       "information.  So there are going to be active parts of your program.\n",
       "\n",
       "But whenever you are dealing with the part of your program that is\n",
       "just about representing facts and information, we will always in\n",
       "Clojure choose plain data to do that.\n",
       "\n",
       "\n",
       "[Time 0:17:51]\n",
       "\n",
       "```\n",
       "slide title: Atomic Data Types\n",
       "\n",
       "+ Integers - 12345678987654\n",
       "\n",
       "+ Doubles 1.234 , BigDecimals 1.234M\n",
       "\n",
       "+ Ratios - 22/7\n",
       "\n",
       "+ Strings - \"fred\" , Characters - \\a \\b \\c\n",
       "\n",
       "+ Symbols - fred ethel , Keywords - :fred :ethel\n",
       "\n",
       "+ Booleans - true false , Null - nil\n",
       "\n",
       "+ Regex patterns #\"a*b\"\n",
       "```\n",
       "\n",
       "So there is a small set of data literals in Clojure.  They are\n",
       "relatively obvious.  You can write integers in the normal way, and\n",
       "doubles the normal way, and BigDecimals with an M at the end.  There\n",
       "are ratios, and these are proper ratios that do not lose precision.\n",
       "\n",
       "Strings are in double quotes, and strings are java.lang.String.  When\n",
       "you write that you get a java.lang.String, and so it is just a literal\n",
       "for a string.  There are literals for characters.\n",
       "\n",
       "Because we use data structures for programming, there are a couple of\n",
       "extra things we need.  But if you look at Java code, is it written all\n",
       "with quotes around every word?  No.  So Java needs something besides\n",
       "strings in order to be a successful programming language.  It needs\n",
       "symbols.  And it needs identifiers.\n",
       "\n",
       "So if you are going to properly represent your code as data, those\n",
       "things have to be first-class data structures, or atomic data types,\n",
       "that are different from strings.  So there are two in Clojure.  One\n",
       "are symbols, and the other are keywords.  And their use in Clojure,\n",
       "which I am not going to dive into, is that symbols are generally used\n",
       "to reference something else.  So like variables and things like that.\n",
       "They name something.\n",
       "\n",
       "And keywords name themselves.  They are more like enums, if you want.\n",
       "They are very useful as keys in maps, for instance, and that is why\n",
       "they are called that.\n",
       "\n",
       "There are true and false Boolean literals.  And there is nil, which is\n",
       "null.  And it is the same.  That is the Java null.  And those Booleans\n",
       "are Java Booleans.  Those characters are Java characters, etc. etc.\n",
       "And there are also literals for regex.\n",
       "\n",
       "\n",
       "[Time 0:19:31]\n",
       "\n",
       "```\n",
       "slide title: Data Structures\n",
       "\n",
       "+ Lists - singly linked, grow at front\n",
       "\n",
       "  + (1 2 3 4 5), (fred ethel lucy), (list 1 2 3)\n",
       "\n",
       "+ Vectors - indexed access, grow at end\n",
       "\n",
       "  + [1 2 3 4 5], [fred ethel lucy]\n",
       "\n",
       "+ Maps - key/value associations\n",
       "\n",
       "  + {:a 1, :b 2, :c 3}, {1 \"ethel\" 2 \"fred\"}\n",
       "\n",
       "+ Sets #{fred ethel lucy}\n",
       "\n",
       "+ Everything nests\n",
       "```\n",
       "\n",
       "And then we have data structures.  Some fundamental data structures.\n",
       "\n",
       "We have the singly linked list.  It is in parens.  Those are all lists\n",
       "there: a list of numbers, a list of symbols, a list that has a symbol\n",
       "and then some numbers.  That is OK.  It can be heterogeneous.  And\n",
       "they grow at the front, and they have linked list kind of performance\n",
       "characteristics, which means it is fast to put something at the front,\n",
       "and it is slow to find the 57000-th thing.  It is linear time to find\n",
       "stuff in the middle.\n",
       "\n",
       "Then we have vectors.  They are in square brackets.  Again, they can\n",
       "be heterogeneous.  This happens to be one with numbers, and one with\n",
       "symbols, but you can intermix them.  They grow at the end in constant\n",
       "time, but they also offer fast access anywhere in the middle.  So they\n",
       "are different from linked lists, then.\n",
       "\n",
       "And then there are maps.  They are key value, key value, key value.\n",
       "The commas are optional.  The keys need not be keywords.  So this\n",
       "first one uses keywords mapping to integers, and the second one uses\n",
       "integers mapping to strings.  But you can be heterogeneous in both the\n",
       "key and the value.\n",
       "\n",
       "And then we have sets, which are just curlies preceded by a hash.  And\n",
       "you can have sets, again, heterogeneous of anything.\n",
       "\n",
       "And all of the stuff nests.\n",
       "\n",
       "One of the important things about this is that these maps, they scale\n",
       "and are efficient from the very small, all the way to the very large.\n",
       "So you can use them as sort of pseudo objects in the small, and have\n",
       "four or five fields, if you will, or entries.  Or you can have a giant\n",
       "map that has millions, tens of millions, hundreds of millions of\n",
       "things in it.  The same data structure is used throughout that range\n",
       "in Clojure.  We do not distinguish those two uses at all.\n",
       "\n",
       "\n",
       "[Time 0:21:11]\n",
       "\n",
       "```\n",
       "slide title: Persistent Data\n",
       "               Structures\n",
       "\n",
       "+ Immutable\n",
       "\n",
       "+ Can make new 'modified' versions while\n",
       "  keeping standard performance expectations\n",
       "\n",
       "  i.e. not copy-on-write\n",
       "\n",
       "+ Key to practical functional programming\n",
       "```\n",
       "\n",
       "So all of the data structures I showed you are immutable.  There is no\n",
       "way to change them.  Just like there is no way to change 42, there is\n",
       "no way to change a vector.  What you can do is make a new vector that\n",
       "is slightly different from the vector you started with, and then you\n",
       "have both vectors.\n",
       "\n",
       "And there is a technique called persistent data structures, which\n",
       "makes this making of a new slightly different version efficient.  The\n",
       "two versions will have a substantial amount of structural sharing\n",
       "going on under the hood.  And that is possible _because_ they are\n",
       "immutable.  They can share structure because no one can change them.\n",
       "And that is what makes it practical to use immutable data structures\n",
       "all the way through the range, from tiny things through very very\n",
       "large things.\n",
       "\n",
       "It is _not_ copy-on-write.  These new modifications that you make\n",
       "still comply with the big O expectations you have for the data\n",
       "structure in hand.  And this is the key to practical functional\n",
       "programming, is having this.\n",
       "\n",
       "\n",
       "[Time 0:22:13]\n",
       "\n",
       "```\n",
       "slide title: The Clojure Premise\n",
       "\n",
       "+ We can build a substantial portion of our\n",
       "  programs using just the data structures above\n",
       "  and pure functions thereof\n",
       "\n",
       "+ These programs will be substantially smaller,\n",
       "  simpler and more robust than OO programs\n",
       "  that do the same jobs\n",
       "\n",
       "+ So, we should make that idiomatic\n",
       "```\n",
       "\n",
       "So the idea behind Clojure, or one of the ideas behind Clojure, is\n",
       "just this.  I had done so much object-oriented programming, and it is\n",
       "just so much busy work and so much extra stuff.  And when I finally,\n",
       "later in my career, learned Lisp, I saw people building very very\n",
       "interesting systems out of much much simpler stuff.  And I tried it,\n",
       "and guess what?\n",
       "\n",
       "You can build exactly the same systems out of much much simpler stuff.\n",
       "And I said -- well, I cannot repeat it.  But I was very unhappy.\n",
       "Basically, something to the effect of: I have been wasting my time and\n",
       "my career doing what I have been doing.  I need to do something.  I\n",
       "need to change what I am doing.  Because I am wasting my time.  I am\n",
       "wasting my life doing it this way.\n",
       "\n",
       "Because you can build programs, the same programs, better programs,\n",
       "that do the same things with substantially simpler stuff.  In fact,\n",
       "you can build them out of the data structures I just showed you, plus\n",
       "pure functions that take those things and return those things.  _Most_\n",
       "of your program, you can build that way.\n",
       "\n",
       "In little tiny bits of your program you will have state.  You will\n",
       "have communication.  You will have the other aspects.\n",
       "\n",
       "I like runtime polymorphism, and Clojure has it.  I will talk about it\n",
       "in a second.  But you can build programs out of this.  And you can\n",
       "build big programs out of it.  You can build databases out of it.  I\n",
       "have done it.  I have built a database out of it.  When I made\n",
       "Clojure, I was targeting being able to do everything that I used to do\n",
       "in Java and C++.  So I built broadcast automation systems, scheduling\n",
       "systems, yield management systems, election projection systems, and\n",
       "exit poll systems, in all those: C++ and Java and C#.\n",
       "\n",
       "I believe that I could have used Clojure to build anything I ever\n",
       "built, with maybe a _tiny_ little bit of lower-level code in small\n",
       "places.  But that is the target for Clojure.  I wanted to replace what\n",
       "I was doing.\n",
       "\n",
       "I think the programs _are_ substantially smaller.  They are simpler,\n",
       "and they are _much_ more robust than the object oriented programming I\n",
       "was doing to accomplish the same jobs.  So the idea behind Clojure is:\n",
       "let us make that idiomatic.  Let us make that the first class way we\n",
       "do things.\n",
       "\n",
       "\n",
       "[Time 0:24:19]\n",
       "\n",
       "```\n",
       "slide title: Syntax\n",
       "\n",
       "+ You've just seen it (edn)\n",
       "\n",
       "+ Data structures _are_ the code\n",
       "\n",
       "+ Not text-based syntax\n",
       "\n",
       "  + Syntax is in the interpretation of data structures\n",
       "\n",
       "+ Things that would be declarations, control\n",
       "  structures, function calls, operators, are all just lists\n",
       "  with op at front\n",
       "\n",
       "+ Everything is an expression\n",
       "```\n",
       "\n",
       "So the syntax of Clojure, there is no more.  You just saw it.  It is\n",
       "those data structures.  That set of data structures, and those\n",
       "fundamental things, are a format called edn, which stands for\n",
       "\"extensible data notation\".  But it is just a grown up version of\n",
       "S-expressions, which have been used in the Lisp community for years.\n",
       "Basically you build programs out of data structures, and I will show\n",
       "you some of that in a second.\n",
       "\n",
       "So the data structures are the code.  The syntax is not based around\n",
       "characters.  It is based around data structures.  The definition of\n",
       "what a function is, is a list whose head is a symbol called \"fn\", and\n",
       "whose next thing in the list is a vector of arguments, which are\n",
       "themselves symbols, etc. etc. etc.\n",
       "\n",
       "But the syntax is described in terms of data structures.  It is not\n",
       "like there is no syntax, but that is where the interpretation happens.\n",
       "And everything that would be special in an ordinary programming\n",
       "language: declarations, control structures, function calls, operators,\n",
       "etc. etc. they are _all_ just represented as lists with the verb at\n",
       "the front.  That is it.  That is the Lisp way.\n",
       "\n",
       "Also everything is an expression.  And that is typical of functional\n",
       "programming languages.  That is about all I am going to say about\n",
       "Clojure the language.\n",
       "\n",
       "\n",
       "[Time 0:25:39]\n",
       "\n",
       "```\n",
       "slide title: edn - extensible data\n",
       "                   notation\n",
       "\n",
       "+ meant to be useful for data _and_ code\n",
       "\n",
       "+ unlike XML and JSON\n",
       "\n",
       "{\n",
       "  \"Fn::Base64\": {\n",
       "    \"Fn::Join\": [\"\", [\"#!/bin/bash -ex\", \"\\n\", \"\\n\",\n",
       "                      \"yum install ec2-net-utils -y\", \"\\n\"\n",
       "                      \"ec2ifup eth1\", \"\\n\",\n",
       "                      \"service httpd start\"]]\n",
       "  }\n",
       "}\n",
       "```\n",
       "\n",
       "But I am going to show you a lot more about the use of these aspects\n",
       "of it.  I have a little bit more later.\n",
       "\n",
       "So edn, this extensible data notation.  I showed you some built-in\n",
       "things.  There is also a way to extend it to add new tags, that are\n",
       "namespaced, that allow you to describe something new, in terms of\n",
       "anything that is already known.\n",
       "\n",
       "So you cannot make up arbitrary stuff.  You cannot say, \"we will build\n",
       "a new parser to parse characters and get this thing\".  But you can\n",
       "say, \"I have a new interpretation of a vector of two numbers, and we\n",
       "are going to call that a point.\"  And so on and so forth.  And you can\n",
       "cascade these extensions and build richer things.\n",
       "\n",
       "But one of the important things about edn is: it is meant to be useful\n",
       "for data and code.  So you saw in a previous slide I said commas are\n",
       "optional.  That is kind of critical.  Imagine if in between everything\n",
       "you said in Java you had to put a comma.  Who would like that?  That\n",
       "would be awful.  So you cannot have stuff like that.  How many people\n",
       "have ever used any system that tried to encode programming in JSON or\n",
       "XML?  Yeah, how fun is that?\n",
       "\n",
       "[Audience member: It stinks.]\n",
       "\n",
       "Yeah.\n",
       "\n",
       "So this is a little bit of ...  AWS cloud formation has some functions\n",
       "in their syntax, which is normally declarative.  So this is a nested\n",
       "function call.  But you cannot do this.  You cannot program like this.\n",
       "So if you are going to program using data structures, you have to have\n",
       "a data structure format that is amenable to that.\n",
       "\n",
       "\n",
       "[Time 0:27:05]\n",
       "\n",
       "```\n",
       "slide title: Data as Program\n",
       "\n",
       "; Norvig's Spelling Corrector in Clojure\n",
       "; http://en.wikibooks.org/wiki/Clojure_Programming#Examples\n",
       "\n",
       "(defn words [text] (re-seq #\"[a-z]+\" (.toLowerCase text)))\n",
       "\n",
       "(defn train [features]\n",
       "  (reduce (fn [model f] (assoc model f (inc (get model f 1))))\n",
       "          {} features))\n",
       "\n",
       "(def *nwords* (train (words (slurp \"big.txt\"))))\n",
       "\n",
       "(defn edits1 [word]\n",
       "  (let [alphabet \"abcdefghijklmnopqrstuvwxyz\", n (count word)]\n",
       "    (distinct (concat\n",
       "      (for [i (range n)] (str (subs word 0 i) (subs word (inc i))))\n",
       "      (for [i (range (dec n))]\n",
       "        (str (subs word 0 i) (nth word (inc i)) (nth word i) (subs word (+ 2 i))))\n",
       "      (for [i (range n) c alphabet] (str (subs word 0 i) c (subs word (inc i))))\n",
       "      (for [i (range (inc n)) c alphabet] (str (subs word 0 i) c (subs word i)))))))\n",
       "\n",
       "(defn known [words nwords] (for [w words :when (nwords w)]  w))\n",
       "\n",
       "(defn known-edits2 [word nwords]\n",
       "  (for [e1 (edits1 word) e2 (edits1 e1) :when (nwords e2)]  e2))\n",
       "\n",
       "(defn correct [word nwords]\n",
       "  (let [candidates (or (known [word] nwords) (known (edits1 word) nwords) \n",
       "                       (known-edits2 word nwords) [word])]\n",
       "    (apply max-key #(get nwords % 1) candidates)))\n",
       "```\n",
       "\n",
       "So this is what Clojure looks like.  I do not really expect you to be\n",
       "able to read it.  But I just told you before, that is a list.\n",
       "\n",
       "\"defn\", it defines a function.  The name of the function is \"words\".\n",
       "It takes an argument called \"text\".  And there is the implementation.\n",
       "And so on, and so on, and so forth.\n",
       "\n",
       "So this is a port of Peter Norvig's Python code.  It is as short as\n",
       "the Python program.  And that is not like a contest.  It is more about\n",
       "this: everything that is in here is about the problem.  All the words\n",
       "you are reading, and everything, it is all about the problem.  There\n",
       "is no extra stuff.  There is no static, import, blah, type this, type\n",
       "that, yada ya, extra control stuff.  It is all about the problem.\n",
       "100% about the problem.\n",
       "\n",
       "And that is what you want.  So it is short.  It is free of ceremony.\n",
       "But most important is: it is about the problem, which means it is a\n",
       "lot easier to look at now, and later, and see what you were trying to\n",
       "do.  What you are trying to accomplish.\n",
       "\n",
       "\n",
       "[Time 0:28:12]\n",
       "\n",
       "```\n",
       "slide title: Data as HTML\n",
       "             (Hiccup DSL)\n",
       "\n",
       "[:html\n",
       "    [:head\n",
       "      [:title title]]\n",
       "    [:body\n",
       "      [:h1 title]\n",
       "      [:h2 (str \"By \" author)]\n",
       "      (for [post posts]\n",
       "        [:article\n",
       "\t  [:h3 (:title post)]\n",
       "\t  [:p (:content post)]])]]\n",
       "```\n",
       "\n",
       "So once we have this format edn, and we use it for code, and we can\n",
       "obviously use it for data, you use it for everything.  So let us say\n",
       "you want to have a DSL to represent HTML.  Because we know HTML on its\n",
       "own is kind of gross to generate and manipulate.  Because it is XML\n",
       "plus some randomness.\n",
       "\n",
       "So this is one of many DSLs for representing HTML in Clojure.  But it\n",
       "is edn.  This is the same stuff that the program was made out of.  The\n",
       "same reader reads this.  If I call \"read\", which is available a la\n",
       "carte in Clojure, I get a vector that has a keyword, then a vector\n",
       "that has a keyword, a vector, blah blah blah.\n",
       "\n",
       "I get data.  I know exactly what I am gonna get, the data structures I\n",
       "am going to get.  I don't have a special thing.  I don't have a DOM,\n",
       "blah blah blah.  I get data when I read this.  And that is great.  It\n",
       "means it is easy for me to process this.  It is easy for me to write a\n",
       "program that produces this.  So I can produce HTML without an extra\n",
       "special different thing.\n",
       "\n",
       "\n",
       "[Time 0:29:09]\n",
       "\n",
       "```\n",
       "slide title: Data as Config\n",
       "\n",
       "(defproject hiccup \"1.0.5\"\n",
       "  :description \"A fast library for rendering HTML in Clojure\"\n",
       "  :url \"http://github.com/weavejester/hiccup\"\n",
       "  :dependencies [[org.clojure/clojure \"1.2.1\"]]\n",
       "  :plugins [[codox \"0.7.4\"]]\n",
       "\n",
       "  :profiles\n",
       "  {:1.3 {:dependencies [[org.clojure/clojure \"1.3.0\"]]}\n",
       "   :1.4 {:dependencies [[org.clojure/clojure \"1.4.0\"]]}\n",
       "   :1.5 {:dependencies [[org.clojure/clojure \"1.5.1\"]]}})\n",
       "```\n",
       "\n",
       "Of course we would use this for our configuration files.  Why not?  We\n",
       "can read it.  We can generate it.  We can process it.  We can\n",
       "manipulate it.  Everything we know, all those hundreds of functions we\n",
       "know how to do, we can use to do this.\n",
       "\n",
       "Now add up the stuff in Java.  How much have you got?  You have syntax\n",
       "for which you use I do not know what.  Some parser thingy for that,\n",
       "from javac or something, to manipulate.  You have annotations.  You\n",
       "have JSON here.  You have XML there.  Maybe for writing your own DSL\n",
       "you use ANTLR or something.  It keeps adding up.  More and more and\n",
       "more different things.\n",
       "\n",
       "And if you read stuff with an API, what do you get?  Some API author's\n",
       "idea of the DOM for this kind of thing.  What do you get when you read\n",
       "XML?  Well it depends on how you read it, but you could get this\n",
       "machine that calls you back every time it gets a new element.  Wow.\n",
       "\n",
       "\n",
       "[Time 0:30:03]\n",
       "\n",
       "```\n",
       "slide title: Data as Hadoop Job\n",
       "              (Netflix PigPen)\n",
       "\n",
       "(defn my-data-2 []\n",
       "  (->>\n",
       "    (pig/load-tsv \"input.tsv\")\n",
       "    (pig/map (fn [[a b c]]\n",
       "               {:sum (+ (Integer/valueOf a)\n",
       "\t                (Integer/valueOf b))\n",
       "                :name c}))\n",
       "    (pig/filter (fn [{:keys [sum]}]\n",
       "                  (< sum 5)))))\n",
       "\n",
       "=> (pig/dump (my-data-2))\n",
       "[{:sum 3, :name \"foo\"}]\n",
       "```\n",
       "[https://github.com/Netflix/PigPen](https://github.com/Netflix/PigPen)\n",
       "\n",
       "This is Hadoop programming.  Netflix has quite profitably used Clojure\n",
       "to build a very succinct DSL for doing Hadoop and big data processing.\n",
       "It looks exactly like Clojure.  It is Clojure, sort of embedded in\n",
       "Clojure.\n",
       "\n",
       "And the thing is, you can run this locally, and then push a button,\n",
       "and it will distribute it over your Hadoop cluster and run it there.\n",
       "Same thing.  And you can run your own Clojure functions there, too,\n",
       "and it will ship them and everything else.\n",
       "\n",
       "\n",
       "[Time 0:30:34]\n",
       "\n",
       "```\n",
       "slide title: More via Data ...\n",
       "\n",
       "+ Type annotations\n",
       "\n",
       "+ Data schemas\n",
       "\n",
       "+ Logic DSLs\n",
       "\n",
       "  + core.logic\n",
       "\n",
       "  + Datalog\n",
       "\n",
       "  + Cascalog\n",
       "\n",
       "+ Your (embedded) DSL\n",
       "```\n",
       "\n",
       "So we just do this.  We do this everywhere.  Everywhere we want.\n",
       "There is a type annotation system for Clojure that uses data.  There\n",
       "is a schema language for Clojure that uses data.  There are many kinds\n",
       "of logic DSLs that all use data as their representation.\n",
       "\n",
       "And this allows you to do something that is very interesting, which is\n",
       "to write an embedded DSL.  How many people have written a DSL, and had\n",
       "more and more pressure to make it Turing complete and general-purpose?\n",
       "\n",
       "You start with a DSL and it did X and Y.  And then people ask: could\n",
       "you do Z?  Could you have conditionals?  Could you have case?  Could\n",
       "you have, ugh!  They always want more stuff.\n",
       "\n",
       "So one of the cool things about doing DSLs in a language like Clojure\n",
       "is that you can sort of co-opt all of Clojure inside your DSL.  It is\n",
       "like, oh, you want to do arithmetic?  Well sure!  All you have to do\n",
       "is expose something that you are going to flow through to Clojure and\n",
       "let Clojure eval it.  So it is very powerful.  You keep doing this.\n",
       "\n",
       "The other big point of programs as data is: it allows you to write\n",
       "program-generating programs, and that takes a few forms in the small.\n",
       "There is a capability in Clojure and other Lisps called macros.  They\n",
       "are nothing like C macros from your past, maybe, depending on how old\n",
       "you are.\n",
       "\n",
       "They are functions of data structures to data structures.  But\n",
       "basically the compiler for Clojure says: if you declare something as a\n",
       "macro, then if I see that in the program, I will call your code.  I\n",
       "will give you the form, as data, that I encountered, and you give me\n",
       "back a different form.\n",
       "\n",
       "You can do any transformation you want, which means you can build your\n",
       "own syntax.  You can build your own constructs.  You can extend the\n",
       "language however you want.  You do not need to wait for me, or for\n",
       "anybody else, or for the Java JSR, whatever.  You just go.\n",
       "\n",
       "So we are doing all this stuff with raw data structures, and how do we\n",
       "contrast that with objects?\n",
       "\n",
       "\n",
       "[Time 0:32:33]\n",
       "\n",
       "```\n",
       "slide title: <rant> Objects are like\n",
       "                 Marionettes\n",
       "\n",
       "[ Stick figure drawing of a marionette, i.e. a person-shaped puppet on\n",
       "strings, with sticks at the top that a puppeteer would hold and use to\n",
       "control the marionette. ]\n",
       "```\n",
       "\n",
       "This is the ranty part of the talk.  Just warning in advance.\n",
       "\n",
       "So objects are like marionettes.  Everybody has their burrito analogy,\n",
       "but I could not.  Objects are not like burritos.  Objects are like\n",
       "marionettes.\n",
       "\n",
       "They have all these methods on them.  And anybody who has access to\n",
       "the object, it is like they have that control stick thing.  Wikipedia\n",
       "says that the person who has that is called the master minder.\n",
       "\n",
       "I could not find anybody else who agree with them, but that is a cool\n",
       "name.  Like you can remote control the object, which you can.  If you\n",
       "have a reference to the object, and you know its type, you can call\n",
       "any of its methods whenever you feel like it, in whatever thread you\n",
       "want.  Just have at it.  You can do anything you want, because you can\n",
       "call those things.\n",
       "\n",
       "So whoever writes the object, the class, they have to defend against\n",
       "that.  Because what is going to happen?\n",
       "\n",
       "\n",
       "[Time 0:33:25]\n",
       "\n",
       "```\n",
       "slide title: More Refs, More\n",
       "               Uncertainty\n",
       "\n",
       "[ Similar stick figure drawing as previous slide, with same\n",
       "marionette, but with sad face, and multiple sets of strings attached\n",
       "to it, controlled from 3 different sets of control sticks. ]\n",
       "```\n",
       "\n",
       "Well in a real program, you are going to start passing around\n",
       "references that object.  Well now you have more than one master\n",
       "minder.  Now you have as many master minders as you have shared\n",
       "references to the thing.\n",
       "\n",
       "And anybody can call something at any time.  And what do you end up\n",
       "doing?  You end up saying, well maybe they are friends and they are\n",
       "standing next to each other, and they are like: OK, let us make the\n",
       "fancy horse dance, and I will do the front legs, and you do the back\n",
       "legs.\n",
       "\n",
       "[Audience laughter.]\n",
       "\n",
       "And that happens in puppetry, but in programming sometimes they just\n",
       "go off, and somebody is trying to make the front of the horse go this\n",
       "way, and somebody is trying to make the back of the horse go that way.\n",
       "And it does not work.  And so you have to have all kinds of\n",
       "protection.\n",
       "\n",
       "And you cannot.  You actually cannot effectively do this.  Java, and\n",
       "languages like it, do not give you an effective way to do this.  So\n",
       "you are suffering from this, constantly.  As soon as you have a\n",
       "reference leak, you are suffering.\n",
       "\n",
       "Now I know you say, \"Oh, I use value objects\", and blah.  But you\n",
       "don't, everywhere.  You _could_, but you don't.\n",
       "\n",
       "And it is not idiomatic, and it is still hard.  And you still do not\n",
       "even know.  If somebody gives you a reference to an interface, can you\n",
       "know that it will not start dancing on you?  Is there anything in Java\n",
       "that will tell you it is not going to move around?  Any way, any\n",
       "construct, anything in the type system, anything?\n",
       "\n",
       "No!  Nothing.  So every day, you have this unhappy face.\n",
       "\n",
       "\n",
       "[Time 0:34:50]\n",
       "\n",
       "```\n",
       "slide title: Distribution?\n",
       "\n",
       "+ Does anyone still think RMI/DCOM/\n",
       "  CORBA is a good idea?\n",
       "\n",
       "[ Same unhappy face marionette, now with 2 sets of strings in one box,\n",
       "probably representing the local computer system where the\n",
       "object/marionette is, and another set of strings tied to control\n",
       "sticks in another box, representing a different computer system. ]\n",
       "```\n",
       "\n",
       "And then, the final problem.  How many people write a program that is\n",
       "just a program?  It sits by itself, and it reads standard in, and\n",
       "spits to standard out?  Compiler writers write that stuff.  And they\n",
       "write these great languages that are really good at that.\n",
       "\n",
       "But that is not the real world.  How many people write programs that\n",
       "talk to other programs routinely?  Yeah, we do that all the time!\n",
       "\n",
       "How many people put objects on the wire?  Wow!  That is terrifying.\n",
       "But, just so you know, a long time ago we decided that was a bad idea.\n",
       "So I don't know if you got the memo, or whatever.\n",
       "\n",
       "[Audience laughter.]\n",
       "\n",
       "But yeah, objects do not travel on wires.  You can fake it.  You can\n",
       "pretend.  You can make all these elaborate things, but most of these\n",
       "things have have failed in practice.  You can get away with it in\n",
       "small circumstances, but it is not how things work.  We do not\n",
       "actually give somebody a reference to something and allow them to\n",
       "remote-control us.\n",
       "\n",
       "\n",
       "[Time 0:35:52]\n",
       "\n",
       "```\n",
       "slide title: </rant>\n",
       "\n",
       "+ If your API takes an object, will it mutate?\n",
       "\n",
       "  Does your type system help with this most\n",
       "  important robustness aspect?\n",
       "\n",
       "+ If you wanted to refactor out-of-proc (or\n",
       "  even onto another thread), how much work?\n",
       "\n",
       "+ Not the way the world works (ORM, O_M)\n",
       "\n",
       "+ Not the way successful _systems_ work\n",
       "```\n",
       "\n",
       "So this is what I was saying before.  If your API takes an object,\n",
       "especially via a reference to an interface, so you do not have the\n",
       "concrete class's definition to sort of make you feel better about it\n",
       "not changing, do you know if it is going to mutate?  Can your type\n",
       "system help you with this?\n",
       "\n",
       "Which is really, it is _such_ an important thing for the robustness of\n",
       "your program, to control this.  The answer is: no.  You are getting no\n",
       "help at all.  So your default idioms leave you completely on your own\n",
       "to deal with these problems.  And really, in a position that\n",
       "encourages you to create these problems, just by accident.\n",
       "\n",
       "The other thing is ...  So let us say RMI is not allowed at your\n",
       "company.  How many people are not allowed to use RMI at their company?\n",
       "Everybody is allowed to use RMI?  Wow!\n",
       "\n",
       "[Audience member: And we are allowed to use goto's also.]\n",
       "\n",
       "Goto?  Yeah, that is actually not as bad.\n",
       "\n",
       "[Audience laughter.]\n",
       "\n",
       "But let us say you are allowed.  And somebody says: I want you to\n",
       "service-ize your thing.  How many people would _choose_ RMI over\n",
       "something else, like HTTP or _anything_ else?  Nobody would.  And then\n",
       "what do you have to do?  You have this interface.  You said I took an\n",
       "object.  I expected all these methods on the object.  And now I have\n",
       "to talk over a wire.  What do you have to do?\n",
       "\n",
       "Map.  Mapping, right?  Object relational mapping, object blah map,\n",
       "object something map.  Every time you want to get to and from the\n",
       "outside world.  Especially stuff you are not writing.  So RMI is out\n",
       "of the question.  You are not going to get some web site to accept\n",
       "your RMI calls, or make RMI calls to you.\n",
       "\n",
       "Any time you have to go outside of your box, out of your world view,\n",
       "your object world view, you have to map.  So Java programmers and\n",
       "object-oriented programs have been kicking SQL saying, \"Oh, it\n",
       "requires object relational mapping\", and that is like a problem with\n",
       "SQL.  No!  It is a problem with objects.  Objects are not the way the\n",
       "world works.  Nothing in the world works that way.\n",
       "\n",
       "People do not hand their strings out to other people to start yanking\n",
       "on them.  And that is how we are going to build this.  So that is how\n",
       "we are going to have a soccer team.  Everybody is going to have a\n",
       "reference to somebody else, and you call \"pass\" to me, and we build\n",
       "this big spaghetti nightmare.\n",
       "\n",
       "That is not how the world works.  It is completely not the way the\n",
       "world works.  It is not how physics works.  So we say objects are the\n",
       "way to model the real world.  It is not at all.  It is a complete\n",
       "programming fabrication.  It is not very realistic.  It is not a good\n",
       "fit for almost anything that is in the outside world.  So you can\n",
       "build your own world where all this stuff makes sense, but it is\n",
       "inherently -- I would call it idiosyncratic.\n",
       "\n",
       "But in particular, it is not the way that systems work, systems in the\n",
       "large.\n",
       "\n",
       "\n",
       "[Time 0:38:45]\n",
       "\n",
       "```\n",
       "slide title: Learning from Systems\n",
       "\n",
       "+ system - \"to cause to stand\"\n",
       "\n",
       "+ independent parts connected together\n",
       "\n",
       "+ computer systems\n",
       "\n",
       "  + different langs/runtimes/types\n",
       "\n",
       "  + RPC and queues, of plain data\n",
       "\n",
       "+ Flexible insofar as:\n",
       "\n",
       "  + support independent development\n",
       "\n",
       "  + tolerant in what they accept\n",
       "```\n",
       "\n",
       "So what are systems?  The word \"system\" means \"to cause to stand\".\n",
       "And I love that idea.  I mean, I always think of these legs sort of\n",
       "self-assembling to try to make something that stands up.\n",
       "\n",
       "It is independent parts that you connect together, substantially\n",
       "independent parts.  Because you do not need to cause something to\n",
       "stand that is one thing that already has three legs.  You are not\n",
       "causing it to stand up.  It is the independence of the things that\n",
       "matters.\n",
       "\n",
       "And in general we try to build systems in a way that makes them\n",
       "independent.  Do we want to care if another server is using the same\n",
       "programming language that we are?  Or the same runtime, the same\n",
       "version of the Java runtime?  Or the same type system?  Do we want to\n",
       "build a system like that, where we care?  No, we don't.  Why?  Because\n",
       "it is going to be brittle.  It is going to be hard to make changes.\n",
       "We are going to have to agree with the other person.  Tomorrow, we are\n",
       "going to have this thing, and everything is going to be different.\n",
       "\n",
       "You know: three, two, one.  We don't do that.  The Internet, does it\n",
       "work that way?  No!  We do not do specific stuff.  We do general\n",
       "stuff, and we try to be as independent as possible.\n",
       "\n",
       "Most things that happen between systems use one of two techniques.\n",
       "They use RPC with plain data out and back.  Or they use queues, where\n",
       "you send data and somebody shows up later and gets the data.  You just\n",
       "send, and you just flow data around.  This is the way that systems are\n",
       "built, big systems.  Big successful systems like the Internet.  And\n",
       "most systems.\n",
       "\n",
       "And those systems are flexible.  You measure their flexibility in\n",
       "terms of how much independence they support.  Can you independently\n",
       "develop these parts of a system?  Can somebody upgrade their part of\n",
       "the system and not mess up the other person?  Because Twitter is not\n",
       "going to tell your web browser when they change their home page and\n",
       "have Safari do something special.  That is not how it works.\n",
       "Everybody has independent development, independent time frames.\n",
       "\n",
       "Then the other thing that is critical to this, is that if somebody\n",
       "else on the other end is going to change, you have to be tolerant of\n",
       "things being different.  You cannot say, \"well, here is our contract!\"\n",
       "There are nine hundred things that have to be exactly this way.  And\n",
       "then I will work, and then you will work.  Then if we are going to\n",
       "change anything, we have to have lunch, and have a meeting, and decide\n",
       "this stuff again.  You have to be tolerant and accepting to some more\n",
       "things, so we do not have to change in lock step.\n",
       "\n",
       "So these systems are inherently dynamic, and they are inherently\n",
       "extensible.  That is what I just said.  Systems are made with dynamic\n",
       "types, extensible types.  They can accept data that you were not\n",
       "expecting to see, and it will not make them fall over.  And hopefully\n",
       "they will do a good job of propagating it.  They are all made this\n",
       "way.\n",
       "\n",
       "\n",
       "[Time 0:41:30]\n",
       "\n",
       "```\n",
       "slide title: Outside/In\n",
       "\n",
       "+ We should program the insides of our\n",
       "  systems like we program the outsides\n",
       "\n",
       "  communicating via immutable data\n",
       "\n",
       "+ for the same reasons\n",
       "\n",
       "  loose coupling/subsystem independence\n",
       "\n",
       "  flexibility\n",
       "\n",
       "+ RPC => PC (function call)\n",
       "\n",
       "+ queues => channels\n",
       "```\n",
       "\n",
       "So this is the other fundamental idea of Clojure: we should build the\n",
       "insides of our systems like we build the outsides of our systems.  All\n",
       "those value propositions that accrue to systems, we want them.  How\n",
       "many people want to have a meeting every time they change a class or a\n",
       "subsystem?  How people have meetings every time they change a class?\n",
       "Yeah, you have to, right?  This could break!  Stuff is going to break.\n",
       "\n",
       "So we should communicate using immutable data inside our systems, for\n",
       "the same reason we do outside.  It makes our systems more robust.  It\n",
       "makes them easier to change.  It makes the independent parts separate.\n",
       "It makes it easier to move them around.  We get loose coupling.  We\n",
       "get subsystem independence.  We get flexibility.\n",
       "\n",
       "And what is the mapping?  Well there is no real mapping.  This does\n",
       "not _need_ mapping.  RPC [remote procedure call] becomes PC [procedure\n",
       "call].  We can call functions.  We were calling functions before there\n",
       "was R.  Then they had R.  We had PC before we had RPC.  We can go back\n",
       "to PC.  We can do that.  We can pass data to functions and get data\n",
       "back.  We used to be able to do it, then we had all this elaborate\n",
       "stuff.  Now we forgot how to do it.\n",
       "\n",
       "And we can implement queues and flow inside our programs, using queues\n",
       "or channels or things like that.\n",
       "\n",
       "\n",
       "[Time 0:42:48]\n",
       "\n",
       "```\n",
       "slide title: Process and State\n",
       "\n",
       "+ Of course there must be state and effects\n",
       "\n",
       "+ Clojure is not 'pure', but does have _explicit_\n",
       "  state constructs\n",
       "\n",
       "  functional succession model\n",
       "\n",
       "  observation of state _values_\n",
       "\n",
       "+ core.async offers simple channel (queue) model\n",
       "\n",
       "  flow vs places\n",
       "```\n",
       "\n",
       "So that is the other key idea.  Now there is going to be process and\n",
       "state.  Clojure is a practical language.  Of course you are going to\n",
       "have process and state, or there is no reason to run your program.  I\n",
       "just make the computer hot and you go home.  You are going to have\n",
       "state and effects.\n",
       "\n",
       "But this is another area where we are left just totally with nothing,\n",
       "in object-oriented languages like Java.  You have nothing here.  There\n",
       "are very fancy functional languages that have purity, where they will\n",
       "force you, through the type system, to identify and isolate all the\n",
       "parts of your program that could do IO, or have any kind of effect.\n",
       "They will either do it via purity, or via effect systems.\n",
       "\n",
       "And then there is the alternative to that, is nothing.  That is what\n",
       "most people have is absolutely nothing.\n",
       "\n",
       "And then you could also have reified constructs that at least make a\n",
       "state change explicit.  And that is where Clojure sits.  Because in\n",
       "Java and C++ and C# you have nothing.  We just have nothing.  You have\n",
       "some really raw constructs like mutexes, and a pat on the back, and\n",
       "good luck, buddy, and read Brian's book.\n",
       "\n",
       "[ Brian's book refers to:\n",
       "Brian Goetz, \"Java Concurrency in Practice\", 2006, Addison-Wesley ]\n",
       "\n",
       "So Clojure does not have any purity to it, but it has explicit\n",
       "constructs for state.  These are like, you can imagine them being\n",
       "variables that have semantics to them.  So it is not just like anybody\n",
       "can come in and whack on this variable at any time.  Instead you say,\n",
       "\"I am going to give you a function, and you somehow apply that\n",
       "function to that variable to move it from one state to another.\"  But\n",
       "in doing so, you can ensure it is free of conflict, and free of races,\n",
       "and it is never going to become half of a thing.\n",
       "\n",
       "[Time 0:44:27]\n",
       "\n",
       "And these variables always refer to values.  So you are always able to\n",
       "observe them, or dereference them, and get out a value.  There is\n",
       "nothing else.  There is only these reference cells that point to\n",
       "values, and values.  There is no mutable object that half of which\n",
       "could be whatever, or a date class that you could set the month, or\n",
       "things like that.  A date is a value.  You can have a reference to a\n",
       "date.  You can make that reference point to another date.  But you\n",
       "can't change a date.\n",
       "\n",
       "So you have: things you can change, which are references, and you have\n",
       "values, which are not.  You cannot change dates, any more than you can\n",
       "change 42.  But you can change these references.  But they are atomic.\n",
       "They just point to one thing.\n",
       "\n",
       "So between those, you can get a whole bunch of different variants.\n",
       "CAS implements a successorship model.  You say: only make this new\n",
       "thing if my presumption is still valid.\n",
       "\n",
       "So that is the tiniest version.  And Clojure has a construct that\n",
       "wraps that, so you do not have to write the loop, or anything else.\n",
       "You say: here is my function, apply it to the inside of that, use CAS,\n",
       "do the loop for me.  And I know I will get a clear successorship\n",
       "there, with no race, and no conflicts.\n",
       "\n",
       "[ These constructs are called an \"atom\" in Clojure, and \"swap!\" is the\n",
       "name of the built-in function that does what is described above.\n",
       "Atoms also have a few other similar built-in functions for updating\n",
       "atoms.\n",
       "\n",
       "The STM in Clojure can update references in Clojure things called\n",
       "\"ref\"s, for which the built-in macros \"sync\" and \"dosync\" can update\n",
       "one or more refs in a transactional way. ]\n",
       "\n",
       "There is also an STM in Clojure that allows for bigger transactional\n",
       "kinds of modifications to occur.  But the point is: this construct is\n",
       "doing the job.  And the construct is calling out: here is where the\n",
       "mutation is in the system.  Here is where the state is.\n",
       "\n",
       "And the thing is: you have a way to get out of it.  If I give you\n",
       "something that you do not know if it is going to change, how can you\n",
       "save its value?  If I give you a reference, via an interface, to some\n",
       "composite type, you don't know if it could mutate, how can you save\n",
       "its value?  What is the safe way to do that?\n",
       "\n",
       "[Time 0:46:09]\n",
       "\n",
       "[Audience member: clone]\n",
       "\n",
       "You do not know the clone is going to work at all.  Sorry, does not\n",
       "work.  What else?  Walk through all the get's, get this, get that.\n",
       "You have got nothing.  You have absolutely nothing.  So this is like a\n",
       "critical thing for making a system that works.  You have absolutely\n",
       "nothing to do this with.  You have to build up your own convention\n",
       "around this.\n",
       "\n",
       "So I think you should pick.  You should either have explicit\n",
       "constructs, or go all the way to Haskell, because everything in\n",
       "between is catastrophe.\n",
       "\n",
       "And then in Clojure we have something called core.async which is a\n",
       "channel model.  It is a little bit richer than queues, because you\n",
       "don't have to set up the threads and do all the micro writes.  They\n",
       "have semantics that are based around something called communicating\n",
       "sequential processes.  But the basic idea is that you are going to try\n",
       "to encourage -- especially when you are trying to convey values\n",
       "through a system -- instead of saying, \"I will put the acorn behind\n",
       "this tree, and you come by later and find it behind the tree,\" you\n",
       "say, \"I am going to put the acorn on the conveyor belt, and you can\n",
       "take it off the conveyor belt.\"\n",
       "\n",
       "And there is a big difference between those two things, because if you\n",
       "put something on a conveyor belt and then go back to it, what do you\n",
       "expect?  Nothing.  A conveyor belt is moving, man.  That is it.  That\n",
       "flowed.  So you cannot write the logic you can write with variables,\n",
       "going back and re-examining a place to update it in place and try to\n",
       "read it again.  It flows.  And so flow is a much more robust way to\n",
       "build a system.  Data flow is a much more robust way than variables.\n",
       "So we want to emphasize flow over places.\n",
       "\n",
       "\n",
       "[Time 0:47:50]\n",
       "\n",
       "```\n",
       "slide title: (Program) Size Matters\n",
       "\n",
       "+ Smaller is better\n",
       "\n",
       "+ Bigger - more bugs, longer time to market,\n",
       "  slower maintenance, more brittleness\n",
       "\n",
       "+ Concision - size in the small\n",
       "\n",
       "+ Generality - size in the large\n",
       "```\n",
       "\n",
       "So program size matters.  Smaller is better.  This is one of the few\n",
       "areas where we have research.  People have done research and said:\n",
       "smaller programs have fewer bugs.  It is just that simple.  It does\n",
       "not matter what programming language it is.  Smaller programs have\n",
       "fewer bugs.\n",
       "\n",
       "Bigger programs have more bugs, longer time to market.  They are\n",
       "harder to maintain, and they are more brittle.\n",
       "\n",
       "But what I think is interesting is that there are two flavors of\n",
       "small.  A lot of languages focus on concision, which is size in the\n",
       "small.  How small is your if statement?  How small is a function call?\n",
       "How tiny are your constructs?  How much overhead, how much syntactic\n",
       "stuff is there?  And there are a lot of languages that focus on that:\n",
       "Ruby, and Python, and a lot of languages are actually very good at\n",
       "concision.\n",
       "\n",
       "But the bigger impact on a program overall is not moving from 42\n",
       "characters to 20 characters.  That only gets you 2x.  The biggest\n",
       "thing is moving from more specificity, which bloats your program, to\n",
       "more generality, which shrinks it.  That is the big payoff.  That is\n",
       "the area where you are going to get a payoff much higher than 2x.\n",
       "\n",
       "\n",
       "[Time 0:49:06]\n",
       "\n",
       "```\n",
       "slide title: Death by Specificity\n",
       "\n",
       "+ Most information objects are just glorified\n",
       "  maps of name->value\n",
       "\n",
       "+ but you can't treat them as such in Java!\n",
       "\n",
       "+ more code, less reuse, more coupling\n",
       "\n",
       "  need to access each object via its own\n",
       "  language (class)\n",
       "\n",
       "+ this is a complete waste of time (IMO)\n",
       "```\n",
       "\n",
       "So one of the other things I think we suffer from in object\n",
       "orientation is death by specificity.  All the time, we have a new\n",
       "thing, we have a new idea, a new piece of data.  Boom!  We have a new\n",
       "class.  Get this, get that, get whatever.\n",
       "\n",
       "I do not care if they are value types, whatever.  It is just a\n",
       "glorified map, except you cannot even use it as a map in Java.  There\n",
       "is no generic way to manipulate something that says: get this, get\n",
       "that, get that.  So new type, new language, it has got its own little\n",
       "vocabulary.\n",
       "\n",
       "So you are going to have more code.  You are going to have much less\n",
       "reuse.  You are going to have more coupling.  Because essentially what\n",
       "is happening is every object has its own little language: my class, my\n",
       "interface, my own language.  This is my biggest pet peeve.  I wanted\n",
       "to get away from this.  When we saw it writing get this, get that,\n",
       "there is no purpose to this.  This is just life-sucking.\n",
       "\n",
       "\n",
       "[Time 0:49:59]\n",
       "\n",
       "```\n",
       "slide title: Example - HttpServletRequest\n",
       "\n",
       "getAsyncContext, getAttribute, getAttributeNames,\n",
       "getCharacterEncoding, getContentLength,\n",
       "getContentType, getDispatcherType, getInputStream,\n",
       "getLocalAddr, getLocale, getLocales, getLocalName,\n",
       "getLocalPort, getParameter, getParameterMap,\n",
       "getParameterNames, getParameterValues, getProtocol,\n",
       "getReader, getRealPath, getRemoteAddr, getRemoteHost,\n",
       "getRemotePort, getRequestDispatcher, getScheme,\n",
       "getServerName, getServerPort, getServletContext,\n",
       "isAsyncStarted, isAsyncSupported, isSecure,\n",
       "removeAttribute, setAttribute, setCharacterEncoding,\n",
       "startAsync, startAsync...\n",
       "getHeader, getHeaderNames, getHeaders, getIntHeader...\n",
       "\n",
       "                 How many maps?\n",
       "```\n",
       "\n",
       "So let us look at life sucking.\n",
       "\n",
       "[Audience laughter.]\n",
       "\n",
       "This is just a tiny part.  This is just the servlet request, and I\n",
       "have a little bit of HttpServletRequest, which really doubles the size\n",
       "of this thing.\n",
       "\n",
       "But my question to you is: how many maps do you see here?  Or like,\n",
       "give a name, you get a value.  I got 1.  I got 1, I got 1, ... I\n",
       "actually cannot do the auctioneer thing.  How many you got?\n",
       "\n",
       "[Audience member: It looks like there are one or two sub-maps, like\n",
       "parameter names, parameter values.]\n",
       "\n",
       "Yeah.  So first of all, this game is hard, right?\n",
       "\n",
       "[Audience laughter]\n",
       "\n",
       "[Time 0:50:43]\n",
       "\n",
       "[ This slide is the same as previous one, but some names have been\n",
       "colorized.  I will mark them in the slide text by surrounding them\n",
       "with _, but not trying to indicate the colors of each. ]\n",
       "\n",
       "```\n",
       "slide title: Example - HttpServletRequest\n",
       "\n",
       "getAsyncContext, _getAttribute_, _getAttributeNames_,\n",
       "getCharacterEncoding, getContentLength,\n",
       "getContentType, getDispatcherType, getInputStream,\n",
       "getLocalAddr, getLocale, getLocales, getLocalName,\n",
       "getLocalPort, _getParameter_, _getParameterMap_,\n",
       "_getParameterNames_, _getParameterValues_, getProtocol,\n",
       "getReader, getRealPath, getRemoteAddr, getRemoteHost,\n",
       "getRemotePort, getRequestDispatcher, getScheme,\n",
       "getServerName, getServerPort, getServletContext,\n",
       "isAsyncStarted, isAsyncSupported, isSecure,\n",
       "_removeAttribute_, _setAttribute_, setCharacterEncoding,\n",
       "startAsync, startAsync...\n",
       "_getHeader_, _getHeaderNames_, _getHeaders_, _getIntHeader..._\n",
       "```\n",
       "\n",
       "There are some.  I got three inside, and the overall thing is a map,\n",
       "too.  So I got four right off, by picking it apart.\n",
       "\n",
       "What is really interesting is: look at these map interfaces.  They are\n",
       "all ad hoc.  Guess what else?  They are all different!  One has\n",
       "setting.  One you can actually get the map.  One you can get a list.\n",
       "Some you can get out with types.  There are four _different_ maps in\n",
       "this one class.  This is _crazy_!\n",
       "\n",
       "\n",
       "[Time 0:51:12]\n",
       "\n",
       "```\n",
       "slide title: In Clojure, Just Use Maps\n",
       "\n",
       "{:remote-addr \"127.0.0.1\",\n",
       " :scheme :http,\n",
       " :query-params {\"somekey\" \"somevalue\"},\n",
       " :form-params {},\n",
       " :request-method :get,\n",
       " :query-string \"somekey=somevalue\",\n",
       " :content-type nil,\n",
       " :uri \"/foobaz\",\n",
       " :server-name \"localhost\",\n",
       " :params {\"somekey\" \"somevalue\"},\n",
       " :headers\n",
       "        {\"accept-encoding\" \"gzip, deflate\",\n",
       "\t \"connection\" \"close\",\n",
       "\t \"user-agent\" \"Apache-HttpClient/4.1.2 (java 1.5)\",\n",
       "\t \"content-length\" \"0\",\n",
       "\t \"host\" \"localhost:8383\"},\n",
       " :content-length 0,\n",
       " :server-port 8383,\n",
       " :character-encoding nil}\n",
       "```\n",
       "\n",
       "In Clojure, we just use maps.  This stuff came over a wire in HTTP, as\n",
       "text.  How did we turn it into this?\n",
       "\n",
       "[switches back to previous slide with Java API]\n",
       "\n",
       "[Audience laughter]\n",
       "\n",
       "What happened?  What happened?\n",
       "\n",
       "[switches back to \"In Clojure, Just Use Maps\"]\n",
       "\n",
       "This is crazy.\n",
       "\n",
       "I told you the curly braces are maps.  Who can see how many maps?\n",
       "One, two, ...  You see all the maps.  Because they are still maps.\n",
       "\n",
       "\n",
       "[Time 0:51:38]\n",
       "\n",
       "```\n",
       "slide title: Specific vs General\n",
       "\n",
       "+ Everything using HttpServletRequest is special\n",
       "\n",
       "  + yes, dot completion works and no typos\n",
       "\n",
       "+ but everything else is much worse\n",
       "\n",
       "  + inconsistent, idiosyncratic, wide interfaces\n",
       "\n",
       "  + much more code - can't reuse map\n",
       "    manipulation libraries\n",
       "\n",
       "  + consumer code completely coupled\n",
       "\n",
       "  + harder to fabricate for testing\n",
       "```\n",
       "\n",
       "If you are going to write code that manipulates that other stuff [Java\n",
       "API version], every single line of code you write is going to be\n",
       "special.  It has to use whatever Java X servlet blah, and you are\n",
       "writing code explicitly to this thing.\n",
       "\n",
       "If there is another way to do HTTP, not that there is, so this is\n",
       "probably the only way to do HTTP.  But if there was another way to do\n",
       "HTTP, will you be able to reuse that code?  No!  It is all hardwired\n",
       "to this person or persons idea of what an HTTP request is.\n",
       "\n",
       "So yeah, there is a tiny little benefit.  Dot works in your IDE.\n",
       "Whoo!  Oh my goodness, because I could never remember that [back to\n",
       "Java API slide for a moment here], so something better happen when I\n",
       "press dot, because I am doomed otherwise.\n",
       "\n",
       "Of course I could look at the HTTP spec and we could agree on these\n",
       "names.  And I just don't get it.  You can tell a kid not to put a\n",
       "spoon in a blender and turn it on, and they will remember that for\n",
       "their entire lives.  They will never make that mistake.  But grown-up\n",
       "adult programmers, we need protection from this stuff.\n",
       "\n",
       "But the protection we get is really minimal.  What is the cost?  It is\n",
       "huge!  That is an inconsistent interface.  It is incredibly\n",
       "idiosyncratic.  The interface is huge, so if you wanted to have a\n",
       "second implementation, get to work.  There is a ton more code to\n",
       "consume it.  You cannot use any of the libraries you already have.\n",
       "\n",
       "With the Clojure version, all the map code, like I said those hundreds\n",
       "of functions, they work on this.  You can create this with them.  You\n",
       "can read this with them.  You can merge two of these with that.  And\n",
       "you have no new code to manipulate this.  No new code.  All the\n",
       "functions you already know manipulate HTTP requests, as soon as you\n",
       "represent them as data.  Which they were, by the way, before we map\n",
       "them.\n",
       "\n",
       "Testing.  It is easier to test data.  Can you make a program that\n",
       "makes this?  [Clojure map version]  Yeah.  Can you make a program that\n",
       "makes one of these?  [Java API version]\n",
       "\n",
       "Yeah.  OK.  And the other problem is your typical Java program has two\n",
       "to three orders of magnitude more of that.  More of this [Java API\n",
       "slide].  Right?  100 classes, a couple hundred.  How many people have\n",
       "programs with more than a thousand classes?  Yeah.  That is a party!\n",
       "\n",
       "\n",
       "[Time 0:54:03]\n",
       "\n",
       "```\n",
       "slide title: Clojure Programs are\n",
       "                 Smaller\n",
       "\n",
       "+ Very concise code (in the small)\n",
       "\n",
       "  dynamic typing\n",
       "\n",
       "  direct support for idioms\n",
       "\n",
       "+ Very generic code (in the large)\n",
       "\n",
       "  programming with data abstractions\n",
       "\n",
       "  information == plain data\n",
       "```\n",
       "\n",
       "All right.  So Clojure programs are smaller in both ways.  They are\n",
       "more concise, and they support generic programming, because we just\n",
       "program with these data abstractions.  We represent information as\n",
       "plain data.\n",
       "\n",
       "\n",
       "[Time 0:54:14]\n",
       "\n",
       "```\n",
       "slide title: Dynamic Typing\n",
       "\n",
       "+ Yes, you _can_ have an error that a type checker\n",
       "  would catch\n",
       "\n",
       "  + e.g. name typos\n",
       "\n",
       "  + likely to catch at REPL or in tests\n",
       "```\n",
       "\n",
       "So this is always the biggest reservation.  I love my types.  I like\n",
       "my dot.  I like my IDE.  I cannot deal with something other than that.\n",
       "\n",
       "And it is true: if you have the types of Java -- not fancier types;\n",
       "fancier type systems can do more -- but if you have the type system of\n",
       "Java you can catch typos in passing ints when you are supposed to pass\n",
       "strings.  But it is really likely that your tests or your REPL\n",
       "interaction is going to catch that stuff.\n",
       "\n",
       "\n",
       "[Time 0:54:43]\n",
       "\n",
       "```\n",
       "slide title: Quality\n",
       "\n",
       "+ Much more important is avoiding problems\n",
       "  that your type checker (and tests) can't catch\n",
       "\n",
       "  + state management\n",
       "\n",
       "  + coupling\n",
       "\n",
       "  + lack of flexibility due to specificity\n",
       "\n",
       "  + problems of misconception hidden in\n",
       "    morass\n",
       "\n",
       "+ Clojure's default idioms are a big net win\n",
       "```\n",
       "\n",
       "That is not a quality metric.  That is not sufficient for quality.  It\n",
       "is part of quality, no typos.  But it is not sufficient for quality.\n",
       "\n",
       "The quality is in all this other stuff.  What did we say?  We have no\n",
       "way to deal with state management.  We are encouraged to write highly\n",
       "coupled programs.  We are inflexible.  We are not meeting the customer\n",
       "stakeholder quality metric at all.  In fact, we are pointed against it\n",
       "time and time again.  We are pointed at the wrong thing.\n",
       "\n",
       "And because our code is so huge, we cannot even really understand what\n",
       "it does any more.  So the biggest source of bugs in programs, which is\n",
       "misconceptions.  Everybody gets it wrong.  I talked to the\n",
       "stakeholder.  They told me this.  I did not think of one of the\n",
       "situations when I wrote the program.  Those are the real bugs in\n",
       "programs.  Everything else are superficial bugs.  Those are the real\n",
       "bugs.  They are harder to see.  So I think these default idioms are a\n",
       "big win.\n",
       "\n",
       "\n",
       "[Time 0:55:32]\n",
       "\n",
       "```\n",
       "slide title: Programming is an\n",
       "             Economic Activity\n",
       "\n",
       "+ _economic_ - \"relating to household management\"\n",
       "\n",
       "+ Our programming 'house' is a mess\n",
       "\n",
       "  full of language features, crutch tools\n",
       "\n",
       "  secret passageways\n",
       "\n",
       "  dirt (state)\n",
       "\n",
       "+ Languages and programs are too big\n",
       "\n",
       "+ Require large staff\n",
       "```\n",
       "\n",
       "I am not going to spend much time on this, but it was interesting to\n",
       "me, because I always like to look up words, what does \"economic\" mean?\n",
       "It actually means \"relating to household management\".  So the idea of\n",
       "home economics is kind of redundant.  It is what the word means.\n",
       "\n",
       "And I would say that our programming house is just like a hoarder's\n",
       "delight.  There is too much stuff in it.  Everything is too big.  We\n",
       "need too many people to do basic things.\n",
       "\n",
       "\n",
       "[Time 0:55:59]\n",
       "\n",
       "```\n",
       "slide title: There's Much More to\n",
       "                  Clojure\n",
       "\n",
       "+ Most of it is _libraries_\n",
       "\n",
       "+ that can be used independently\n",
       "\n",
       "+ Small core is protected from bloat\n",
       "```\n",
       "\n",
       "There is a lot more to Clojure.  This was not a tutorial on Clojure.\n",
       "But the important thing is that most of it is in libraries.  Clojure\n",
       "grows via libraries.  The core is really pretty vigorously protected\n",
       "against growth.  It is not like an experiment in language design.\n",
       "\n",
       "\n",
       "[Time 0:56:17]\n",
       "\n",
       "```\n",
       "slide title: Polymorphism Made\n",
       "                   Simple\n",
       "\n",
       "+ Clojure protocols\n",
       "\n",
       "  + set of functions polymorphic on first arg\n",
       "\n",
       "  + Like interfaces, without inheritance\n",
       "\n",
       "+ Can be extended to existing, even final\n",
       "  classes like java.lang.String\n",
       "\n",
       "+ Greatly reduce coupling vs derivation\n",
       "\n",
       "+ Avoid the 'privileged native framework'\n",
       "```\n",
       "\n",
       "So the one other part of Clojure I would like to talk about is\n",
       "polymorphism, just because it is another example of simple.  I have\n",
       "not talked a lot about simple.  But one of the cool things about\n",
       "Clojure is that polymorphism is independent.  In other words, it does\n",
       "not require inheritance.\n",
       "\n",
       "Clojure has something called protocols.  They are a set of functions\n",
       "that work together.  They are polymorphic on the first argument.  So\n",
       "that is like the same kind of single dispatch you have in Java.  So\n",
       "you can imagine them as interfaces, but they do not require\n",
       "inheritance.  And the beautiful thing about not requiring inheritance\n",
       "is, you can have a protocol, and you can extend it to something that\n",
       "is finished.  Something that Sun wrote a long time ago and is never\n",
       "going to change, and certainly is never going to implement your\n",
       "interface.\n",
       "\n",
       "You can also take stuff from two vendors.  Because what do we usually\n",
       "have?  We have the framework problem.  There is a privileged framework\n",
       "in Java -- the one that comes with it.  And people implement those\n",
       "interfaces, but if you have a piece of software from vendor A that has\n",
       "an interface, and stuff from vendor B like objects from vendor B that\n",
       "you want to use, how do you get vendor B to implement vendor A's\n",
       "interfaces?  It just does not happen.  Which is even worse than the\n",
       "C++ world, but in Java we still have this problem.  There is a\n",
       "privileged framework that people implement the interfaces, and\n",
       "otherwise implemented interfaces are parochial.  They are small.\n",
       "\n",
       "So we have polymorphism in Clojure is a la carte.  And that reduces\n",
       "coupling, because you do not need to derive.\n",
       "\n",
       "\n",
       "[Time 0:57:41]\n",
       "\n",
       "```\n",
       "slide title: Ecosystem and Support\n",
       "\n",
       "+ Seamless integration with host platforms\n",
       "\n",
       "+ Keep leveraging existing libs during\n",
       "  transition\n",
       "\n",
       "+ Clojure is _stable_\n",
       "\n",
       "  not an ongoing programming language\n",
       "  experiment\n",
       "```\n",
       "\n",
       "All right.  I know.  Maybe Clojure seems more interesting now.\n",
       "\n",
       "So it is not just about technology.  It is not even about these\n",
       "programming things.  It is also about ecosystem and things like that.\n",
       "And the first thing that is great about using Clojure is that you get\n",
       "to keep connection to the ecosystem you already know.  Not only the\n",
       "runtime and the deployment environment, but those libraries.  The\n",
       "inter-op in both cases is extremely good.\n",
       "\n",
       "All those Clojure data structures I showed you, they all implement the\n",
       "appropriate java.util.Map whatever.  They implement all the Java\n",
       "interfaces.  You can just take one of those things you wrote in square\n",
       "brackets that was pretty easy, and pass it to something that expects a\n",
       "java.util.List that implements random access.  Right there, works.\n",
       "Ready to go.\n",
       "\n",
       "Clojure is also very stable.  I value that in Java.  I think it is an\n",
       "important part of why Java grew, and Clojure takes the same approach.\n",
       "It is not like kids on Github hacking away, adding every new idea, or\n",
       "it is not a think-tank experiment.  It is made for production use and\n",
       "it is very stable.  All the programs from a long time ago still run.\n",
       "\n",
       "\n",
       "[Time 0:58:47]\n",
       "\n",
       "```\n",
       "slide title: Books\n",
       "\n",
       "[ Rather than listing all of the books that appeared on the slide\n",
       "here, I would recommend looking at the official Clojure site page on\n",
       "Clojure books, at the link just below. ]\n",
       "```\n",
       "[https://clojure.org/community/books](https://clojure.org/community/books)\n",
       "\n",
       "There are books if you wanted to get started.  There are a lot of\n",
       "books now for Clojure.\n",
       "\n",
       "I spoke here last five years ago and people had never heard of\n",
       "Clojure, and now there is plenty.\n",
       "\n",
       "\n",
       "[Time 0:58:57]\n",
       "\n",
       "```\n",
       "slide title: Tools\n",
       "\n",
       "[ screen shot ]\n",
       "\n",
       "Counterclockwise for Eclipse\n",
       "```\n",
       "\n",
       "There are tools.  Oh look!  There is an IDE!  That looks like Eclipse,\n",
       "with code highlighting for Clojure, and structural nav.\n",
       "\n",
       "\n",
       "[Time 0:59:06]\n",
       "\n",
       "```\n",
       "slide title: Tools\n",
       "\n",
       "[ screen shot ]\n",
       "\n",
       "Cursive for IntelliJ\n",
       "```\n",
       "\n",
       "And oh!  That is IntelliJ.  Same thing.  Breakpoints, look.  And you\n",
       "type, and it starts popping stuff up!  This is good!  We are good!\n",
       "And you have a REPL down there, which is even better, once you get\n",
       "used to that.\n",
       "\n",
       "\n",
       "[Time 0:59:20]\n",
       "\n",
       "```\n",
       "slide title: Tools\n",
       "\n",
       "+ leiningen (build tool)\n",
       "\n",
       "+ Typed Clojure (fancy types)\n",
       "\n",
       "+ Prismatic Schema (schemas for data)\n",
       "\n",
       "+ test.check (a la QuickCheck)\n",
       "\n",
       "+ core.logic (a la Prolog)\n",
       "\n",
       "+ Immutant (interface to JBoss web stack)\n",
       "\n",
       "+ many more\n",
       "```\n",
       "\n",
       "There are a ton of tools in various areas.\n",
       "\n",
       "\n",
       "[Time 0:59:25]\n",
       "\n",
       "```\n",
       "slide title: Libraries\n",
       "\n",
       "[ Screen shot of search results for term \"clojure\" in Github, with\n",
       "\"We've found 12,145 repository results\" circled in red for drawing\n",
       "attention.  That number as of 2018-Feb-10 search is 26,144. ]\n",
       "```\n",
       "\n",
       "There are lots of libraries.  That says 12,000 repos on Github.\n",
       "\n",
       "\n",
       "[Time 0:59:30]\n",
       "\n",
       "```\n",
       "slide title: Users\n",
       "\n",
       "[ Screen shot of management screen for Clojure Google group, with\n",
       "\"Showing 50 of 9564 members\" circled for attention.  As of 2018-Feb-10\n",
       "that number is 11,252. ]\n",
       "```\n",
       "\n",
       "There are lots of users.  The mailing list has almost 10,000 users on\n",
       "it.  And they are all happy nice people.  I promise.\n",
       "\n",
       "[Audience laughter]\n",
       "\n",
       "No, they are.  I think that matters, if you have ever seen the old\n",
       "Lisp community.  They were not all happy nice people.  But Clojure\n",
       "users are happy and nice people.\n",
       "\n",
       "\n",
       "[Time 0:59:46]\n",
       "\n",
       "![0:59:46](ClojureMadeSimple/2014-redmonk-language-ranking-chart.png)\n",
       "\n",
       "[http://redmonk.com/sogrady/2014/06/13/language-rankings-6-14/](http://redmonk.com/sogrady/2014/06/13/language-rankings-6-14/)\n",
       "\n",
       "That is where Clojure is at in RedMonk's, where our language is at.\n",
       "Like way up there!  This functional Lisp.  What is happening in the\n",
       "world?  Look at it.\n",
       "\n",
       "\n",
       "[Time 0:59:56]\n",
       "\n",
       "![0:59:56](ClojureMadeSimple/2014-thoughtworks-technology-radar.png)\n",
       "\n",
       "[https://assets.thoughtworks.com/assets/technology-radar-jan-2014-en.pdf](https://assets.thoughtworks.com/assets/technology-radar-jan-2014-en.pdf)\n",
       "\n",
       "There it is on the tech radar.  Adopt.  It has actually gone off the\n",
       "tech radar.  They are like: of course you should be using Clojure\n",
       "already.\n",
       "\n",
       "\n",
       "[Time 1:00:03]\n",
       "\n",
       "```\n",
       "slide title: Companies\n",
       "\n",
       "[ logos for these companies:\n",
       "\n",
       "ThreatGRID (A Cisco Company)\n",
       "Netflix\n",
       "heroku\n",
       "citi\n",
       "Staples\n",
       "Twitter\n",
       "Groupon\n",
       "livingsocial\n",
       "Akamai\n",
       "Deutsche Bank USA\n",
       "Yahoo! Labs\n",
       "WalmartLabs\n",
       "The Climate Corporation, A Monsanto Company\n",
       "Puppet labs\n",
       "DRW Trading Group\n",
       "ConsumerReports.org\n",
       "\n",
       "[ See the much longer list on the official Clojure web site, linked\n",
       "below, if you are interested. ]\n",
       "```\n",
       "[https://clojure.org/community/companies](https://clojure.org/community/companies)\n",
       "\n",
       "And they are right.  People are using Clojure already.  A lot of\n",
       "people are already using Clojure.  Banks use Clojure.  Plenty of\n",
       "startups use Clojure.  Plenty of analytics houses use Clojure.  So\n",
       "people are being successful with it.\n",
       "\n",
       "\n",
       "[Time 1:00:18]\n",
       "\n",
       "```\n",
       "slide title: Clojure\n",
       "\n",
       "+ Better and more flexible programs\n",
       "\n",
       "+ Sooner\n",
       "\n",
       "+ because Clojure is _data-oriented_ and _simple_\n",
       "```\n",
       "\n",
       "So I think that is the short message for today.  The idea behind\n",
       "Clojure is to get you to better and more flexible programs sooner.\n",
       "And the way it approaches that is by being data-oriented and simple.\n",
       "And I really appreciate your time.  Thanks.\n",
       "\n",
       "[Audience applause.]\n",
       "\n",
       "[Time 1:00:36]\n"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(slurp \"https://raw.githubusercontent.com/matthiasn/talk-transcripts/master/Hickey_Rich/ClojureMadeSimple.md\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules\n",
    "One can import modules with [require](https://clojuredocs.org/clojure.core/require)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(require 'clojure.string)\n",
    "(clojure.string/blank? \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Does not work with notebooks, but one can give aliases to namespaces in Clojure programs `(require '[clojure.string :as str])`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "THIs Is A tEst."
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(clojure.string/replace \"This is a test.\" #\"[a-o]\" clojure.string/upper-case) ;; #\"[a-o]\" is a regular expression literal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "class java.util.regex.Pattern"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(class #\"[a-o]\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Java interoperability\n",
    "[Java interoperability](https://clojure.org/reference/java_interop) is extensive.\n",
    "### Java static method calls\n",
    "static methods and attributes can be accessed with `/`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1537626870412, 3.141592653589793]"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(System/currentTimeMillis)\n",
    "Math/PI]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Java import\n",
    "Java classes can be imported with [import](https://clojuredocs.org/clojure.core/import)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2018-09-22"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(import java.time.LocalDate)\n",
    "(LocalDate/now)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Java method calls\n",
    "Java methods can be called on objects like functions by prefixing the name with `.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2018-09-24"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(.plusDays (LocalDate/now) 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Java methods can also be called with the dot form, providing the objet and then the method (and arguments if anay) to the `.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2018-09-24"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(. (LocalDate/now) plusDays 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2018-10-01"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(.plusWeeks (.plusDays (LocalDate/now) 2) 1);; rewrite with a threading macro ? (immutablity ftw !)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Java constructors\n",
    "Java constructors can be called like functions by postfixing the class name with `.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sat Sep 22 14:34:30 GMT 2018"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(import java.util.Date)\n",
    "(Date.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [doto](https://clojuredocs.org/clojure.core/doto) macro allows to thread the object as the first argument to methods and functions and return the object. (Compared to `->` that threads the result from function calls to function calls and returns it)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#object[java.time.LocalDate 0x202ead6 2018-09-22]\n",
      "#object[java.time.LocalDate 0x202ead6 2018-09-22]\n",
      "#object[java.time.LocalDate 0x202ead6 2018-09-22]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2018-09-22"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(doto (LocalDate/now)\n",
    "      (println)\n",
    "      (.plusDays 2)\n",
    "      (println)\n",
    "      (.plusWeeks 1)\n",
    "      (println))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#object[java.util.HashMap 0x6e8f1f73 {a=1, b=2}]\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a075bc6c-0aa2-4dda-9dcb-89e8aae4fcc9",
       "version_major": 2,
       "version_minor": 0
      },
      "method": "display_data"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "(doto (java.util.HashMap.)\n",
    "            (.put \"a\" 1)\n",
    "            (.put \"b\" 2)\n",
    "            (println))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Java arrays\n",
    "For performance or interoperability reasons, one might want to use java arrays. However, these are obviously **not immutable**. One can make arrays of references with [make-array](https://clojuredocs.org/clojure.core/make-array) and use [aset](https://clojuredocs.org/clojure.core/aset) and [aget](https://clojuredocs.org/clojure.core/aget) to set and get elements of the array. Arrays of primitive types can be created and used with specific functions such as [int-array](https://clojuredocs.org/clojure.core/int-array), [aset-int](https://clojuredocs.org/clojure.core/aset-int) and [aget-int](https://clojuredocs.org/clojure.core/aset-int). [aget](https://clojuredocs.org/clojure.core/aget) and [alength](https://clojuredocs.org/clojure.core/alength) work on arrays of all types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[I@152ca3e[0 0 0 0 0 0 0 0]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[I@152ca3e[0 0 0 0 256 0 0 0]"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def int-a (int-array 8))\n",
    "(println (str int-a (vec int-a)))\n",
    "(aset-int int-a 4 256)\n",
    "(str int-a (vec int-a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Runtime polymorphism / Dynamic dispatching\n",
    "[Dynamic dispatching](https://en.wikipedia.org/wiki/Dynamic_dispatch) can be achieved in [two ways in Clojure](https://clojure.org/about/runtime_polymorphism).\n",
    "A most efficient dispatching based on the type of a single argument, relying on the OOP mechanism of the JVM, is available with [protocols](https://clojure.org/reference/protocols).\n",
    "Compared to java *interfaces* clojure protocols can be added to existing types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MyCustomType implementation can access fields\n",
       "firstname Rich and lastname Hickey"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(defprotocol Processing\n",
    "    \"A demo protocol\"\n",
    "  (process [this] \"the process methods does not take any argument besides the object\"))\n",
    "\n",
    "(extend-type Object\n",
    "    Processing\n",
    "    (process [this] (str \"Default implementation for \" this)))\n",
    "\n",
    "(extend-type String\n",
    "    Processing\n",
    "    (process [this] (str \"String implementation for \" this)))\n",
    "\n",
    "(defrecord MyCustomType\n",
    "    [firstname lastname]\n",
    "    Processing\n",
    "    (process [this] (str \"MyCustomType implementation can access fields\\nfirstname \"\n",
    "                    (:firstname this) \" and lastname \" (:lastname this))))\n",
    "\n",
    "(def test-record (MyCustomType. \"Rich\" \"Hickey\"))\n",
    "(process test-record)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A most generic and flexible multiple arguments dispatching is also available in the form of\n",
    "[multimethods](https://clojure.org/reference/multimethods)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "result of formula of intersection of ellipses {:shape :ellipse, :data :todo1} and {:shape :ellipse, :data :todo2}"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(defmulti intersect\n",
    "  (fn [a b]\n",
    "    [(:shape a)(:shape b)])) ;; could use class\n",
    "\n",
    "(defn rectangle-ellipse-intersect[rectangle ellipse]\n",
    "    (str \"result of formula of intersection of rectangle \" rectangle \" and ellipse \" ellipse))\n",
    "    \n",
    "(defmethod intersect [:rectangle :ellipse]\n",
    "  [r e] (rectangle-ellipse-intersect r e))\n",
    "(defmethod intersect [:ellipse :rectangle]\n",
    "  [e r] (rectangle-ellipse-intersect r e))\n",
    "\n",
    "(defmethod intersect [:rectangle :rectangle]\n",
    "  [r1 r2] (str \"result of formula of intersection of rectangles \" r1 \" and \" r2))\n",
    "\n",
    "(defmethod intersect [:ellipse :ellipse]\n",
    "  [e1 e2] (str \"result of formula of intersection of ellipses \" e1 \" and \" e2))\n",
    "\n",
    "(def ellipse-1 {:shape :ellipse :data :todo1})\n",
    "(def ellipse-2 {:shape :ellipse :data :todo2})\n",
    "\n",
    "(def rectangle-1 {:shape :rectangle :data :todo3})\n",
    "(def rectangle-2 {:shape :rectangle :data :todo4})\n",
    "\n",
    "(intersect ellipse-1 ellipse-2)\n",
    ";;(intersect ellipse-1 rectangle-1)\n",
    ";;(intersect rectangle-2 ellipse-1)\n",
    ";;(intersect rectangle-1 rectangle-2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concurrency\n",
    "Most concurrency issues are completely sidestepped by functional programming on **immutable** data. However, any useful\n",
    "program has to deal with side effects and some mutable state can be useful. There are [many ways to manage states in Clojure](https://aphyr.com/posts/306-clojure-from-the-ground-up-state) and to [manage concurrency and parallelism in Clojure](http://clojure-doc.org/articles/language/concurrency_and_parallelism.html), we'll only see a few of them. \n",
    "### Agents\n",
    "[Agents](https://clojure.org/reference/agents) store a value that can be changed by a\n",
    "a function taking the previous value as an argument. The function calls and the resulting update of the value are done by\n",
    "asynchronous messages that are queued so the messages can be sent from concurrent threads.\n",
    "Agents are created with the [agent](https://clojuredocs.org/clojure.core/agent) function taking the initial value as an argument. Messages are sent using the [send](https://clojuredocs.org/clojure.core/send) function and the current state is accessed with the [deref](https://clojuredocs.org/clojure.core/deref) function or the `@` prefix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "5\n",
      "15\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "clojure.lang.Agent@64883856"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def x (agent 0))\n",
    "(println @x)\n",
    "(defn increment [c n] (+ c n))\n",
    "(send x increment 5)  ; @x -> 5\n",
    "(println @x)\n",
    "(send x increment 10)\n",
    "(println @x)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[await](https://clojuredocs.org/clojure.core/wait) can be used to wait until all messages to one or more agents\n",
    "have been processed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "#object[clojure.lang.Agent 0x64883856 {:status :ready, :val 15}]\n",
      "#object[clojure.lang.Agent 0x64883856 {:status :ready, :val 30}]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(defn slow-increment [c n] (Thread/sleep 20000)(+ c n))\n",
    "(send x slow-increment 5)  ; @x -> 5\n",
    "(println @x)\n",
    "(send x slow-increment 10)\n",
    "(println x)\n",
    "(await x)\n",
    "(println x)\n",
    "(.flush *out*)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Atoms\n",
    "[Atoms](https://clojure.org/reference/atoms) allow for atomic updates of a single state. They are created with the [atom](https://clojuredocs.org/clojure.core/atom) function. And the stored state can be accessed with the [deref](https://clojuredocs.org/clojure.core/deref) function or the `@` prefix.\n",
    "\n",
    "The value stored in an atom can be updated with the [swap!](https://clojuredocs.org/clojure.core/swap!) function that takes the current value as an argument and return the new value to be stored in the atom."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{:a 0}\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b29f61ba-a69d-4e97-95a8-fd9626ba6915",
       "version_major": 2,
       "version_minor": 0
      },
      "method": "display_data"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "(def my-atom (atom {:a 0}))\n",
    "(println @my-atom)\n",
    "(swap! my-atom #(assoc % :b 1));; can be called from multiple concurrent threads\n",
    "@my-atom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "(def int-atom (atom 0))\n",
    "(defn slow-inc[x]\n",
    "   (let[current-value x] ;; not useful, just to emphasis that the value we use was read before sleeping\n",
    "       (Thread/sleep 10000)\n",
    "       (inc current-value)))\n",
    "(dotimes [i 10] (.start (Thread. #(do (swap! int-atom slow-inc)(println @int-atom)))));; clojure functions are Runnable\n",
    "@int-atom"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Futures\n",
    "While one can use a `java.lang.Thread` with clojure functions because they implement the `java.lang.Runnable` interface,\n",
    "the [future](https://clojuredocs.org/clojure.core/future) function can more easily be used to launch an asynchronuous call when we are interested in the result. The result can be synchronously accessed later by using the [deref](https://clojuredocs.org/clojure.core/deref) function or the `@` prefix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before access\n",
      ":done\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def f (future (Thread/sleep 10000) :done))\n",
    "(println \"before access\")\n",
    "(.flush *out*)\n",
    "(println @f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Refs\n",
    "[Refs](https://clojure.org/reference/refs) allow for [Software Transactional Memory](https://en.wikipedia.org/wiki/Software_transactional_memory) over multiple states. \n",
    "The [ref](https://clojuredocs.org/clojure.core/ref) is used to create a /ref/ with the initial value, [deref](https://clojuredocs.org/clojure.core/deref) or the `@` prefix is used to retrieve the value.The [alter](https://clojuredocs.org/clojure.core/alter) function cals in a [dosync](https://clojuredocs.org/clojure.core/dosync) scope allow for transactional modifications inside the scope. No side effect should be performed by the function used to alter the refs as they can be retried as needed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 6 0 7 13 4 8 15]\n",
      "[3 2 1 11 14 12 10 9]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def first-half (ref (vec (range 8))))\n",
    "(def second-half (ref (vec (range 8 16))))\n",
    "(def swap #(let[i1 (rand-int (count @first-half))\n",
    "                i2 (rand-int (count @second-half))]\n",
    "                (dosync\n",
    "                (let[tmp (nth @first-half i1)]\n",
    "                 (alter first-half assoc i1 (nth @second-half i2))\n",
    "                 (alter second-half assoc i2 tmp)))))\n",
    "\n",
    "(dorun (apply pcalls (repeat 8 #(dotimes [_ 1000] (swap)))))\n",
    "(println @first-half)\n",
    "(println @second-half)\n",
    "(sort (concat @first-half @second-half))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269]"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def fib-seq\n",
    "     (lazy-cat [0 1] (map + (rest fib-seq) fib-seq)))\n",
    "(take 32 fib-seq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 5, 7, 9, 11, 13, 17, 19, 23, 25, 29, 31, 37, 41, 43, 47, 49, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 121, 127, 131, 137, 139, 149, 151, 157, 163, 167, 169, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 289, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 361, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def primes (lazy-cat [2] (filter (fn[candidate]\n",
    "                                    (not-any? #(zero? (mod candidate %1))\n",
    "                                              (take-while (partial > (Math/sqrt candidate))\n",
    "                                                          primes)))\n",
    "                                  (iterate (partial + 2) 3))))\n",
    "(take 100 primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`let` bindings can (should ?) be used to document code by naming sub-expressions :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "null"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ";; TODO example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pattern matching\n",
    "[Pattern matching](https://en.wikipedia.org/wiki/Pattern_matching) is implemented in a library, thanks to the power of macros built on homoiconicity.\n",
    "\n",
    "For a real clojure program (i.e. not a notebook), the library dependency is expressed in the file `project.clj` (when using [leiningen](http://github.com/technomancy/leiningen/) ), as explained in the [core.match](https://github.com/clojure/core.match) `Readme`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "method": "display_data"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6cda7150-2f36-45e8-931d-bcbbd1bceca8",
       "version_major": 2,
       "version_minor": 0
      },
      "method": "display_data"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%classpath add mvn org.clojure core.match 0.3.0-alpha5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[FizzBuzz, 1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, FizzBuzz, 16, 17, Fizz, 19, Buzz, Fizz, 22, 23, Fizz, Buzz, 26, Fizz, 28, 29, FizzBuzz, 31]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(require '[clojure.core.match :refer [match]])\n",
    "\n",
    "(defn fizz-buzz[n]\n",
    "    (match[(mod n 3) (mod n 5)]\n",
    "          [0 0] \"FizzBuzz\"\n",
    "          [0 _] \"Fizz\"\n",
    "          [_ 0] \"Buzz\"\n",
    "          :else n))\n",
    "\n",
    "(map fizz-buzz (range 32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logic programming\n",
    "[Logic programming](https://en.wikipedia.org/wiki/Logic_programming) is implemented in a library, thanks to the power of macros built on homoiconicity.\n",
    "\n",
    "For a real clojure program (i.e. not a notebook), the library dependency is expressed in the file `project.clj` (when using [leiningen](http://github.com/technomancy/leiningen/) ), as explained in the [core.logic](https://github.com/clojure/core.logic) `Readme`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "method": "display_data"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8b065868-b44e-4294-bca9-a91a85a5313d",
       "version_major": 2,
       "version_minor": 0
      },
      "method": "display_data"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%classpath add mvn org.clojure core.logic 0.8.11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[7, 1, 4, 2, 8, 9, 5, 6, 3], \n",
       ", [6, 3, 8, 7, 1, 5, 9, 2, 4], \n",
       ", [9, 2, 5, 3, 6, 4, 1, 7, 8], \n",
       ", [8, 6, 1, 5, 4, 7, 3, 9, 2], \n",
       ", [4, 5, 3, 9, 2, 6, 7, 8, 1], \n",
       ", [2, 9, 7, 1, 3, 8, 4, 5, 6], \n",
       ", [1, 4, 9, 6, 7, 2, 8, 3, 5], \n",
       ", [5, 8, 6, 4, 9, 3, 2, 1, 7], \n",
       ", [3, 7, 2, 8, 5, 1, 6, 4, 9]]"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ";; example from https://gist.github.com/orb/5884956\n",
    "(ns sudoku\n",
    "  (:refer-clojure :exclude [==])\n",
    "  (:use [clojure.core.logic])\n",
    "  (:require [clojure.core.logic.fd :as fd]))\n",
    "\n",
    "\n",
    "(defn init-board [vars puzzle]\n",
    "  (matche [vars puzzle]\n",
    "          ([[] []]\n",
    "             succeed)\n",
    "          ([[_ . more-vars] [0 . more-puzzle]]\n",
    "             (init-board more-vars more-puzzle))\n",
    "          ([[num . more-vars] [num . more-puzzle]]\n",
    "             (init-board more-vars more-puzzle))))\n",
    "\n",
    "\n",
    "(defn solve [puzzle]\n",
    "  (let [sdnum (fd/domain 1 2 3 4 5 6 7 8 9)\n",
    "        board (repeatedly 81 lvar)\n",
    "        rows (into [] (map vec (partition 9 board)))\n",
    "        cols (apply map vector rows)\n",
    "\n",
    "        get-square (fn [x y]\n",
    "                     (for [x (range x (+ x 3))\n",
    "                           y (range y (+ y 3))]\n",
    "                       (get-in rows [x y])))\n",
    "\n",
    "        squares (for [x (range 0 9 3)\n",
    "                      y (range 0 9 3)]\n",
    "                  (get-square x y))]\n",
    "\n",
    "    (run* [q]\n",
    "         (== q board)\n",
    "         (everyg #(fd/in % sdnum) board)\n",
    "         (init-board board puzzle)\n",
    "         (everyg fd/distinct rows)\n",
    "         (everyg fd/distinct cols)\n",
    "         (everyg fd/distinct squares))))\n",
    "\n",
    "\n",
    "(def puzzle1\n",
    "  [0 0 0 0 0 9 0 6 0\n",
    "   0 3 8 0 0 5 0 0 4\n",
    "   0 2 0 0 6 0 0 7 0\n",
    "   0 0 0 0 0 0 3 9 0\n",
    "   0 0 0 9 2 6 0 0 0\n",
    "   0 9 7 0 0 0 0 0 0\n",
    "   0 4 0 0 7 0 0 3 0\n",
    "   5 0 0 4 0 0 2 1 0\n",
    "   0 7 0 8 0 0 0 0 0])\n",
    "\n",
    "(def puzzle2\n",
    "  [0 3 0 5 0 0 0 0 0\n",
    "   7 0 0 0 6 0 9 0 0\n",
    "   8 2 9 0 0 0 0 0 0\n",
    "   9 6 0 0 3 0 1 0 0\n",
    "   3 0 0 6 0 4 0 0 2\n",
    "   0 0 4 0 8 0 0 7 6\n",
    "   0 0 0 0 0 0 7 5 3\n",
    "   0 0 7 0 5 0 0 0 9\n",
    "   0 0 0 0 0 9 0 1 0])\n",
    "\n",
    ";; http://www.sudokudragon.com/unsolvable.htm\n",
    "(def puzzle3\n",
    "  [0 8 0 0 0 9 7 4 3\n",
    "   0 5 0 0 0 8 0 1 0\n",
    "   0 1 0 0 0 0 0 0 0\n",
    "   8 0 0 0 0 5 0 0 0\n",
    "   0 0 0 8 0 4 0 0 0\n",
    "   0 0 0 3 0 0 0 0 6\n",
    "   0 0 0 0 0 0 0 7 0\n",
    "   0 3 0 5 0 0 0 8 0\n",
    "   9 7 2 4 0 0 0 5 0])\n",
    "\n",
    "(comment\n",
    "  (partition 9 (first (solve puzzle1)))\n",
    "  ((7 1 4 2 8 9 5 6 3)\n",
    "   (6 3 8 7 1 5 9 2 4)\n",
    "   (9 2 5 3 6 4 1 7 8)\n",
    "   (8 6 1 5 4 7 3 9 2)\n",
    "   (4 5 3 9 2 6 7 8 1)\n",
    "   (2 9 7 1 3 8 4 5 6)\n",
    "   (1 4 9 6 7 2 8 3 5)\n",
    "   (5 8 6 4 9 3 2 1 7)\n",
    "   (3 7 2 8 5 1 6 4 9))\n",
    "\n",
    "  (partition 9 (first (solve puzzle2)))\n",
    "  ((4 3 6 5 9 1 2 8 7)\n",
    "   (7 5 1 8 6 2 9 3 4)\n",
    "   (8 2 9 4 7 3 5 6 1)\n",
    "   (9 6 8 2 3 7 1 4 5)\n",
    "   (3 7 5 6 1 4 8 9 2)\n",
    "   (2 1 4 9 8 5 3 7 6)\n",
    "   (6 9 2 1 4 8 7 5 3)\n",
    "   (1 8 7 3 5 6 4 2 9)\n",
    "   (5 4 3 7 2 9 6 1 8))\n",
    "\n",
    "  (count (solve puzzle3))\n",
    "  8\n",
    ")\n",
    "(interpose \\newline (vec (partition 9 (first (solve puzzle1)))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TODO (supra) (loop[] (recur))\n",
    "## TODO example reduce map multiple values (mean / sse)\n",
    "## TODO core.async\n",
    "## TODO core.typed ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "beakerx_kernel_parameters": {},
  "kernelspec": {
   "display_name": "Clojure",
   "language": "clojure",
   "name": "clojure"
  },
  "language_info": {
   "codemirror_mode": "Clojure",
   "file_extension": ".clj",
   "mimetype": "text/x-clojure",
   "name": "Clojure",
   "nbconverter_exporter": "",
   "version": "1.9.0"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": false,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}