Introduction to Clojure

This is the presentation I give to colleagues new to Clojure.

Transcript

1. Clojure I  seldom  end  up  where  I  wanted  to  go,  but  almost  always   end  up  where  I  need  to  be.  – Douglas  Adams
2. First  Steps https://mitpress.mit.edu/sicp/full-­text/book/book.html
3. First  Steps http://www.infoq.com/presentations/Simple-­Made-­Easy
4. What  is  Clojure? § Simple:  untangled § Powerful:  adequate  to  complete  tasks
5. Simple § Lisp § Separate  reading  from  evaluation § Tiny  language  syntax § Functional § Pure  Functions § Immutable  Data § Sequence § Polymorphism § Separate  polymorphism  from  derivation § Time  Model § Separate  values,  identities,  state,  and  time
6. Simple § Lisp § Separate  reading  from  evaluation § Tiny  language  syntax § Functional  mostly § Pure  Functions § Immutable  Data § Sequence § Polymorphism  a  la  carte § Separate  polymorphism  from  derivation § Time  Model § Separate  values,  identities,  state,  and  time
7. Power § Java/Javascript interop § Lisp § Compiler  and  Macros § Pragmatic § That’s  why  I  said  mostly functional
8. Syntax § Literals:  \a, “string”, 42, :tag, true, false, nil § Symbols:  +, defn, foo, § resolve  to  something § Composites:  [], {}, #{} § Evaluated  values  of  contained  objects   § Lists:  () § calls § Special  form,  macro,  function
9. Syntax
10. Syntax symbol
11. Syntax symbol list vector literal dispatch   reader  macro
12. Syntax
13. Syntax list symbol literal
14. Syntax
15. Syntax
16. Syntax
17. Syntax  
18. Syntax Reserved   words control  flow   statements operators assignment
19. Syntax § Simple § few  structures  that  always  do  the  same  thing § Powerful § begets  semantics
20. Functional § Pure  Functions   § Persistent  Data  Structures § …  my  precious § Recursion
21. Pure  Functions
22. Persistent  Data  Structures § [],  {},  #{},  () § behave  as  though  a  complete  copy  is  made  each  time  they’re   modified Seven  Concurrency  Models  in  Seven  Weeks  – Paul  Butcher
23. Persistent  Data  Structures Seven  Concurrency  Models  in  Seven  Weeks  – Paul  Butcher 1 2 3 listv1
24. Persistent  Data  Structures Seven  Concurrency  Models  in  Seven  Weeks  – Paul  Butcher 1 2 3 listv1 4 listv2
26. Sequence
27. Sequence
28. Sequence § All  Clojure collections § All  Java  collections § Java  arrays  and  strings § Regular  expression  matches § Directory  structures § I/O  streams § XML  trees § …
30. Recursion
31. Laziness! § Laziness:  elements  calculated  as  needed § So  what? § You  can  postpone  expensive  computations  that  may  not  in  fact   be  needed. § You  can  work  with  huge  data  sets  that  do  not  fit  into  memory. § You  can  delay  I/O  until  it  is  absolutely  needed. Programming  Clojure – Stu  Halloway and  Aaron  Bedra
32. Functional § Pure  Functions   § Persistent  Data  Structures
33. Functional § Pure  Functions  mostly § Immutable  Data  Structures  mostly
34. Pure  Functions  mostly
35. Pure  Functions  mostly
36. Immutable  mostly
37. Immutable  mostly
38. Functional § Simple § Functional  Programming § Immutable  Data  Structures § Sequence § Helpful  Recursion  Constructs § Powerful § Sequence § Laziness § mostly
39. Polymorphism
40. Polymorphism
41. Polymorphism  inheritance http://eduladder.com/viewnotes.php?notesid=49
42. Polymorphism  inheritance
43. Polymorphism  inheritance https://www.thoughtworks.com/insights/blog/composition-­vs-­inheritance-­how-­choose
44. Polymorphism  expression http://www.ibm.com/developerworks/library/j-­clojure-­protocols/
45. Polymorphism  expression http://www.ibm.com/developerworks/library/j-­clojure-­protocols/
46. Protocols  and  Records § Behavior § Type
47. Protocols  and  Records § Behavior § Type § Polymorphism  a  la  carte
48. Protocols  and  Records http://www.ibm.com/developerworks/library/j-­clojure-­protocols/
49. Polymorphism § Simple § Detangled  from  type § Powerful § Extend  existing  types  without  Monkey  Patching
50. Concurrency  vs Parallelism § Concurrency: § composition  of  independently  executing  processes § dealing  with  lots  of  things  happening  at  once § structure   § Parallelism:   § more  than  1  thing  happening  at  the  same  time § doing  lots  of  things  at  once § execution
51. Concurrency  …  so  far § Pure  Functions § Decouple  execution  order  from  desired  result § Immutable  Data § Can  be  shared  without  worrying
52. Concurrency § Concurrency  is  a  way  to  structure  a  program  by  breaking  it   into  pieces  that  can  execute  independently § Concurrency  requires  communication  to  coordinate   independent  executions   § Up  to  now  everything  has  been  immutable § Well  …  you  can  communicate  immutable  things  without   worrying  so  the  model  has  been  inherently  concurrent § But  …  let’s  model  some  things  that  change http://www.infoq.com/presentations/An-­Introduction-­to-­Clojure-­Time-­Model
53. Concurrency  …  the  beginning § Future:   § blocking  cached  computation  on  separate  thread § start  immediately § Promise:   § blocking  cached  computation § computation  thread  must  deliver
54. Concurrency  …  the  beginning § Future:
55. Concurrency  …  the  beginning § Promise:
56. Model  of  Time § Value:  is  immutable  and  semantically  transparent,  a  fact § Time:  concept  that  we  overlay  on  causal  events § Identity:  concept  we  lay  on  a  series  of  values over  time § State:  the  value of  an  identity at  a  point  in  time Key  Insight:  Separate Identity and State
57. Model  of  Time http://www.infoq.com/presentations/An-­Introduction-­to-­Clojure-­Time-­Model
58. Identity  Types § Atoms  enable  independent,  synchronous  changes  to  single   values § Agents  enable  independent,  asynchronous  changes  to  single   values § Refs  enable  coordinated,  synchronous  changes  to  multiple   values Seven  Concurrency  Models  in  Seven  Weeks  – Paul  Butcher
59. Identity  Types  atom
60. Identity  Types  agent
61. Identity  Types  ref
62. Concurrency § Simple § Functional  Programming  Helps § Pure  Functions  and  Immutable  Data § Good  primitives § Intuitive  Model § Powerful § Controlled  Mutation
63. Complexity http://www.infoq.com/presentations/Simple-­Made-­Easy
64. Simplicity http://www.infoq.com/presentations/Simple-­Made-­Easy
65. References § http://www.infoq.com/presentations/Simple-­Made-­Easy § https://mitpress.mit.edu/sicp/full-­text/book/book.html § http://www.infoq.com/presentations/Value-­Values § https://pragprog.com/book/pb7con/seven-­concurrency-­ models-­in-­seven-­weeks § http://www.joyofclojure.com/ § https://pragprog.com/book/shcloj2/programming-­clojure