Clojure Explained: A Modern Lisp on the JVM

Introduction

Lisp is the second-oldest programming language still in use, and most programmers have never written it — yet its ideas (code as data, functions as values, macros) shaped everything after it. Clojure, released in 2007, is Lisp rebuilt for the modern world: it runs on the JVM, uses every Java library, and replaces Lisp's mutable lists with immutable data structures. It is the language that convinced a generation of sceptics that parentheses are not a problem — they are the point.

Immutable data, code as data, and the REPL

Clojure's model rests on a few distinctive ideas:

• Immutable data by default — maps, vectors, and sets never change in place; "updating" returns a new version, so concurrent code shares data safely and old versions stay available.
• Code as data — Clojure code is itself a data structure (lists), so programs can manipulate programs: macros, the feature other languages fake with code generation, are native.
• The REPL — develop interactively: evaluate expressions, inspect state, and reshape a running program without restarting it. The REPL is not a toy; it is the workflow.
• JVM hosted — every Java library works, so Clojure programs deploy wherever Java does, with none of the ecosystem risk of a niche runtime.

A tiny example shows the shape — a function, a map, and immutable transformation:

;; A user, and a function that "ages" them — returning a new map
(def user {:name "Ayesha" :age 25})
(defn birthday [u]
  (update u :age inc))
(birthday user)
;; => {:name "Ayesha" :age 26}
;; user itself is unchanged — still 25

No mutation, no classes, just data and functions — and the original value is still there, untouched, for any other code that needs it.

The honest trade

Clojure's trade is familiarity and hiring: parentheses and prefix notation take adjustment, startup time is JVM-slow, and the talent pool is small. Error messages, from the JVM stack, can be cryptic. The rule of thumb: Clojure when immutable data and interactive development matter most, especially for data pipelines and backends; a mainstream JVM language when team familiarity dominates.

Takeaway

Clojure is a modern Lisp on the JVM: immutable data, code as data, and REPL-driven development, with every Java library available. It trades familiarity for simplicity that scales — and for programmers who learn it, parentheses stop looking strange and start looking honest.

Originally published at https://practicaldevblog.blogspot.com/2026/10/clojure-explained-modern-lisp-on-jvm.html