Syntax Differences From Java

The biggest syntax mistake Java developers make is assuming Clojure is Java with different punctuation. It is not. Clojure has less syntax, but the syntax it keeps reflects a different execution model: forms evaluate to values, data is represented directly, and mutation is explicit rather than the default local habit.

Read Clojure by asking what shape a form has and what value it produces. Do not start by looking for the nearest Java statement.

The Core Translation Shift

This is not a rejection of Java engineering discipline. It is a different notation for organizing the same concerns: names, data, behavior, boundaries, and effects.

Prefix Calls Replace Mixed Call Syntax

Java mixes operator syntax, constructor syntax, method syntax, static calls, and control statements:

1int total = Math.round((subtotal - discount) * taxRate);

Clojure uses a uniform call shape:

1(Math/round (* (- subtotal discount) tax-rate))

At first, prefix notation feels backward. The advantage is that nesting is explicit and uniform. You do not need separate syntax rules for operators and ordinary calls.

When nesting gets hard to read, use a threading macro:

1(-> subtotal
2    (- discount)
3    (* tax-rate)
4    Math/round)

The threaded form is still an expression. It returns a value; it does not mutate subtotal.

Conditionals Return Values

Java often uses conditionals to choose which assignment happens:

1String label;
2if (count > 0) {
3    label = "positive";
4} else {
5    label = "zero";
6}

Clojure usually binds the result of the conditional directly:

1(def label
2  (if (> count 0)
3    "positive"
4    "zero"))

That pattern is everywhere. if, cond, case, let, and many other forms produce values that can be returned, passed, tested, or composed.

Bindings Are Not Variables You Reassign

Java local variables often act like mutable slots:

1total = total - discount;
2total = total + tax;

Clojure bindings name values:

1(let [discounted-total (- total discount)
2      final-total      (+ discounted-total tax)]
3  final-total)

The habit is to derive a new value and pass it forward. If you need a changing identity, Clojure has reference types such as atoms, refs, agents, and Vars, but those are explicit design choices rather than the default local variable behavior.

Data Literals Replace Constructor Noise

Java often starts domain state with classes and constructors:

1new User(id, email, Status.ACTIVE)

Clojure often starts with direct data:

1{:user/id id
2 :user/email email
3 :user/status :active}

That syntax is not just shorter. It makes attribute names visible at the value boundary. A function can accept, return, log, validate, or transform the map without requiring a class-specific method surface.

Interop Has Its Own Shapes

Real Clojure on the JVM still calls Java. Learn these shapes early:

Do not treat every slash or dot as the same concept. str/trim, Instant/now, and .length are different syntactic categories.

Loops Become Data Transformations First

Java loop:

1List<String> emails = new ArrayList<>();
2for (Order order : orders) {
3    if (order.isPaid()) {
4        emails.add(order.getCustomerEmail());
5    }
6}

Clojure transformation:

1(->> orders
2     (filter :order/paid?)
3     (map :order/customer-email)
4     (into []))

The Clojure version describes what values flow through the pipeline. Use doseq for side effects, loop/recur for explicit recursion, and sequence functions for ordinary collection transformations.

Quick Reading Checklist

Key Takeaways

• Clojure syntax is form-oriented, not statement-oriented.
• Prefix notation gives operators and function calls one uniform shape.
• Conditionals and bindings are value-producing forms.
• Data literals are central to application design, not just convenience syntax.
• JVM interop is explicit and readable once you recognize its shapes.

Quiz: Syntax Differences From Java