Prioritize Java-to-Clojure Migration Candidates

Prioritizing migration candidates turns a long list of Java modules into an ordered learning path. The first migration should not be the most painful system in the company. It should be valuable enough to matter, isolated enough to finish, and reversible enough that the team can learn without betting the release calendar on a rewrite.

Clojure adoption works best when early wins prove three things: the team can model domain behavior as data, Java and Clojure can interoperate cleanly, and tests can prove equivalence. Use prioritization to protect those goals.

Score Payoff And Risk Separately

A module with high payoff and high risk is not automatically first. A module with moderate payoff and low risk often makes a better pilot because it builds team fluency and deployment confidence.

Score each factor from 1 to 5, but keep the discussion more important than the number. The score should expose disagreements, not replace engineering judgment.

Prefer A Migration Ladder

Early migration candidates should climb from low blast radius to higher-value service code. This avoids the common failure mode where a team starts with a core subsystem, discovers missing tests and ownership gaps, and then blames Clojure for a planning problem.

The ladder is not about avoiding hard work. It is about sequencing hard work after the team has evidence that the migration path works.

Make Reversibility Explicit

If Java will keep calling the migrated behavior, define the boundary before ranking a candidate. A reversible boundary lets you compare behavior, run both implementations in tests, and roll back without reverting a large architectural change.

1public interface DiscountPolicy {
2    Money discountFor(Customer customer, Cart cart);
3}

A Clojure implementation can live behind this interface through an adapter while the rest of the Java application continues to depend on the same contract.

1(ns pricing.discount)
2
3(defn discount-for [{:customer/keys [tier]} {:cart/keys [subtotal]}]
4  (cond
5    (= tier :enterprise) (* subtotal 0.15M)
6    (> subtotal 1000M)   (* subtotal 0.05M)
7    :else                0M))

This is a better pilot than rewriting the whole checkout service because the team can test the rule function directly, compare results against the Java implementation, and keep framework ownership unchanged.

Treat Performance Claims As Hypotheses

Do not rank a candidate first because someone assumes Clojure will be faster. Rank it first only if the current bottleneck is measured, the migrated shape is plausible, and the team has a benchmark or production-like fixture.

Sometimes the best performance migration is no migration at all. If the bottleneck is a database query or network call, prioritize a Clojure rewrite only if it also improves maintainability or correctness.

Choose A First Batch

A practical first batch usually contains two or three modules, not one large rewrite. Pick candidates that exercise different migration concerns without overwhelming the team.

Good first-batch mix:

• one pure transformation or validation rule
• one Java-facing adapter that calls a Clojure namespace
• one test harness that compares Java and Clojure behavior from fixtures

Poor first-batch mix:

• one entire subsystem with weak tests
• multiple framework migrations at once
• performance-critical code without a benchmark
• code owned by a team that cannot review Clojure changes

Practice

1. List five possible migration candidates from your Java system.
2. Score each one for payoff, risk, test coverage, reversibility, and learning value.
3. Select one pilot and one delayed candidate. Write the reason for each decision.
4. Define the Java boundary that would call the first Clojure namespace.

Key Takeaways

• Prioritization should balance payoff, risk, reversibility, tests, and team learning.
• Start with valuable seams, not the largest or most frustrating subsystem.
• Treat performance improvements as measured hypotheses.
• Keep Java boundaries stable while Clojure proves behavior behind them.
• A good first batch teaches the migration process without forcing a big-bang rewrite.

Quiz: Prioritizing Java Code For Migration