Optimize Migrated Clojure Code After Profiling

Optimizing Clojure code should be boring and evidence-driven. Java engineers often reach first for types, loops, and mutable structures because those tools are familiar. In Clojure, start by making the code correct and measurable, then optimize only the parts profiling identifies.

The wrong performance process is “rewrite idiomatic Clojure until it looks like Java.” The right process is “measure, locate the cost, apply the smallest optimization that preserves clarity.”

Optimization Order

This order keeps performance work reviewable. Most migrated code should not start at the bottom of the table.

Remove Reflection At Java Boundaries

Reflection appears when Clojure cannot determine a Java method target at compile time. It is common near migrated Java APIs.

1(set! *warn-on-reflection* true)
2
3(defn customer-prefix [^String customer-id]
4  (.substring customer-id 0 3))

The type hint tells the compiler that customer-id is a String, so the Java method call can be emitted directly. Type hints are especially useful at interop boundaries, not as decoration on every local value.

Avoid type-hint clutter. If a hint does not remove a warning or help a proven hot path, it probably does not belong.

Choose Data Structures By Access Pattern

Java engineers are used to choosing between ArrayList, HashMap, HashSet, and arrays. Clojure has the same need for deliberate choice.

Do not choose a list because it “looks Lisp-like.” In practical Clojure, vectors and maps are often the default data structures for application data.

Reduce Intermediate Collections

An idiomatic pipeline is a good starting point.

1(defn taxable-total [orders]
2  (->> orders
3       (filter :order/taxable?)
4       (map :order/amount)
5       (reduce + 0M)))

If profiling shows this path is hot, a transducer can express the same transformation without producing intermediate lazy sequence steps.

1(defn taxable-total [orders]
2  (transduce (comp (filter :order/taxable?)
3                   (map :order/amount))
4             +
5             0M
6             orders))

Use this when measurement shows allocation or sequence overhead matters. Do not replace every readable pipeline with a transducer just because transducers sound advanced.

Use Transients For Local Bulk Building

Persistent maps are usually fine. When profiling shows that a tight loop builds a large map, transients can reduce allocation while keeping mutation local.

1(defn index-by-id [orders]
2  (persistent!
3    (reduce (fn [idx order]
4              (assoc! idx (:order/id order) order))
5            (transient {})
6            orders)))

The mutation is contained inside the function. Callers still receive an immutable map.

Avoid Premature Low-Level Code

Clojure can use primitive arrays, type hints, mutable locals through loops, and Java interop for hot paths. These are useful tools, but they should be deliberate exceptions.

When optimization changes the shape of the code, add comments that explain the measured reason. Future maintainers need to know it is intentional.

Practice

1. Enable reflection warnings for one migrated namespace and remove one real warning.
2. Pick a pipeline and decide whether it is hot enough to justify a transducer.
3. Replace one accidental list with a vector, map, or set that better fits the access pattern.
4. Write a short note explaining why a low-level optimization is or is not justified.

Key Takeaways

• Optimize after behavior is tested and performance is measured.
• Type hints are most useful for reflection and hot interop boundaries.
• Data structure choice matters as much in Clojure as it does in Java.
• Transducers and transients are tools for measured hot paths, not default style.
• Low-level JVM tactics belong behind tests and comments that explain the trade-off.

Quiz: Optimizing Clojure Code