Slide 1

Slide 1 text

Ben Mabey Communicating Sequential Processes in Clojure core.async @bmabey Lambda Lounge Utah, April 8 2014

Slide 2

Slide 2 text

Everything is a Remix … but especially this presentation.

Slide 3

Slide 3 text

Everything is a Remix … but especially this presentation. https://speakerdeck.com/hlship/mastering-time-with-clojure-core-dot-async Mastering Time with Clojure core.async by Howard M. Lewis Ship http://www.infoq.com/presentations/Death-by-Accidental-Complexity Death by Accidental Complexity by Ulf Wiger https://github.com/stuarthalloway/presentations/wiki/Core-Async core.async by Stuart Halloway

Slide 4

Slide 4 text

Event loop w/Callbacks Promises/Futures/Tasks Rx (push based FRP) Coroutines & Generators Actors Communicating Sequential Processes (CSP) async keyword

Slide 5

Slide 5 text

core.async is an efficient implementation of CSP that drastically reduces the accidental complexity usually associated with concurrent programming.

Slide 6

Slide 6 text

core.async is an efficient implementation of CSP that drastically reduces the accidental complexity usually associated with concurrent programming.

Slide 7

Slide 7 text

Embarrassingly Parallel …emparallel? aka brain dead concurrency

Slide 8

Slide 8 text

(defn request-handler! [request]! (let [data1 (do-query-1 request)! data2 (do-query-2 request)! data3 (do-query-3 request)]! (send-response data1 data2 data3))) Embarrassingly Parallel …emparallel? aka brain dead concurrency

Slide 9

Slide 9 text

1 3 2

Slide 10

Slide 10 text

1 3 2

Slide 11

Slide 11 text

1 3 2

Slide 12

Slide 12 text

Channel Writer Writer Writer Reader Reader

Slide 13

Slide 13 text

Channel Writer Writer Writer Reader Reader 1 2 3

Slide 14

Slide 14 text

Channel Writer Writer Writer Reader Reader 1 2 3 Any value can be placed in channel, except for nil

Slide 15

Slide 15 text

Channel Writer Writer Writer Reader Reader 1 2 3

Slide 16

Slide 16 text

Channel Writer Writer Writer Reader Reader 1 2 3

Slide 17

Slide 17 text

Channel Writer Writer Writer Reader Reader 1 2 3

Slide 18

Slide 18 text

Channel Writer Writer Writer Reader Reader 3

Slide 19

Slide 19 text

Channel Writer Writer Writer Reader Reader

Slide 20

Slide 20 text

Channel Reader Reader (close! channel)

Slide 21

Slide 21 text

Channel Reader Reader (close! channel) nil nil

Slide 22

Slide 22 text

Channel Writer Writer Writer

Slide 23

Slide 23 text

Channel Writer Writer Writer 1 2 3 4

Slide 24

Slide 24 text

Channel Writer Reader Reader Writer Writer 1 2 3 4

Slide 25

Slide 25 text

Channel Writer Reader Reader Writer Writer 1 2 3 4

Slide 26

Slide 26 text

No content

Slide 27

Slide 27 text

(defn request-handler! [request]! (let [data1 (do-query-1 request)! data2 (do-query-2 request)! data3 (do-query-3 request)]! (send-response data1 data2 data3)))

Slide 28

Slide 28 text

(defn request-handler [request] (let [query1 (thread (do-query-1 request)) query2 (thread (do-query-2 request)) query3 (thread (do-query-3 request)) data1 (

Slide 29

Slide 29 text

(defn request-handler [request] (let [query1 (thread (do-query-1 request)) query2 (thread (do-query-2 request)) query3 (thread (do-query-3 request)) data1 (

Slide 30

Slide 30 text

(thread (do-query-1 request)) (

Slide 31

Slide 31 text

1 3 2

Slide 32

Slide 32 text

core.async is an efficient implementation of CSP that drastically reduces the accidental complexity usually associated with concurrent programming.

Slide 33

Slide 33 text

No content

Slide 34

Slide 34 text

No content

Slide 35

Slide 35 text

(defn request-handler [request] (let [query1 (thread (do-query-1 request)) query2 (thread (do-query-2 request)) query3 (thread (do-query-3 request)) data1 (

Slide 36

Slide 36 text

(defn request-handler [request] (let [result (go (let [query1 (thread (do-query-1 request)) query2 (thread (do-query-2 request)) query3 (thread (do-query-3 request)) data1 (

Slide 37

Slide 37 text

(go (let […
 data1 (

Slide 38

Slide 38 text

(go (let […
 data1 (

Slide 39

Slide 39 text

1 3 2

Slide 40

Slide 40 text

1 3 2

Slide 41

Slide 41 text

(defn request-handler [request] (go (let [query1 (thread (do-query-1 request)) query2 (thread (do-query-2 request)) query3 (thread (do-query-3 request)) data1 (

Slide 42

Slide 42 text

query1 (thread (do-query-1 request)) query2 (thread (do-query-2 request)) query3 (thread (do-query-3 request)) 0 data1 (

Slide 43

Slide 43 text

No content

Slide 44

Slide 44 text

No content

Slide 45

Slide 45 text

(defn google [query]! (let [results-chan (chan)! timeout-chan (timeout 100)]! (go (>! results-chan (! results-chan (! results-chan (>! (alt! [results-chan timeout-chan] ([v] v))! (conj results))))))) Shared timeout!

Slide 46

Slide 46 text

Event loop w/Callbacks Promises/Futures/Tasks Rx (push based FRP) Coroutines & Generators Actors Communicating Sequential Processes (CSP) async keyword

Slide 47

Slide 47 text

No content

Slide 48

Slide 48 text

var  tweets,  answers,  kaggleProfile;
  
 twitter.getTweetsFor("bmabey",  function  (result)  {
    tweets  =  result;
    somethingFinished();
 });
 stackOverflow.getAnswersFor("bmabey",  function  (result)   {
    answers  =  result;
    somethingFinished();
 });
 kaggle.getProfileOf("bmabey",  function  (result)  {
    kaggleProfile  =  result;
    somethingFinished();
 }); var  finishedSoFar  =  0;
  
 function  somethingFinished()  {
    if  (++finishedSoFar  ===  3)  {
        ui.show(tweets,  answers,  kaggleProfile);
    }
 } http://www.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript

Slide 49

Slide 49 text

var  tweets,  answers,  kaggleProfile;
  
 twitter.getTweetsFor("bmabey",  function  (result)  {
    tweets  =  result;
    somethingFinished();
 });
 stackOverflow.getAnswersFor("bmabey",  function  (result)   {
    answers  =  result;
    somethingFinished();
 });
 kaggle.getProfileOf("bmabey",  function  (result)  {
    kaggleProfile  =  result;
    somethingFinished();
 }); var  finishedSoFar  =  0;
  
 function  somethingFinished()  {
    if  (++finishedSoFar  ===  3)  {
        ui.show(tweets,  answers,  kaggleProfile);
    }
 } http://www.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript

Slide 50

Slide 50 text

var  tweets,  answers,  kaggleProfile;
  
 twitter.getTweetsFor("bmabey",  function  (result)  {
    tweets  =  result;
    somethingFinished();
 });
 stackOverflow.getAnswersFor("bmabey",  function  (result)   {
    answers  =  result;
    somethingFinished();
 });
 kaggle.getProfileOf("bmabey",  function  (result)  {
    kaggleProfile  =  result;
    somethingFinished();
 }); var  finishedSoFar  =  0;
  
 function  somethingFinished()  {
    if  (++finishedSoFar  ===  3)  {
        ui.show(tweets,  answers,  kaggleProfile);
    }
 } - Continuation Passing Style - Destroys readability - Forces shared mutable state - Can’t use normal language constructs for error handling and looping. http://www.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript

Slide 51

Slide 51 text

(go! (let [results (chan 3)]! (twitter/get-tweets "bmabey" c)! (stack-overflow/get-answers "bmabey" c)! (kaggle/get-profile "bmabey" c)! (send-async-response (async/into [] results)))

Slide 52

Slide 52 text

No content

Slide 53

Slide 53 text

Q.all([
    twitter.getTweetsFor("bmabey"),
    stackOverflow.getAnswersFor("bmabey"),
    kaggle.getProfileOf("bmabey")   ]).then(function  (results)  {
    console.log(results[0],  results[1],  results[2]);
 }); http://www.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript

Slide 54

Slide 54 text

Q.all([
    twitter.getTweetsFor("bmabey"),
    stackOverflow.getAnswersFor("bmabey"),
    kaggle.getProfileOf("bmabey")   ]).then(function  (results)  {
    console.log(results[0],  results[1],  results[2]);
 }); http://www.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript + Promises are values + Composable + Better error handling - Continuation Passing Style! - Still can’t use language constructs. - Mutable state still flying around. - By design, are not for streams! - Have to create a new promise for each event.. every time! !

Slide 55

Slide 55 text

C# Async async void Go() {! _button.IsEnabled = false;! string[] urls = "clojure.org www.albahari.com/nutshell/ golang.org".Split();! int totalLength = 0;! foreach (string url in urls)! {! var uri = new Uri ("http://" + url);! byte[] data = await new WebClient().DownloadDataTaskAsync (uri); _results.Text += "Length of " + url + " is " + data.Length +! totalLength += data.Length;! }! _results.Text += "Total length: " + totalLength;! }

Slide 56

Slide 56 text

C# Async async void Go() {! _button.IsEnabled = false;! string[] urls = "clojure.org www.albahari.com/nutshell/ golang.org".Split();! int totalLength = 0;! foreach (string url in urls)! {! var uri = new Uri ("http://" + url);! byte[] data = await new WebClient().DownloadDataTaskAsync (uri); _results.Text += "Length of " + url + " is " + data.Length +! totalLength += data.Length;! }! _results.Text += "Total length: " + totalLength;! } + No more Continuation Passing Style! - Still can’t use for streams.

Slide 57

Slide 57 text

Async Adoption 2007 - F# adds introduces async workflows 2010? - C# adds async 2012-13? - Scala library adds async via macros 2013 - Python announced it will be adding it 2014 - Javascript, ES7 proposal for async

Slide 58

Slide 58 text

No content

Slide 59

Slide 59 text

(defn batch-until-pause! "Batches values from the `in` channel into a single a vec of values up until no! messages have appeared in `timeout-pause` milliseconds. `max-batch-time` is the! number of milliseconds to wait overall before sending a batch."! ([timeout-pause max-batch-time in]! (batch-until-pause timeout-pause max-batch-time in (chan)))! ([timeout-pause max-batch-time in out]! (go! (loop [batch []! batch-timeout (timeout max-batch-time)]! (alt!! ;; batch timed out, send what we have now and start a new batch timeout! batch-timeout (do! (>! out batch)! (recur [] (timeout max-batch-time)))! in ([v]! (if v! ;; we got a value, add it to the batch! (recur (conj batch v) batch-timeout)! ;; we got nil so the 'in' channel was closed, send our batch! (>! out batch)))! ! ;; a timeout happened, send the batch and start a new one! (timeout timeout-pause) (do! (>! out batch)! (send-batch!)! (recur [] batch-timeout))))! (close! out))! out))

Slide 60

Slide 60 text

What about Rx?

Slide 61

Slide 61 text

What about Rx? + Very composable + Handles streams - Push-based semantics only cover ~80% use cases - Have to learn all the combinators - Writing a combinator can be difficult. - Mutable state with call backs again! ! Awesome abstraction, but in the end it is more complex and less powerful than CSP.

Slide 62

Slide 62 text

No content

Slide 63

Slide 63 text

No content

Slide 64

Slide 64 text

We’ve covered brain dead concurrency… what about mind blowing concurrency?

Slide 65

Slide 65 text

No content

Slide 66

Slide 66 text

No content

Slide 67

Slide 67 text

(defn start-phone-process [phone]! (let [...]! (go-loop []! (alt!! off-hook (

Slide 68

Slide 68 text

(defn start-phone-process [phone]! (let [...]! (go-loop []! (alt!! off-hook (

Slide 69

Slide 69 text

No content

Slide 70

Slide 70 text

No content

Slide 71

Slide 71 text

No content

Slide 72

Slide 72 text

No content

Slide 73

Slide 73 text

No content

Slide 74

Slide 74 text

Differences with Actors…

Slide 75

Slide 75 text

Macro Limitations

Slide 76

Slide 76 text

Thank you! ! ! BenMabey.com ! github.com/bmabey ! @bmabey !