As programs became more complicated there wasn't any outcomes. Using threading macros: data transformaitons with only one side effect at the end:

  (defn execute-action []
    (->
     (lookup-data)
     (lookup-data2)
     (side-effect)
     (transform-data)
     (retransform-data)
     (modify-state)))

http://pedestal.io/

http://clojure.com/blog/2013/06/28/clojure-core-async-channels.html

Covered some of the use of Channels in core.async.

core.async working with ClojureScript.

rx.js as one of the options for managing conditional activities based on async requests.

https://github.com/swannodette/async-tests/blob/master/src/async_test/robpike/core.cljs

This continues some of the work on having better composability than what is provided just through callbacks or futures.

  (defn handler [[e c]]
    (match [e]
           [{"x" x} {"y" y}]))

Requires bringing the async edges in to channels. Example was using the Google JSONP interface dumping values into a channel.

  (defn fastest []
    ())
  

This also provides precise event control when using throttle rules with timeouts.

  (defn throttle
    ([src ms]
       ())
    ([c src ms]
       ()))
  

See a comparable implementation: http://davidwalsh.name/function-debounce

• Multiplex channels
• event channel
• map includes the munction to removeEventListener el
• go blocks
• Fan-in
• Blocking

http://en.wikipedia.org/wiki/Communicating_sequential_processes

http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-25.html#%_chap_4

See also http://mitpress.mit.edu/sites/default/files/titles/content/sicm/book.html

On Lisp Prolog interpretter http://dunsmor.com/lisp/onlisp/onlisp_28.html

Problem: Fetch a value then async conditional data request.

Research:

• http://channel9.msdn.com/shows/Going+Deep/Anders-Hejlsberg-Herb-Sutter-Erik-Meijer-Brian-Beckman-Software-Composability-and-the-Future-of/
• http://msdn.microsoft.com/en-us/data/gg577609.aspx
• Iterable
• pull
• T next()
• throws Exception
• returns
• Observable
• Actors
• Event loops

Looking at Futures and Observable .

Treat the contruction of Observable endpoint based on machine state, amount of work, data in memory.

• RX marble diagrams http://rxwiki.wikidot.com/marble-diagrams
• onNext, onCompleted, onError

Havae a grid of movies each with metadata that, based on that data, will require a second (or more) request(s): VideoMetadata, VideoBookmark, VideoRating.

This used Groovy for the implementations against the service:

• getVideos
• take
• mapMany / flatMap
• metadata, bookmark, rating:
• return zip(a, b, F)

Apply functions to async

Emphasize developer training re: functional and reactive programming. Initial hurdle was just in setting up the workshops, brought in a technical writer just for the documentation for the on-boarding.

Debugging and performance was the next area of improvement.

Only rule: "Don't mutate state outside of function."

https://github.com/Netflix/RxJava

• http://conal.net/

• Next
• Error
• Empty
• Complete

TBD

Starting with Lambda Calculus and BNF of SExpr, Var, Int, Bool, Binop.

3 basic operations.

• symbol
• repetion
• concatenation

Strings in Haskell are just lists.

• pull characters from string one at a time
• at end of string check the match

• Define a list of tokens we want to suport
• Define a sample program that we want to run

  (let (y (lambda f
            ((lambda x (x x))
             (lambda x (f (lambda v ((x x) v)))))))
    (let (factH (lambda partial
                  (lambda n (if (= n 0)
                           1
                         (* n (partial (- n 1)))))))
      (let (fact (y factH))
        (print (fact 5)))))
  

• Lex the program by finding matches for types associated with If, Sub, Mul, Eq, Gt, Lt, Or, And, Let
• Create the rules as RegExp matches
• Running from Haskell

jwalsh:CompilersFromScratch/ (master) $ ghci SExpr

• Provide a simple example

(let (x 1)