Requirements in context

"Maybe Not" (Clojure/conj 2018) separated the keys a map may hold from the keys a given use needs. Hickey described the 1.13 work in those terms: "What the checked directives and & do is outfit destructuring with the remaining facilities of MN's 'select'. What :select does is preclude the inevitable request for closed maps :)" (Clojurians #clojure-dev, 2026-07-08).

Checked keys

:keys!, :syms! and :strs! throw "Missing required key: :id" for an absent key. A key that is present with a nil value passes. Keys listed after & are mentioned without binding a local, and are required inside the checked directives.

Defaults as data

:or accepts keys as well as symbols, and :defaults binds the key-to-default map.

Open maps stay open

:select binds only the keys the form uses, with defaults filled in, at every nesting level. :excess binds the keys the form does not mention, and :all binds the input plus defaults. No directive rejects extra keys.

Missing keys as data

:missing collects absent required keys into a map instead of throwing.

A selection as a value

the alpha8 selector macro turns a destructuring form into a function, and merge-deep recombines a selection with its excess.

Spec next

the open ticket CLJ-2965 ("Keyspaces") splits a map specification into vocabulary, selection "in a context" and values. It asks spec to validate a map against a keyspace plus a destructuring form as the selection.

;; Clojure 1.13.0-alpha8
(let [{:keys! [id] :keys [name] :or {name "anon"} :select s :excess e}
      {:id 7 :role :admin}]
  [id name s e])
;; => [7 "anon" {:name "anon", :id 7} {:role :admin}]

Closed by default

Nix function arguments, Dhall records, Plumatic schema, and Rust serde with deny_unknown_fields reject unknown keys. Clojure 1.13 projects or reports them instead. Jackson 3.0 changed its default from rejecting unknown properties to ignoring them.

Open patterns

Erlang and Elixir map patterns match a subset of keys and ignore the rest. Python and Ruby patterns capture the rest with **rest, and JavaScript with object rest, one level deep. :excess works at every nesting level.

Selection at the point of use

GraphQL selection sets, Datomic pull patterns and spec-alpha2's s/select choose fields per query or per use, as :select does.

Lens laws

with :select as get, :excess as the complement and merge-deep as put, the pair satisfies GetPut and PutPut. It fails PutGet when a view drops a nested map (source {:n {:q 0}}, view {}).

The lens-laws point above uses the names of Foster, Greenwald, Moore, Pierce and Schmitt (TOPLAS 2007): GetPut is put(get s, s) = s, PutGet is get(put v s) = v, and PutPut is put(v2, put(v1, s)) = put(v2, s). The names are not stable across libraries, which matters when checking the PutGet failure against someone else's property suite. Haskell's optics library reverses Foster's first two names, and other libraries use their own names (optics Lens.hs).

Two outcomes from reading these suites. Haskell's optics swaps the first two names relative to Foster, so "PutGet fails" means opposite things in the two vocabularies. And three of the eight (Monocle, accessor, monocle-ts) test only the same-value form of PutPut, which is weaker than the law: a suite can pass there and still lose data on a second, different put.

• :or defaults now evaluate before the input and cannot see bindings from the same map form. (let [a 100 {:keys [a b] :or {b a}} {:a 1}] [a b]) gives [1 1] on 1.12.5 and [1 100] on 1.13.0-alpha8, and the release notes do not mention the change.
• The "Missing required key" error carries no ex-data; :missing is the way to get absent keys as data.
• core.specs.alpha checks only the shape of the new forms. destructure checks the rules, so a form that passes the spec can still fail to compile.

Three slides photographed during the talk, transcribed below. Notes pending.

• track activity of people and systems in the world
  • customers, employees, patients, students, suppliers…
  • to support decision-making and activity of an org
• situated
  • involve databases
  • external systems
  • handle events
  • comprise multiple programs

• large systems become info systems about themselves
  • keep runtime information needed to convey program problems
• single approach to errors, testing etc
• telemetry in language of intent/design
  • enhances ability to analyze
• inspect/intervene in a running program without extending program
  • in REPL, with handwritten or generated data

• tools for flexible information programming
• for a dynamic world
• select, don't reject
• think about flow, conveyance, intermediaries, manifests…
• move fast, learn
• don't make concrete please

The abstract names four topics. Each has a post on the jank blog.

jank-lang/jank

the compiler and runtime. The jank book is the manual, and each compiler error links to its own reference page there.

jank-lang/commons

community-owned packages. Most are raw -sys bindings to a C or C++ library: SDL, GLFW, Dear ImGui, raylib, OpenGL, box2d, sqlite3, FTXUI, ncurses, cpp-httplib.

jank-lang/awesome-jank

the index of the above plus third-party work, such as jank-slint (Slint GUI bindings) and minitui (terminal UIs).

jank-lang/clojure-test-suite

a cross-dialect test suite for clojure.core and friends; the measure of how much Clojure a dialect actually is.

jank-lang/is-jank-fast-yet

benchmarks tracking Clojure dialects over time.

jank-lang/setup-jank, homebrew-jank

CI and install.

• Wednesday's Fast, Lean, Native Clojure workshop (Adrian Smith) lists jank as optional setup.
• Powering a 3D Game Engine with Clojure (Jared Cone, 9:55 the same morning) is the adjacent native-and-games talk.
• What Survived Clojure cites this talk as a live data point.
• Heart of Clojure 2024 had jank office hours.
• The June 2 brief picked up the ray-tracing post.

Notes pending.

One file, three scenarios, each small enough to exhaust a 64 MB heap in under a second. Needs org.clojure/core.async on the classpath. Run on Clojure 1.12.6, JDK 21.0.4, 2026-10-01.

(ns leak
  (:require [clojure.core.async :as async]))

;; 1. memoize: the cache is an atom closed over by the returned fn,
;;    keyed by args, never evicted
(defn render-report [customer-id] (byte-array (* 256 1024)))
(def render-report-memo (memoize render-report))

(defn memoize-leak []
  (doseq [customer-id (range)]
    (render-report-memo customer-id)))

;; 2. go-loop: the go block captures the dynamic binding frame when it is
;;    created and keeps it for as long as it is parked
(def ^:dynamic *request-body* nil)

(defn go-loop-leak []
  (let [events (async/chan)]
    (binding [*request-body* (byte-array (* 20 1024 1024))]
      (async/go-loop []
        (when (async/<! events)
          (recur))))
    events))

;; 3. registry: a def'd atom that only ever grows
(defonce handlers (atom {}))

(defn register-handler! [handler-id]
  (swap! handlers assoc handler-id (byte-array (* 256 1024))))

(defn registry-leak []
  (doseq [handler-id (range)]
    (register-handler! (str "handler-" handler-id))))

(defn -main [scenario]
  (case scenario
    "memoize" (memoize-leak)
    "registry" (registry-leak)))

Ask the JVM to write one when it dies:

clojure -J-Xmx64m -J-XX:+HeapDumpOnOutOfMemoryError \
        -J-XX:HeapDumpPath=memoize.hprof -M -m leak memoize

java.lang.OutOfMemoryError: Java heap space
Dumping heap to memoize.hprof ...
Heap dump file created [63807603 bytes in 0.049 secs]

Or take one from a process that is still alive, which is the long-running REPL case:

jcmd <pid> GC.heap_dump live.hprof     # full dump
jcmd <pid> GC.class_histogram          # no dump, just counts by class

With 100 memoized calls and 100 registered handlers loaded, the histogram's first line is:

 num     #instances         #bytes  class name (module)
   1:         37995       54909984  [B (java.base@21.0.4)

52 MB of that is the 200 byte arrays of 256 KB each. The histogram cannot say which of the two leaks owns which half, or that anything owns them at all. That is the question a dump answers and a histogram does not, and it is the case for opening Eclipse MAT.

A dump is in JVM names. clojure.repl/demunge turns them back:

(require '[clojure.repl :refer [demunge]])
(demunge "leak$render_report")             ;;=> "leak/render-report"
(demunge "leak$register_handler_BANG_")    ;;=> "leak/register-handler!"
(class leak/render-report-memo)            ;;=> clojure.core$memoize$fn__6969

The last line is the one to remember: a memoized function is not an instance of your function's class. It is an anonymous clojure.core$memoize$fn, and the cache hangs off it.

The 20 MB array is bound only for the duration of binding. After the form returns nothing in the program names it. It is still live:

parked:
   1:         37558       23436840  [B (java.base@21.0.4)
after (async/close! events):
   1:         37618        2467952  [B (java.base@21.0.4)

21 MB held by a parked go block, released when the channel closes and the loop exits.

Not run here; MAT is not installed on this machine. The standard path:

1. Open the .hprof. Take the Leak Suspects report as a first guess only.
2. Dominator Tree, sorted by retained heap. Expect one clojure.lang.Atom or PersistentHashMap holding most of the heap.
3. On that object: Path to GC Roots, excluding weak and soft references. For the registry the path ends at a clojure.lang.Var named leak/handlers. For memoize it passes through clojure.core$memoize$fn to the var leak/render-report-memo.
4. Predict before looking: the memoize and registry dumps are both about 64 MB of byte[] under a hash map. The path to the root is what tells them apart.

• Which MAT views does he use first, and which does he ignore?
• How does the core.cache issue differ from plain memoize? core.memoize shows up in the histogram above only because core.async depends on it.
• Does the dynamic-var capture show up as a clojure.lang.Var$Frame in the path to roots?

Related here: gc-viz, a tri-color mark-sweep collector on a tiny heap, for what "reachable from a root" means.

Notes pending.

The abstract does not name scope-capture or FlowStorm. They are the nearest public tools to "local variable-capture macros" and "step through historical transitions", and are guesses at what the talk shows.

The site's REPL notes start from a developer or an agent at a prompt. This talk starts from an incident: a pipeline pulls one failing entity's history and writes the namespace for you. The nearest thing here is the transcript loader in Time-Travel Chat. Nothing here generates a REPL session from production data.

Also on the same thread: Wednesday's Backseat Driver workshop, and Santiago Cabrera's "long-running REPL session" leaks in the 2:30 talk.

• What is redacted between production and the scratch file, and where?
• Is the scratch namespace committed, or thrown away after the incident?
• What stops an agent's hot-patch from reaching anything but the local REPL?

Notes pending.

Redefine a function in a running program; callers see the new one.

(def order {:id 7 :items [:tea]})
(defn total [order] (count (:items order)))
(total order)   ;;=> 1
(defn total [order] (* 2 (count (:items order))))
(total order)   ;;=> 2

Ask the running program what it contains.

(require '[clojure.string :as string])
(:arglists (meta #'string/join))   ;;=> ([coll] [separator coll])
(count (ns-publics 'clojure.string)) ;;=> 21

The DSL is ordinary data, so ordinary functions build it.

[:ul (for [item (:items order)] [:li (name item)])]
;;=> [:ul ([:li "tea"])]

The bio mentions it. The shape is one changed word:

(defn parse-record [line] (Thread/sleep 100) (count line))
(def lines (repeat 16 "record"))
(time (doall (map parse-record lines)))    ;; 1657 ms
(time (doall (pmap parse-record lines)))   ;;  227 ms, 10 cores

Elsewhere: Java parallel streams, Python multiprocessing.Pool.map (process overhead, pickling), Rust's rayon par_iter, Elixir Task.async_stream.

• How much of 90,000 to 12,000 is the language and how much is the rewrite? A second system is smaller in any language.
• Which headwind did the agent not absorb?

Related here: What Survived Clojure, which already cites this talk, and Building a Clojure Agent Environment.

Notes pending.

From the bio: computer science at CU Boulder; web 3D graphics at Anark; lossless compression for GIS at SRC; led the PhysX debugger team at NVIDIA; since then, neural networks and data-intensive systems. His GitHub account dates from December 2008.

The protocol implementation

ham-fisted.defprotocol describes itself as an "alternative protocol implementation". Its stated features: a subclass can override a subset of methods and inherit the rest; primitive type hints on arguments and returns; no writes to global variables per call, so less cache traffic under contention; extending a method that does not exist is an error at extension time.

The var work

his fork of Clojure has a lazy-vars branch, last touched 2024-03. The name fits "a novel compiler approach to vars"; whether it is what the talk presents is a guess.

Stock protocols cache the last dispatched class per call site, which is the write the first claim removes. Thursday's keynote slides argued for runtime information and flexibility; this talk argues the runtime under them can be rebuilt.

• Clojure/Conj 2023: High Performance Clojure.
• Clojure/Conj 2019: Extending Clojure with Python, the libpython-clj talk.
• Python Built-in Functions via libpython-clj2.

• "Provably better": a proof of what property, and against which workload?
• Do the var changes keep redefinition at the REPL, or trade some of it away?
• Is any of this proposed for Clojure itself, or does it stay in libraries?
• Same slot, other room: Burin Choomnuan on ClojureDart in production.

Notes pending.

A guess at the mechanism, not the talk's code. A macro sees the position of the form that called it, so it can stamp that position onto the element. Run on Clojure 1.12.6:

(ns views)

(defmacro located
  "Hiccup element that remembers the form that wrote it."
  [[tag & children]]
  (let [{:keys [line column]} (meta &form)]
    `[~tag {:data-src ~(str *file* ":" line ":" column)} ~@children]))

(defn cart-row [item]
  (located [:div.row (name item)]))

(defn cart [items]
  (located [:ul (map cart-row items)]))

(cart [:tea])
;;=> [:ul {:data-src "views.clj:13:3"}
;;        ([:div.row {:data-src "views.clj:10:3"} "tea"])]

That is the page-to-editor half: the browser reads data-src on hover and tells the editor to open it. It also shows the distinction the abstract ends on. views.clj:10 is where cart-row is defined; the row was asked for at line 13. One attribute cannot carry both.

In the terms of Context Surfaces, a rendered page is a surface that has lost its provenance: it can be read, but it cannot say where a given part came from. The inspector puts that back. The same loop serves an agent as well as a person, since an agent looking at a page has the same question.

The neighbouring talks at this conference: Juliana Prieto's Thursday session does for a production incident what this does for a div, and Thursday's keynote slide asked for "telemetry in language of intent/design".

• How are definition and call site both carried to the browser?
• Does it survive Hiccup built by plain functions and for, with no macro at the call site?
• Is the stamping stripped in production builds, and how?
• The abstract says server-rendered. What changes for Reagent or Replicant?

Notes pending.

Facts go in, rules fire, derived facts come out. Run on Clojure 1.12.6 with com.cerner/clara-rules 0.24.0:

(ns underwrite
  (:require [clara.rules :refer [defrule defquery insert! insert
                                 fire-rules query mk-session]]))

(defrecord Loan [id amount])
(defrecord Income [loan-id monthly])
(defrecord Debt [loan-id monthly])
(defrecord Finding [loan-id code])

(defrule debt-to-income-too-high
  [Income (= ?loan loan-id) (= ?income monthly)]
  [Debt (= ?loan loan-id) (= ?debt monthly)]
  [:test (> (/ ?debt ?income) 0.43)]
  =>
  (insert! (->Finding ?loan :dti-over-43)))

(defquery findings []
  [?finding <- Finding])

(-> (mk-session 'underwrite)
    (insert (->Loan 1 300000) (->Income 1 8000) (->Debt 1 4000)
            (->Loan 2 300000) (->Income 2 8000) (->Debt 2 2000))
    (fire-rules)
    (query findings))
;;=> ({:?finding #underwrite.Finding{:loan-id 1, :code :dti-over-43}})

The rule never says when to run or in what order. That is the appeal, and it is also why a release can break something far from the change: with thousands of rules, which ones fire depends on every other rule's output.

Forward chaining is one of several things called logic programming. Prolog and Datalog chain backward from a query; miniKanren searches relations; Drools and CLIPS are the forward-chaining relatives of Clara.

• Logic Programming with MiniKanren and the miniKanren Tutorial.
• What Survived Clojure cites this talk: Clara Rules in mortgage underwriting since 2021.
• Modeling Apache Redirect Rules in TLA+: a small rule set whose interactions needed a model checker to see.

• What is the tooling: rule coverage, fact provenance, a diff of firings between two releases?
• Can a derived fact be traced back to the rules and facts that produced it?
• What did the fork change that the original would not take?

Notes pending.

From the repository's README. Over the alphabet {0, 1}, accept strings that start with 1, end with 1, and strictly alternate. 1, 101 and 101010101 belong; the empty string, 0, 01, 1010, 1001 and 101100101 do not. The task is to recognise the language as a DFA, a regular expression, a context-free grammar and more.

A version written here before reading his, to compare against. A DFA is a map; running it is a reduce. Run on Clojure 1.12.6:

(def alternating
  {:start :q0
   :accept #{:q1}
   :delta {[:q0 \1] :q1
           [:q1 \0] :q2
           [:q2 \1] :q1}})

(defn accepts? [{:keys [start accept delta]} input]
  (contains? accept
             (reduce (fn [state symbol] (get delta [state symbol] :dead))
                     start
                     input)))

(mapv (partial accepts? alternating) ["1" "101" "101010101"])
;;=> [true true true]
(mapv (partial accepts? alternating) ["" "0" "01" "1010" "1001" "101100101"])
;;=> [false false false false false false]

(mapv #(boolean (re-matches #"1(01)*" %)) ["1" "101" "1010" "1001"])
;;=> [true true false false]

The machine is data, so it can be printed, drawn, tested and generated. That is presumably the talk's point.

• Domain-Specific Languages (DSLs).
• Order State Flow: four state machines from a TLA+ spec as an executable core, the same machine-as-data idea outside the classroom.
• Thursday's Clojure in Academia (Jim Newton, EPITA) is the other teaching talk on the program.

• How is the Turing machine represented, and how do students debug one?
• What do students get wrong that the simulator makes visible?
• Is there a measured outcome over the five years, or is it a report of practice?

Notes pending.

Clojars has a public API. One number from it, read on 2026-10-01: com.cerner/clara-rules, the library from the morning's rules talk, has 765,776 downloads.

curl -s https://clojars.org/api/artifacts/com.cerner/clara-rules \
  | jq '.latest_version, .downloads'

"0.24.0"
765776

Supply-chain risk has come up here from the other ecosystems:

• The June 2 brief covered an npm supply-chain incident.
• BSides CambridgeMA 2026: MCP tool poisoning and malicious skill registries, the same attack one layer up.

• Which of the security changes are enforced on deploy, and which are opt-in?
• What should a deps.edn consumer pin: versions, checksums, both?
• How does a git dependency, which bypasses Clojars entirely, fit the advice?
• Who pays for it, and how many people can deploy to production?

Notes pending.