A quick introduction to thinking Functionally with Clojure. Presentation given at Codemotion Rome 2017

1. Thinking Functionally with
Clojure
by John Stevenson
@jr0cket
www.practical.li

3. Why Functional Programming
it's not just because it's really fun...

4. Complex Systems
… are simply not
easy to understand
@jr0cket
Josh Smith - Tweet
Original Gif

5. The Complexity Iceberg
- @krisajenkins
● complexity is very
dangerous when hidden
● You can't know what a
function does for certain if it
has side effects

6. Side Effects
Side Causes term coined by
@krisajenkins

7. Pure Functions
The results of the function are purely determined by its initial output and its own code
- no external influence, a function only uses local values
- referential transparency (the function can be replaced by its value)

8. Impure Functions - side causes
The results of the function are purely determined by its initial output and its own code
- behaviour externally influenced and non-deterministic

9. Eliminating Side Effects
Functional programming is about eliminating side effects where you can,
controlling them where you can't - @krisajenkins
The features in Functional Programming come from a
desire to reduce side effects

10. Clojure
General purpose language hosted on JVM, JavaScript & CLR

11. Clojure / ClojureScript
A hosted language with simple interoperability with the host language
- (java.Util.Date.)
- (js/alert “Client side apps are easier in Clojure”)

12. Clojure - basic syntax for this talk
( ) ;; an empty list. The first element of a list is evaluated as a function call
(function-name data) ;; call a function with the data as its argument
(def name “data-or-value”) ;; assign (bind) a name to a data or legal value
:keyword-name ;; a keyword is a name that points to itself
;; Thread-first macro - chain function calls, passing the result of each call as the first
argument to the next function. The ,,, indicates where the resulting argument goes.
(-> (function-a “data”)
(function-b ,,,) ;; In Clojure commas , are whitespace
(function-c ,,, “data”))

13. Persistent data structures
Built-in Immutability leading to deterministic code

14. List, Vector, Map & Set
Clojure’s built-in data structures are all immutable
- returning a new data structure when a function is applied
(list 1 2 3 4 5) ‘(“fish” “chips” 42)
(vec ‘(1 2 3 4)) [1 2 3 4]
{:key “value”} {:name “John” :skill “conferencing”}
(set ‘(1 2 3 4 4)) #{1 2 3 4}

15. Persistent Data Structures - shared memory
Each function creates a new vector
Memory space for values is shared
between each vector

16. Persistent Data Structures -
shared memory
By sharing memory you
can apply functions
over and over again
effectively
Values persist until
they are no longer
referenced

17. Concurrency is Easier
Concurrency is much easier to write and reason about because of
- Pure functions
- Immutability is encouraged by default
- Persistent Data Structures
- All values are immutable
- unless explicitly wrapped in an atom or ref
- state changes managed atomically (software transactional memory)
- core.async library allows you to write asynchronous code as easily as sequential
code

18. Using
persistent data structures
Iterate over collections
Generate new collections by applying functions

19. Sequence / List Comprehension
Iterate over collections

20. Sequence / List Comprehension
Iterating through a range of generated values to create a list of 2 value vectors

21. Immutability - local binding
Assignments made locally are immutable
- words is a local binding to the result of running the function upper-case on “Hello
World”
- letter->clack is a function that converts a character to a code

22. Lazy Evaluation
Only return a value when necessary
● maintain precision
● optimise evaluation

23. Lazy Evaluation
Clojure's lazy sequences
- returns a reference to a file and step through it one line at a time
- line-seq returns a lazy sequence of lines, so we can read files larger than
available memory, one line at a time

24. Polymorphism
Functions evaluate different algorithms based on arity of arguments

25. Recursion & Polymorphism
Process a collection of values by feeding the remaining elements back to the function
- the sum function is polymorphic, it has different behaviours that could be
evaluated depending on if passed 1 or 2 arguments

26. Recursion - tail call optimisation
Protect the heap space from blowing by using the recur function
Using recur in the last line is the same as calling sum, however the memory required
from the previous sum function call is over-written in memory. So only 1 memory slot
is used instead of 10 billion

27. Higher Order Functions
A function that takes one or more functions as arguments, or
a function that returns a function

28. Higher Order Functions
Functions always return a value & can be used as an argument to another function

29. Composing functions together
Example: current value of the Clojure project from the configuration file
- `slurp` in the project file, convert into a string and return the value at index 2

30. Design idiom:
Composing
functions
together
You can think of functional
design as evaluating one or
more functions in series of
functions

31. Functional Composition - map
Map the function inc over each number of the collection,
returns a new collection of numbers incremented by 1

32. Functional Composition - reduce
Reduce the numbers inside a collection to a single value by applying the + function,
returns a single value

33. Higher Order functions - partial, comp
Higher order functions can return a function
- The comp function composes other functions together
- The partial function allows you to lazily add another argument to a function

34. Managing State
State changes should be managed easily

35. Safe State changes
Changing state safely by not changing it
● Persistent data structures
● Local bindings
Changing state safely by changing it atomically
● Software Transactional Memory (STM)
○ Gives an mechanism like an in-memory atomic database that manages mutable state changes
under the covers
● Atoms
● core.async

36. Concurrency syntax - atoms
An online card game has players that can join and have their winnings tracked

37. Concurrency syntax - atoms
The join-game function adds players to the atom by their name, but only up to 2
players

38. Concurrency syntax - refs for sync updates
The join-game-safely adds players to the ref and alters their account & game account

39. Putting it all together
Let's find all the most common words used in a popular Science Fiction novel

40. Parallelism
Scale to the maximum

41. What is Parallelism
In simple terms: run the same code across multiple CPU’s

42. Parallelism - pmap
pmap - the same as map but in parallel

43. Parallelism - reduce
Significantly lower completion time running in parallel using Immutable data
structures
https://github.com/aphyr/tesser

44. Parallelism - reducers & folds

45. Tools to learn Clojure
inspire them & build up their motivation

46. Clojure support in many different tools

47. Leiningen - Clojure powered
build automation

49. LightTable - Instarepl

50. Emacs & Spacemacs

51. Figwheel (flappy birds example)

53. Examples, examples, examples
we learn by example...

54. Over 20 Books on Clojure...
Where to start with Clojure will be different...
Example:
I typically suggested BraveClojure.com as a starting
point, however many people prefer LivingClojure or
ClojureScript Unraveled...
Help people understand the relevance of a book and if
it's the right thing for them at that time.

55. Clojure.org & ClojureDocs.org

57. Github

58. Clojure-through-code Git repository

59. http://practical.li/clojure-webapps

61. Testing your Clojure skills...

63. Clojurian Community in Person
Probably the most active language-specific
developer communities in London

64. Learning by teaching others
I really started thinking in Clojure when I started talking to & teaching others
- Coding dojos
- talks on Clojure (starting with the basics, showing the art of the possible)
- moving on to running conferences
- workshops at hack days

65. Overtone live performance - MetaX

66. Overtone live performance - MetaX

67. Take your own journey into Clojure

68. Thank you
@jr0cket
jr0cket.co.uk

69. @jr0cket
@Heroku
@SalesforceDevs
#Trailhead
In a galaxy far, far away… London, UK