Unlocking data-driven systems – Paul deGrandis

Inspiring story of success.
Happily familiar with themes and observations that align with our experience of building declarative UIs and services at Outpace.

Om nom nom nom – Anna Pawlicka

Interesting code examples with a concise tour of the various forms of state in om.
Clear and useful explanation of :shared-state and :fn.
I enjoyed the humor.

Cursive: a different type of IDE – Colin Fleming

'As you code' arity checks and hinting.
No other devenv provides an analyzer (they are all REPL based).
Cursive is compelling due to the unique features it provides with this competitive advantage.
Find all, paredit, common task.
Understands keyword destructuring during refactoring.

Generating Generators – Steve Miner

Herbert library for schemas with generators for test.check.

JVM Creature Comforts – Ghadi Shayban

JVM has several styles of function invocation.

The evolution of the Emacs tooling for Clojure – Bozhidar Batsov

0.8.0 is out
CIDER is far more amenable to adding features than its predecessors and competitors now that it is true Clojure code and modular.

Developing Music Systems on the JVM with Pink and Score – Steven Yi

Core concept is representing function invocation at a future point in time with the intention to turn on and off sound functions that produce digital audio.
Why do music engines look like DSLs instead of data? Would a vector of time+invokes suffice?
```
  [[0 [[saw 800] [kick]]]
   [8 [[kick]]]
   [16 [[saw 1600]]]]
```
Which seems more convenient to edit and transform.
Music has conventions such as squelching notes (cut off at next note, play additively, envelope fade out).
Relative time is more intuitive to me for 'score definition'. Absolute time can drive a current position state to identify the next invocations.
Performance via midi keyboard (or other) interaction is tying an input to effecting an invocation now with some value(s). Bind sound function arguments to references, such that those values can be adjusted as they play? At each digital frame, deref and update sound function such that volume of instrument reflects pressure.

Inside Transducers – Rich Hickey

Mindblowingly impactful content eloquently delivered.
Transducers are a novel abstraction with practical, broad applicability inside Clojure.
Knowing how to create a transduction will help identify user space applications.
To create a custom transducer, provide a three arity function.
Be careful with stateful transducers, don't break the contract.
Be mindful that lazy semantics are affected by the transduction.
educe is the new word for the identity of transduction (do nothing).
Transductions don't have to make sense for every context of execution.
Think about processes separate from the feeding mechanism.

Unsessions

Feature expressions

Atmosphere of controversy.
Concern raised that it may complicate Cursive.

Eastwood

CI build task.
Don't argue over style, enforce it.
Emacs compile hook for interactive warnings on save?

Cursive

Much wow, many powerful features.

Helping voters with Pedestal, Datomic, Om and core.async – Nathan Herzing & Chris Shea

Full stack presentation.
Gave a compelling story of the power of the Clojuresque stack.
Pedestal routes can have per route middleware annotation.

Persistent Data Structures for Special Occasions – Michał Marczyk

Providing additional features with replacement data-structures.
Splicable Vectors.
Sorted maps with faster range searching.
Concrete replacement is in this case very powerful.

Applying the paradigms of core.async in ClojureScript – Julian Gamble

The original ants motivated STM, which does not exist in ClojureScript.
Will the uptake of core.async in ClojureScript make transactions appealing? Context switching during a go block between ant behavior and evaporation would cause incorrect application of the simulation rules. For example if either go block were to be parked, the other could mutate state which had already been read by the original, causing an inconsistent update when it resumed.
```
  (def global (atom 0))
  (defn get-it []
    (go (let [x @global]
          (<! (http-request))
          (reset! global (inc x)))))
  (do (get-it) (get-it))
  @x
  ;;=> 1
```

With transaction semantics enforcement you would then need to be mindful of avoidable rollbacks/retries. So I doubt that transactional forms will ever be adopted in ClojureScript. Be mindful to arrange state management such that updates do not span parking. If you did have logic that spanned a park, enforce your consistency explicitly.

Variants are Not Unions – Jeanine Adkisson

Articulate presentation of the pattern, where it occurs, and why a Variant is good. Very engaging.
Prefer [:click {:x 1, :y 2}] over {:type :click, :x 1, :y 2}

Exploring four hidden superpowers of Datomic – Lucas Cavalcanti & Edward Wible

datoms can become more meaningful after a context is realized
canceling card gives meaning to previously mundane datoms
Filtering db prior to query to avoid programmer error.

Lightning talks

There is a better way to store files on the internet.
Many talented, creative, articulate people in the Clojure Community.

Making Games at Runtime with Clojure – Zach Oakes

Fun, entertaining talk. Very enjoyable.

Cló: The Algorithms of TeX in Clojure – Glenn Vanderburg

Everything is Awesome!

Party

Successful businesses are making use of Clojure and love it.
Many growing Clojure teams.
We are all looking to hire (choose Outpace!)

Always Be Composing – Zach Tellman

Many forms of composition, don't obsess over it, but do consider what works for your problem.
Spectrum data->functions->(transducers)->macros
Contextual as to which makes sense to use.

Building a Data Pipeline with Clojure and Kafka – David Pick

Having a persistent queue is a must for production
async was useful in pulling down systems at a known point

Generative Integration Tests - Ashton Kemerling

Generative tests in a parallel / webdriver setting.
Once fixture creates database, creates browser.
Every fixture clones the database, clears browser cache, find and kill any state.

Stewardship: the Sobering Parts – Brian Goetz

Very engaging speaker, great jokes and energy.
Insights into curator responsibilities.
Very articulate backward compatibility redux.
Value classes, bringing efficiency of memory storage.
TCO may get done soon but not a priority.

Discussions/Ideas:

Initial ClojureScript compile can be easily improved by caching AST.

save as edn when calculated
analyze-file hook to load if present
core.cljs AST can be packaged with the compiler.

ClojureScript compiler error reporting

Throw an ex-info at the point of identification with context.
Have a higher level catch that reports, with line and carrot.
Must be configurable to swallow below or not

Many inquiries about Outpace remote pairing

Entire team works from home.
We pair every day, all day. Pairs are rotated adhoc, usually every other day.
Outpace provides high end Macbook Pro + dual Thunderbolt monitors.
VNC + Zoom are most popular for pairing.
VNC because we run browsers, VMs, DB tools and emulators.
We use a mix of editors (mainly Emacs/Cursive/VIM).
Please come work with us, we are hiring :)

General error handling

call a dynamically bound function, pass a closure.
(f runtimeexception)??? (f {:blah :blah})???
shift reset (Scheme) execute a closure of the stack.

RouteGen feedback

There is some appetite for functions over routes.
Routing and service description is already a populated domain.
Many mentions of personal flavors being developed for declarative service styles.
Are orthogonal concerns like auth affected by the RouteGen style?
If using friend, the (authorized ...) form migrates to user namespace. Requiring auth in the service namespace may be slightly constraining. I could separate them by a service to auth map or meta data. I would prefer to avoid such specialization. Is there a more general abstraction here? Is it per function middleware like Pedastal provides? Having auth be explicitly left to service functions seems fine to me.

doto* preferred for return after side effects

    (defn doto* [x & fs]
      (doseq [f fs]
        (f x))
      x)

    (doto* (+ 2 3) #(assert (= 5 %)))

    ;; progn
    (-> x
      f
      g
      (doto* #(assert (= 5 %)))
      (doto println))

Read "To Mock a Mockingbird" (functional composition)

Datoms as model streaming

At start query current datoms from Datomic to filter inital view
Watch transactor to stream datom updates specific to the view
Consume with Datascript

Use NodeJS to execute ClojureScript tasks

ClojureScript in ClojureScript

One gentleman so inspired "I am going to box up my TV when I get home and spend the next six months working on ClojureScript in ClojureScript."

Conditional transformation

    (let [x (+ 7 2)]
      (if (pred x)
        (+ 2 x)
        x))
    (call? v pred f)

I might think this is more common than it really is

Nested sorted maps for spatial representation? by size?

Not general

Pages

Clojure/conj braindump