Clojure Interview Questions

Analogy categoryAnalogies

Preparing for a Clojure Interview

Clojure interviews typically probe three layers: core language fluency (immutable data, the sequence abstraction, destructuring), concurrency reasoning (atoms versus refs versus agents), and practical JVM and tooling knowledge (deps.edn versus Leiningen, the REPL workflow). Unlike interviews in mainstream object-oriented languages, expect more live coding at a REPL rather than a whiteboard, since demonstrating comfort with iterative, REPL-driven development is itself part of what's being evaluated.

🏏

Cricket analogy: A Clojure interview's REPL-driven format is like a net session where a selector watches you adjust your technique ball by ball in real time, rather than a written technique exam — the iterative adjustment process itself is being evaluated, not just the final shot.

Core Language Fundamentals to Master

Be ready to explain the difference between list, vector, map, and set literals and when each is idiomatic — vectors for ordered or indexed data, maps for records, sets for membership tests — and to reason about how persistent structures share structure instead of copying, giving conj on a vector O(1) amortized while conj on a list is O(1) only at the front. Interviewers frequently ask you to implement small sequence functions from scratch, such as your own version of map, filter, or reduce using recur, to test whether you understand laziness and the seq abstraction rather than having memorized the built-in.

🏏

Cricket analogy: Reimplementing map using recur in an interview is like being asked to bowl a genuine yorker instead of just describing one — it proves you understand the mechanics of the seq abstraction rather than having memorized the term.

clojure

;; A common interview prompt: implement map using recur (and reverse-into for output order)
(defn my-map [f coll]
  (loop [remaining (seq coll), acc []]
    (if (empty? remaining)
      acc
      (recur (rest remaining) (conj acc (f (first remaining)))))))

(my-map inc [1 2 3])  ;; => [2 3 4]

;; Contrast with the lazy built-in, which doesn't realize values until consumed:
(def evens (map (fn [x] (println "computing" x) (* x 2)) (range 5)))
(first evens)  ;; only prints "computing 0" -- laziness

Concurrency and State Questions

Expect a question like "when would you use an atom versus a ref versus an agent?" — the correct framing is atom for single independent pieces of synchronous state (a counter, a cache), ref for multiple pieces of state that must change together atomically (transferring money between two accounts via dosync), and agent for asynchronous updates where the caller doesn't need the result immediately (writing to a log). Being able to explain optimistic concurrency — atoms and refs retry the update function if another thread interleaves — versus locking is a strong signal you understand Clojure's concurrency model rather than just its syntax.

🏏

Cricket analogy: Explaining atom vs ref vs agent in an interview is like distinguishing a solo net session (atom, independent), a full team fielding drill requiring everyone to move together (ref, coordinated), and a scoreboard update relayed later by a runner (agent, async) — three different coordination needs.

A classic interview follow-up is "why doesn't swap! need a lock?" The answer: Clojure atoms use compare-and-set at the JVM level, retrying your update function on conflict instead of blocking — which only works safely if the update function is pure and free of side effects.

Common Coding-Exercise Patterns

Common live-coding prompts include parsing and transforming a sequence of maps, such as grouping items by a key with group-by and then computing aggregates with reduce-kv; implementing recursion with recur to avoid stack overflow; and using destructuring in function arguments to pull specific keys out of a map argument cleanly. Practicing the threading macros -> and ->> until they're second nature pays off directly in interviews, since interviewers often judge code cleanliness by whether a candidate reaches for a readable pipeline instead of deeply nested calls.

🏏

Cricket analogy: Using {:keys [...]} destructuring on a match-summary map in an interview is like a captain instantly extracting just the run-rate and wickets-in-hand from a full scorecard without reading every field — the clean, targeted extraction interviewers look for.

clojure

(defn summarize-order
  [{:keys [id items total] :or {items []}}]
  (str "Order " id ": " (count items) " items, total $" total))

(def orders
  [{:id 1 :customer "a" :region "west" :total 20}
   {:id 2 :customer "b" :region "east" :total 35}
   {:id 3 :customer "c" :region "west" :total 15}])

(->> orders
     (group-by :region)
     (reduce-kv (fn [acc region orders]
                  (assoc acc region (reduce + (map :total orders))))
                {}))
;; => {"west" 35, "east" 35}

System Design and JVM Interop Questions

For more senior roles, expect questions about tooling and deployment: the difference between Leiningen's project.clj and tools.deps' deps.edn, how to produce an uberjar for deployment, and how Java interop calls like (.getBytes s "UTF-8") or (Math/sqrt 16) work under the hood. You may also be asked to compare Clojure's approach to a similar problem in another language you know, so be ready to translate a concept like "immutable persistent vector" into terms a Java or Python interviewer would recognize.

🏏

Cricket analogy: Comparing Leiningen's project.clj to deps.edn in an interview is like explaining the difference between an older county-cricket scoring ledger format and a newer digital scoring app a governing body now mandates — both track the same game, different tooling generations.

Don't over-claim performance intuition in an interview. Persistent data structures are fast but not "as fast as a raw Java array" for every operation; interviewers who know the internals will probe claims like "vectors are O(1) for everything," which is false — nth near the end is effectively O(1) via a 32-way branching trie, but it isn't literally constant like a true array access.

Clojure interviews weigh REPL fluency and iterative problem-solving as heavily as the final answer.
Know when to use list, vector, map, and set literals, and be ready to reimplement basic sequence functions with recur.
Master the atom (independent, sync) vs ref (coordinated, sync via dosync) vs agent (independent, async) distinction cold.
Practice destructuring ({:keys [...]}) and threading macros (->, ->>) until they're automatic in live coding.
Be ready to discuss Leiningen vs tools.deps/deps.edn and basic Java interop syntax for senior-level questions.
Avoid over-claiming performance guarantees — persistent vectors are near-O(1), not literally constant-time like raw arrays.
ex-info and structured exception data are common talking points when discussing error-handling design.