Using ^:dynamic *bindings* for awesome!

Quick Intro to Bindings

• Used with dynamic variables
• Thread local

Simple Bindings Demo

(ns my-ns)

(def ^:dynamic *foo* "hello")

(defn print-foo []
  (println *foo*))
          

(ns your-ns
  (:require [my-ns]))

(binding [my-ns/*foo* "world"]
  (my-ns/print-foo))
;; world
(my-ns/print-foo)
;; hello
          

How we use bindings at ReadyForZero

Hiding complexity behind simple interfaces

Tonight's Example: Database Caching Layer

Database Caching Layer

Requirements for a safe to use interface

1. Any function can be cached (within reason)
2. Dependencies are not declared by the programmer
3. Cached functions can call other cached functions (1)
4. DB writes invalidate all dependent cached functions (2) (3)

How do we solve those requirements?

With a tree!

What does that look like?

Functional and Data Dependencies (as code)

(ns app.user
  (:require [app.db :as db]))      

(defn read-accounts [user-id]
  (db/read-model :accounts {:user-id user-id}))

(defn read-payments [user-id]
  (db/read-model :payments {:user-id user-id}))

(defn read-user [user-id]
  {:accounts (read-accounts user-id)
   :payments (read-payments user-id)})
          

What does that look like?

Functional and Data Dependencies (as a tree)

4. DB writes invalidate dependent cached functions

Constructing a dynamic dependency tree with bindings

1. If parent context exists, register with parent
2. Construct a new context
3. Run the function body
4. Save our context and return the result

(ns app.cache
  (:require [app.cache.meta :as meta]))              

;; will be nil or an atom containing a list
(def ^:dynamic *dependencies* nil)

;; register with parent
(defn log-dependency
  "Logs the key as a dependency of the parent 
   cached context, if there is one."
  [dependency-key]
  (when *dependencies*
    (swap! *dependencies* conj dependency-key)))

;; Save context and return the result
(defn save-dependencies [dependency-key]
  (meta/save dependency-key *dependencies))
          

(ns app.user
  (:require [app.db :as db]
            [app.cache :as cache]))
              
(defn read-accounts [user-id]
  ;; register with parent
  (cache/log-dependency :read-accounts)
  ;; Construct a new context
  (binding [cache/*dependencies* (atom '())]
    (let [accounts ;; Run the function body
                   (db/read-model
                     :accounts 
                     {:user-id user-id})]
      ;; Save context and
      ;; return the result
      (cache/save-dependencies :read-accounts)
      accounts)))
          

One Problem...

(ns app.user
  (:require [app.db :as db]
            [app.cache :as cache]))
              
(defn read-accounts [user-id]
  (cache/log-dependency :read-accounts)
  (binding [cache/*dependencies* (atom '())]
    (let [accounts (db/read-model
                     :accounts 
                     {:user-id user-id})]
      (cache/save-dependencies :read-accounts)
      accounts)))
          

Wrap it in a macro!

(defmacro defcachedfn [fn-name fn-args & body]
   (let [fn-key (gen-cache-key fn-name fn-args)]
    `(fn [args#]
       (if-let [cached# (get-cached ~fn-key)]
         cached#
         ;; register with parent
         (log-dependency ~fn-key)
         ;; Construct a new context
         (binding [*dependencies* (atom '())]
           ;; Run the function body
           (let [result# (do ~@body)]
             ;; Save context and
             ;; return the result
             (save-dependencies ~fn-key)
             result#))))))
          

Programmer Peace of Mind

Without caching

(defn read-accounts [user-id]
  (db/read-model :accounts user-id))               
          

(defcachedfn read-accounts [user-id]
  (db/read-model :accounts user-id))               
            

Thanks For Listening

Marshall Brekka - marshall.brekka@avant.com