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. Choose Clojure when immutable data and interactive development matter most, especially for data pipelines and backends, and choose a mainstream JVM language when team familiarity dominates.

Lisp, modernised

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