• .call failures with Closure
• the game for KKO
• working almost all work with ClojureScript

http://www.chris-granger.com/2012/04/12/light-table---a-new-ide-concept/

The work with LightTable is in ClojureScript

This is possible since WebKit (Chromium) is embedded with nodejs.

https://github.com/rogerwang/node-webkit

node-webkit is one of the fundamental elements of LightTable as an implementation.

• :behaviors
• compostable
• introspection by default: can see the ide, the behaviors and listeners

• errors: include the errors in the X header for the source mapping
• compiler on nodejs rather than the jvm
• ClojureScript analyzer should be able to look at Clojure
• screencasts for improving developer involvement
• tools: linode? nrepl, ritz, etc. are good points

Interesting growth in the use of nodejs and javascript with ClojureScript as a protective functionality. Games and editors are good examples are large applications but may not be the core problem area for many web applications that tend to have to look at layout rather than logic; canvas is much different.

http://blog.fogus.me/2012/04/25/the-clojurescript-compilation-pipeline/

• line numbering
• macro support

http://elnode.org/

Can annotate without changing the underlying structure.

The main tests are done with

(cf 1 (I Number Long)))
(ann-form)
(def-alias AnyInteger (U Integer ...))

Check that the first argument is the intersection (rather than U = union) of the second.

This uses ordered intersection types for

this uses a series of cases that need to be checked for correctness

look at the types of arity for (+) (uniform), (map, mapcat); key

This has a mongoDB back-end with the following dumps

{
actor: 'rob',
listing: 'guy-with-bear',
action: 'loved',
interested: [travis, cutter]
}

MongoDB falls over in unexpected ways. Growing interested embedded docs can lock the db.

One of the users (kaitlin) was part of the on-boarding process. Each change would generate massive documents.

• queries required scanning the embedded docs
• query optimizer made bad decisions

Digesting is hard to do: aggregating action for grouping story actors, verbs, and objects.

(defref feed-atom)
@feed-atom

Atoms allow maintaining state so the daemons can do the following:

• thread adds feeds
• thread expires
• thread updates

Redis was tried but failed when too many story sets generated extensive unions.

https://github.com/nathanmarz/storm/wiki/Concepts https://github.com/nathanmarz/storm

spout > score > aggregate > save

spout, tuple, bolt, serialization, deserialization,

This all uses a protocol approach for Spout: nextTuple, ack, and fail.

This still used redis at the start and end of the process. Same processing bolt used for user-id+story

EDN / Hiccup based

Only the weighted connections change not the underlying model.

http://pages.cs.wisc.edu/~bolo/shipyard/neural/local.html http://www.cheshireeng.com/Neuralyst/nnbg.htm

• teach the NN what the correct score is for each character
• (def scores)
• letter-code is a vector of 26 characters to scores
• (neural-network :inputs 26 :outputs 4 : hidden-sizes 6)
• we're trying to create a function that takes a letter and outputs the score
• define a time-chart visualization to show the number of correct scores

• create an identity function that takes the same input and generates the same outputs but by using a smaller set of units (a bottleneck)
• that is a compression layer
• get the training examples
• labels correspond to the training examples
• composition: (def constructor (connect compressor decompressor)
• use a visualization to see what the compressor looks like
• create a coder for representing the value as a vector of binary values
• the neural network takes the compressed 150 inputs to 10 outputs (the hand-written characters)
• run the training then decide when the error rate is small enough to stop the training
• show the recognition for the input training data (would show the failed cases)
• picking the network topography isn't a hard and fast rule: create a function that creates random hidden layers and see which seems to fit

lein deps :tree
lein pendantic

# sudo emacs /etc/hosts
mv .m2 .m2.old
lein deps :verify
gpg --send-keys A2CD6D08
gpg --sign-keys $KEY_ID

http://www.thoughtworks.com/articles/technology-radar-march-2012

adopt trial hold clojure clojurescript

• Clojure + CLJS
• Jetty
• namespaces + functions

http://queue.acm.org/detail.cfm?id=2333133

Debugging is still hard. Errors still require JavaScript background (and that likely won't change).

http://www.pauldee.org/blog/2012/clojurescript-and-node-js-an-experience-report/

http://clojure.net/ http://www.intensivesystems.net/tutorials/monads_101.html

• Comprehending Monads (1992) http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.33.5381
• Comprehending Queries (1999) http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.88.9148

(def f (comp (partial * 2) inc))

;; First Law - Bind
(defn bind [mv f] (apply concat (map f mv)))

;; Second Law - Identity
(= (vector 4) (bind (vector 4) vector))

;; Third Law - Associativity
(= (bind (bind (vector 4) f) g) (bind (vector 4) (fn [x] (bind (f x) g))))

• vector pulls out (1st)
• bind undoes what vector does (2nd)
• bind is associative over functions (3rd)

A monadic value is a container. For the examples noted above that container is a vector. The most obvious of these would be a hash-set.

(hash-set 9)
(defn set-bin [mv f] (apply clojure.set/union (map)))

Using this with constantly…

((constantly 3))
(defn bind [mv f] (fn [] (let [m (mv) new-mv (f m)] (new-mv))))
(defn f [x] (constantly (inc x)))
((f 4))

• bind for constantly
• get the value out of the new mv
• this is a useless monad
• these are monadic values that are functions that take no arguments

(defn result [x] (fn [state] [x state]))
((result 3) :state)
(def h (result 3))
(h #{})

• type signature of f is that it always returns a monadic value
• the result of f
• bind takes values out of a monadic value and binds to a symbol that is a function

(defn bind [mv f] (fn [state] (let [[v new-state] (mv state) new-mv (f v)] (new-mv new-state))))
(defn f [x] (fn [state] [(inc x) (conj state :inced)]))
(def h (f 8))
;; Gives back the function with a conjable state
(h [])
;; [9 [:inced]]
;; Cartesian product with bind and result
(def v1 [:a :b :c])
(def v2 [1 2 3])
(bind v1 (fn [x] (bind v2 (fn [y] (vector [x y])))))

• A Machine-Oriented Logic Based on the Resolution Principle http://dl.acm.org/citation.cfm?id=321253
• http://en.wikipedia.org/wiki/Resolution_(logic)
• Evolution of Lisp http://dl.acm.org/citation.cfm?id=155373
• Forward Reasoning and Dependency-Directed Backtracking in a System for Computer-Aided Circuit Analysis http://dspace.mit.edu/handle/1721.1/6255
• Concepts, Techniques, and Models of Computer Programming https://mitpress.mit.edu/books/concepts-techniques-and-models-computer-programming

• generative and simulation approaches
• use levels of indirection of the test approach to ensure that the implementation isn't the same as the underlying test that could mask the death case
• everything should be a sha with a pointer for reproducible tests
• unit tests aren't used extensively with halloways form of clojure development instead focusing on exploration in the repl or checking in small complete programs that show how functionality works during the initial exploration of the intended functionality
• driving a ui at a data level would be preferable to the drivers required for integration with something like selenium
• tests can become more complicated that the system under development (but likely indicates an abstraction error)
• people who generated the model can review the sim to ensure that it appears to correctly reflect the expected operation of the system