# Clojure

> Source: https://aiwiki.ai/wiki/clojure
> Updated: 2026-06-23
> Categories: AI History, Programming Languages
> From AI Wiki (https://aiwiki.ai), a free encyclopedia of artificial intelligence. Quote with attribution.

**Clojure** is a dynamic, general-purpose, functional programming language and a modern dialect of [Lisp](/wiki/lisp), created by [Rich Hickey](/wiki/rich_hickey) and first released on October 16, 2007. It runs primarily on the [Java Virtual Machine](/wiki/jvm) (JVM), with parallel runtimes targeting JavaScript ([ClojureScript](/wiki/clojurescript)) and the .NET Common Language Runtime ([ClojureCLR](/wiki/clojureclr)) [1][2]. In Hickey's own description, "Clojure is a dialect of Lisp, but is not a direct descendant of any prior Lisp. It complements programming with pure functions of immutable data with concurrency-safe state management constructs" [23]. The language emphasizes [immutable persistent data structures](/wiki/immutable_data_structure), first-class functions, [software transactional memory](/wiki/software_transactional_memory) (STM), and concurrency primitives designed to make managing shared state explicit and safer than the lock-based concurrency typical of mainstream object-oriented languages [3].

Clojure was designed as a practical Lisp for working programmers, hosted on an industrial runtime so Java libraries and tooling can be reused directly. The language has a small core, treats data as values, and encourages programs built from small composable functions operating on a handful of generic data structures: lists, vectors, maps, and sets. Its emphasis on immutability has influenced other languages and libraries, including Scala collections and state management in the React ecosystem [4]. In the AI and [data science](/wiki/data_science) world it is used less as a primary numerics platform than as the orchestration, data-engineering, and tooling layer around [machine learning](/wiki/machine_learning) systems, with a growing ecosystem (scicloj, tech.ml.dataset, tablecloth, Neanderthal) and deep [Python](/wiki/python) interoperability for reaching libraries such as NumPy, scikit-learn, and PyTorch [27][28]. Notable users include [Nubank](/wiki/nubank), [Walmart](/wiki/walmart), [Citibank](/wiki/citibank), [Apple](/wiki/apple), [Atlassian](/wiki/atlassian), [Salesforce](/wiki/salesforce), [CircleCI](/wiki/circleci), [SoundCloud](/wiki/soundcloud), and [Metabase](/wiki/metabase).

## When was Clojure created and why?

Rich Hickey began work on Clojure in 2005 while he was a self-employed contract programmer in New York City. He had been writing software for over twenty years, mostly in C++, Java, and Common Lisp, and had grown frustrated with the difficulty of writing correct concurrent programs in object-oriented languages. He took a self-funded sabbatical of roughly two and a half years to design a new language combining three goals at once: a Lisp, with strong support for functional programming, running on a popular industrial platform [6].

Hickey released Clojure publicly on October 16, 2007, by posting an announcement to the comp.lang.lisp newsgroup and launching the clojure.org website. He gave the language's first public talk at the LispNYC meetup in November 2007 and followed with a slot at the 2008 JVM Languages Summit. Within months an active community had formed around the clojure mailing list and the #clojure IRC channel [7][23].

Hickey wrote a now widely cited "Rationale" document explaining the project's goals. He wanted Clojure to be a Lisp without the historical baggage of [Common Lisp](/wiki/common_lisp) or the academic minimalism of [Scheme](/wiki/scheme) and [Racket](/wiki/racket); a language for functional programming with immutability as the default; a hosted language that leveraged the [Java](/wiki/java) ecosystem; and concurrency designed into the language rather than bolted on. These four pillars (Lisp, functional, hosted, concurrent) have remained the core design philosophy ever since [8].

Clojure 1.0 was released on May 4, 2009, marking the first version with stable APIs and an officially blessed contributor process. The release of *Programming Clojure* by Stuart Halloway later in 2009 helped accelerate adoption beyond the early adopter pool [9].

## Core language features

Clojure is a Lisp, which means programs are written as data: source code consists of nested lists and other literal data structures read and evaluated by the same machinery the program uses at runtime. This property, called [homoiconicity](/wiki/homoiconicity), is the foundation of Clojure's macro system.

The core data structures are immutable and persistent. When you "modify" a vector or map in Clojure, you do not mutate the original; you receive a new structure that shares most of its memory with the previous version through structural sharing. The implementation is based on [Hash Array Mapped Tries](/wiki/hash_array_mapped_trie) (HAMTs), a technique published by [Phil Bagwell](/wiki/phil_bagwell) in 2001 that gives near constant time lookup, insertion, and update for very large collections [10].

The language has a compact but powerful set of core features:

* **First-class functions, closures, and higher-order functions.** Functions are values that can be passed, returned, and stored.
* **Lazy sequences.** Collection-processing functions like map, filter, and reduce return lazy sequences that compute elements on demand, supporting potentially infinite streams. See [lazy evaluation](/wiki/lazy_evaluation).
* **Software Transactional Memory.** Coordinated synchronous mutation of multiple values uses refs and the dosync macro.
* **Atoms, agents, and vars** cover uncoordinated synchronous, asynchronous, and thread-local state respectively.
* **Macros.** Compile-time code transformations written in Clojure itself, with syntax-quote and unquote-splicing for hygienic templating.
* **Reader macros.** A small fixed set of literal syntaxes (#{} for sets, #"..." for regexes, #(...) for anonymous functions). Unlike [Common Lisp](/wiki/common_lisp), users cannot extend the reader at will.
* **Polymorphism via [multimethods](/wiki/multimethod) and [protocols](/wiki/protocol_clojure).** Multimethods support arbitrary [multiple dispatch](/wiki/multiple_dispatch). Protocols are a faster, single-dispatch mechanism compiling to JVM interface calls.
* **[Java](/wiki/java) interop.** Direct calls to any Java method, constructor, or static field with no foreign function interface overhead. The gen-class macro generates AOT-compiled JVM classes when needed.
* **[EDN](/wiki/edn).** Extensible Data Notation, the data subset of Clojure syntax, is widely used for configuration files and network payloads.

A small example illustrates the syntax and the data orientation:

```clojure
(defn word-frequencies [text]
  (->> text
       (re-seq #"\w+")
       (map clojure.string/lower-case)
       frequencies
       (sort-by val >)
       (take 10)))
```

The ->> threading macro pipes a value through a series of expressions, reading top to bottom and avoiding deeply nested calls. Functions like frequencies, sort-by, and take all return immutable collections, never mutating their inputs.

Clojure programs are typically developed at a [REPL](/wiki/repl). A running Clojure process accepts new code at any time, recompiles individual functions, and inspects live program state. Most Clojure developers connect their editor directly to a running REPL inside the application they are building, evaluating expressions in place rather than restarting the program.

## How does Clojure handle concurrency?

Clojure's most distinctive contribution to language design is its treatment of identity, state, and time as separate concepts. Hickey argued in his 2009 talk "Are We There Yet?" that conflating identity with state in object-oriented programming is the root cause of most concurrency bugs. In Clojure, an immutable value is what you observe; an identity is a name pointing to a succession of values over time; and the language provides four reference types that bind names to values under different concurrency policies [11].

| Reference type | Coordination | Synchrony | Typical use |
| --- | --- | --- | --- |
| Var | None (per-thread) | Synchronous | Dynamic binding, configuration, per-request context |
| Atom | Uncoordinated | Synchronous | Independent counters, caches, single-cell state |
| Ref | Coordinated (STM) | Synchronous | Transfers between accounts, multi-cell invariants |
| Agent | Uncoordinated | Asynchronous | Background work, decoupled updates |

Refs use a multi-version concurrency control STM modeled on database transactions. Inside a dosync block, reads see a consistent snapshot and writes either commit atomically or retry on conflict. Atoms use compare-and-swap on a single cell. Agents queue updates and apply them in the background.

In 2013 the [core.async](/wiki/core_async) library introduced a fifth model: [Communicating Sequential Processes](/wiki/csp), modeled on [Tony Hoare](/wiki/tony_hoare)'s 1978 CSP paper and on Go's goroutines. Channels are first-class values; the go macro rewrites blocking channel operations into a state machine that runs on a small thread pool [12].

[Reducers](/wiki/reducers) (Clojure 1.5, 2013) and [transducers](/wiki/transducers) (Clojure 1.7, 2014) extend the model further. Transducers are composable algorithmic transformations decoupled from the input or output collection; the same transformation can apply to a vector, a lazy sequence, a channel, or an observable stream [13]. Clojure does not natively implement the [actor model](/wiki/actor_model) in the Erlang sense; agents share some surface similarities but lack mailboxes and supervision trees.

## ClojureScript

[ClojureScript](/wiki/clojurescript) is a compiler that targets [JavaScript](/wiki/javascript) instead of JVM bytecode. Hickey announced ClojureScript at [Strange Loop](/wiki/strange_loop) in St. Louis on July 20, 2011. The compiler emits JavaScript that is then minified by the Google Closure Compiler, taking advantage of Closure's whole-program optimizations to produce small, dead-code-eliminated bundles [14].

ClojureScript is a near-complete subset of Clojure. Persistent data structures, lazy sequences, macros, multimethods, protocols, and core.async all work the same way. The main differences come from the host platform: there is no STM (because the JavaScript runtime is single-threaded), no agents, no first-class threads, and macros must be defined in Clojure files because compilation and runtime are separated.

The ClojureScript front-end ecosystem is dominated by [Reagent](/wiki/reagent) and [re-frame](/wiki/re_frame), a thin idiomatic wrapper around React combined with a Redux-like state management framework that predates Redux. Earlier libraries like [Om](/wiki/om_clojurescript) by David Nolen demonstrated immutable data structures plus React-style virtual DOM rendering and inspired several non-Clojure libraries. The [shadow-cljs](/wiki/shadow_cljs) build tool by Thomas Heller has become the standard for ClojureScript projects, offering hot module reload and npm integration. Production users of ClojureScript include CircleCI's web UI, Pitch.com's collaborative slide editor, [Roam Research](/wiki/roam_research)'s outliner, and large parts of Nubank's customer-facing tooling.

## Other variants

Besides ClojureScript, several other Clojure runtimes target additional platforms:

* **[ClojureCLR](/wiki/clojureclr)** is a port of Clojure to the .NET Common Language Runtime, created and maintained by David Miller since 2009. It tracks the JVM version closely and supports interop with .NET libraries.
* **[ClojureDart](/wiki/clojure_dart)** targets Dart and the [Flutter](/wiki/flutter) UI toolkit. It was started by Christophe Grand and Baptiste Dupuch in 2022 and lets developers build cross-platform mobile applications in Clojure while reusing Flutter's widget library.
* **[Babashka](/wiki/babashka)** is a native-compiled Clojure scripting tool created by Michiel Borkent in 2019. Babashka uses [GraalVM](/wiki/graalvm) native-image to produce a small, fast-starting binary that interprets Clojure scripts. It has become the de facto choice for shell scripting and CI/CD glue, where the JVM's historical one-second startup time was prohibitive; in the State of Clojure 2024 survey it was the most widely used alternative dialect, reported by 93% of respondents who answered the question (about two-thirds of all participants) [15][19].
* **Jank** is a native Clojure dialect targeting LLVM, started by Jeaye Wilkerson in 2021. It compiles ahead of time and offers C++ interop.
* **Joker** is a small Clojure-like interpreter in Go, used as a linter and a scripting tool.

## Build tools and ecosystem

For most of Clojure's first decade the dominant build tool was [Leiningen](/wiki/leiningen) ("lein"), created by Phil Hagelberg in 2009. Leiningen wraps [Maven](/wiki/maven) underneath but provides a Clojure-flavored project.clj file, plugins, and a friendly command-line interface [16]. Boot, an alternative tool by Micha Niskin and Alan Dipert, briefly competed with Leiningen by treating the build itself as a Clojure program of pipeline filters.

In 2018 the Clojure core team released the official Clojure CLI tools and the [deps.edn](/wiki/deps_edn) file format, providing a minimal, library-oriented dependency resolver and a clean separation between dependency management and build automation. Most new Clojure projects since 2020 default to deps.edn, with companion tools such as tools.build or Polylith handling build steps.

Dependency artifacts are published on Maven Central or on [Clojars](/wiki/clojars), a community-run Maven-compatible repository hosting tens of thousands of Clojure libraries. Editor support is mature: the canonical Emacs experience is [CIDER](/wiki/cider_emacs), VS Code users rely on [Calva](/wiki/calva), and IntelliJ users rely on [Cursive](/wiki/cursive), a dedicated Clojure plugin for [IntelliJ IDEA](/wiki/intellij_idea) by Colin Fleming. All three integrate with nREPL, the standard network REPL protocol.

## Libraries and frameworks

The Clojure ecosystem favors small composable libraries over heavyweight frameworks. A typical web service might combine four or five independent libraries rather than adopt a single framework.

**Web servers and HTTP.** Ring is the underlying abstraction: a request is a Clojure map, a response is a Clojure map, and middleware is a function wrapping a handler. [Compojure](/wiki/compojure) layers a routing DSL on top. [Pedestal](/wiki/pedestal) is Cognitect's interceptor-based framework with first-class async support. Reitit is a newer data-driven router. Aleph and http-kit provide non-blocking servers built on Netty.

**HTML and frontend.** [Hiccup](/wiki/hiccup) represents HTML as Clojure vectors, a style copied widely outside Clojure. Reagent and re-frame dominate ClojureScript SPAs.

**Data and databases.** next.jdbc is the modern JDBC wrapper. HoneySQL builds SQL from Clojure data. [Datomic](/wiki/datomic) is Cognitect's immutable temporal database, designed around an EAV data model and a Datalog query language. Datascript is an in-memory port of Datomic's API for browser use. XTDB (formerly Crux) is an open-source bitemporal database in Clojure.

**Concurrency and core extensions.** core.async (CSP channels), [core.logic](/wiki/core_logic) (a port of miniKanren for logic programming), core.match (pattern matching), and core.cache.

**Validation.** [clojure.spec](/wiki/clojure_spec) is the official specification library introduced in Clojure 1.9 (2017), used for runtime validation, generative testing, and documentation. Malli is a popular alternative. Plumatic Schema predates spec and is still in wide use. Specter offers a tiny algebra for navigating deeply nested structures. Neanderthal wraps native BLAS/LAPACK and CUDA for high-performance linear algebra.

## Cognitect and Nubank

[Cognitect](/wiki/cognitect) was the steward of Clojure for most of its existence. The company was formed in 2013 from the merger of Relevance Inc. (the consultancy founded by Stuart Halloway and Justin Gehtland in 2003) and Metadata Partners (Hickey's vehicle for funding Clojure work). Cognitect employed several of Clojure's most active maintainers, including Hickey, Halloway, Alex Miller, and Stuart Sierra. It released several flagship products: [Datomic](/wiki/datomic) (2012), Pedestal (2013), and Transit, a JSON-friendly serialization format introduced in 2014 (see [transit format](/wiki/transit_format)) [17].

Nubank, the Brazilian fintech founded in 2013, was already the largest Clojure shop in the world by the late 2010s, running thousands of microservices on Datomic and Kafka. On July 8, 2020, Nubank announced it had acquired Cognitect, bringing the entire core team and Datomic in-house [5]. The Clojure language itself remained openly developed and Apache 2.0 licensed. In April 2022, Hickey announced his retirement from Nubank and from active language development, handing stewardship to Alex Miller.

## Industry adoption

Clojure's industrial footprint is concentrated in domains where correctness and concurrency matter: banking, fintech, e-commerce, developer tooling, and analytics. The State of Clojure 2024 survey found that 73% of respondents use Clojure for paid work, with finance, enterprise software, consumer software, healthcare, and retail or e-commerce as the leading industries [19].

* **[Nubank](/wiki/nubank)** runs thousands of Clojure microservices and, on May 16, 2024, became the first digital bank outside Asia to surpass 100 million customers across Brazil, Mexico, and Colombia [5][26].
* **[Walmart](/wiki/walmart)** Labs built large parts of the e-commerce checkout pipeline in Clojure starting around 2013. Anthony Marcar's talk on Walmart's Clojure adoption is one of the most cited industrial case studies [18].
* **[Citibank](/wiki/citibank)** uses Clojure for trading and risk systems, including derivatives pricing and FX systems.
* **[Apple](/wiki/apple)** engineers have described internal tooling, data pipelines, and identity infrastructure built in Clojure at conferences.
* **[Atlassian](/wiki/atlassian)** uses Clojure in parts of the Jira backend and in internal services.
* **[Salesforce](/wiki/salesforce)**, after acquiring Heroku, inherited Heroku's Clojure footprint and maintains Leiningen plugins and Clojure libraries.
* **[CircleCI](/wiki/circleci)** is built almost entirely in Clojure and ClojureScript.
* **[SoundCloud](/wiki/soundcloud)** used Clojure for its data and search infrastructure during the 2010s.
* **[Metabase](/wiki/metabase)** has its server entirely written in Clojure with a ClojureScript admin UI.
* **Pitch.com** and **[Roam Research](/wiki/roam_research)** are well-known ClojureScript-based products.
* Other documented users include Funding Circle, Klarna, Genius, Puppet Labs, and ThoughtWorks.

The annual *State of Clojure* survey consistently finds web development, data engineering, and back-end services as the dominant use cases [19].

## How is Clojure used for AI and machine learning?

Clojure has a smaller AI and [machine learning](/wiki/machine_learning) community than [Python](/wiki/python) and is rarely chosen as a primary numerics platform. The JVM is well suited to data engineering and inference at scale but lacks the breadth of ML libraries that NumPy, PyTorch, and TensorFlow have built up around Python. As a 2024 SciCloj community review put it, "there are already people doing 'real' machine learning work in Clojure" even though "the Clojure for data science ecosystem is not anywhere near as easy to use or understand as reasonable potential users might expect" [27].

The ecosystem has been consolidating around a small set of [data science](/wiki/data_science) building blocks coordinated by the SciCloj community:

* **scicloj** is the community umbrella project producing dataset libraries and notebook tools. **tech.ml.dataset** is the primary dataframe library on the JVM, often described as the closest thing to pandas, and **tablecloth** is a higher-level data-wrangling API built on top of it. **noj** bundles these into a single consolidated data science toolkit intended as the main entry point [27].
* **Notebook tooling.** Clay and Clerk (the latter from Nextjournal) provide literate, REPL-driven notebooks comparable to Jupyter.
* **Neanderthal**, by Dragan Djuric, wraps native BLAS, LAPACK, Intel MKL, and CUDA for high-performance linear algebra.
* **Tribuo interop.** scicloj.ml.tribuo wraps Oracle's Tribuo Java machine learning library, and scicloj.ml.xgboost exposes XGBoost; the community has favored Tribuo to avoid GPL-licensed dependencies as the older Smile library moved to GPL in its 3.x line [27].
* **dl4clj** wraps Deeplearning4j, the JVM-native deep learning framework.
* **Python interop.** libpython-clj embeds the CPython runtime inside the JVM and lets developers call NumPy, pandas, scikit-learn, TensorFlow, and PyTorch almost as if they were Clojure namespaces, with efficient zero-copy data transfer to tech.ml.dataset; sklearn-clj builds a scikit-learn bridge on top of it [28].

Historical and niche projects include **Cortex**, a pure-Clojure deep learning library with OpenCL GPU support started around 2016 and largely abandoned by 2018, and **clojure-mxnet**, idiomatic bindings to Apache MXNet that became defunct after MXNet was retired in 2023.

For [large language model](/wiki/large_language_model) work, recent libraries such as **Llama.clj**, **bosquet**, and **wkok/openai-clojure** orchestrate LLM workflows, prompt construction, and agent loops from Clojure. In practice, the most common pattern in 2024 to 2026 is to use Clojure as the orchestration and tooling layer (for routing, prompt construction, evaluation harnesses, agent loops, and ETL) while delegating heavy model training and inference either to Python through libpython-clj or to separate Python and GPU services reached over HTTP.

## Conferences and community

The flagship event is **Clojure/conj**, an annual US conference held since 2010, organized originally by Cognitect and since 2020 by community-led groups. **EuroClojure** has run in various European cities since 2012. Earlier regional conferences (Clojure/west, Clojure/north) came and went as the community shifted toward virtual events. **re:Clojure** is a community-run virtual conference held since 2020 [20].

[Strange Loop](/wiki/strange_loop), the multi-paradigm conference held in St. Louis from 2010 to 2023, was not Clojure-specific but became closely associated with the language because Hickey delivered several of his most influential talks there.

The **State of Clojure** annual survey gathers thousands of responses on tooling and developer happiness. The Clojurians Slack workspace (roughly 30,000 members) is the primary chat venue. **ClojureBridge**, launched in 2014, is a global volunteer initiative running free workshops aimed at increasing the participation of underrepresented groups in the community.

## Hickey's influential talks

Rich Hickey's conference talks are among the most widely watched in software engineering, regularly appearing on "best of" lists outside the Clojure community [21]. Selected talks include:

* **"Are We There Yet?"** (JVM Languages Summit, 2009). Lays out Clojure's philosophy of identity, state, and time.
* **"Hammock-Driven Development"** (Clojure/conj 2010). Argues that thinking, not typing, is the bottleneck in software development.
* **"[Simple Made Easy](/wiki/simple_made_easy)"** (Strange Loop 2011). Distinguishes "simple" (one role, one task, untwined) from "easy" (familiar, near at hand). Often cited in architecture discussions.
* **"The Value of Values"** (JaxConf 2012). Defends the idea that values are easier to reason about than places.
* **"The Language of the System"** (Clojure/conj 2015). Argues that the language used between services matters more than the language inside any one service.
* **"Spec-ulation"** (Clojure/conj 2016). Introduces clojure.spec and discusses backward compatibility as an industry-wide problem.
* **"Effective Programs"** (Clojure/conj 2017). Reflects on ten years of Clojure.
* **"Maybe Not"** (Clojure/conj 2018). Critiques optionality in static type systems and motivates spec 2.

## Version history

The Clojure team practices what Hickey calls "slow growth on a stable base" and has avoided breaking changes wherever possible. Programs written for Clojure 1.0 in 2009 generally still compile and run on the latest version with no modification.

| Version | Release date | Highlights |
| --- | --- | --- |
| 1.0 | May 4, 2009 | First stable release; persistent collections, STM, agents, Java interop |
| 1.1 | December 31, 2009 | Futures, promises, chunked sequences |
| 1.2 | August 19, 2010 | Protocols, deftype, defrecord, Maven artifacts |
| 1.3 | September 23, 2011 | Primitive arithmetic, contrib library split |
| 1.4 | April 15, 2012 | Reader literals, EDN, mapv/filterv |
| 1.5 | March 1, 2013 | Reducers, faster persistent collections |
| 1.6 | March 25, 2014 | Java 8 support, hashing changes |
| 1.7 | June 30, 2015 | Transducers, reader conditionals |
| 1.8 | January 19, 2016 | Direct linking, socket REPL, string functions |
| 1.9 | December 8, 2017 | clojure.spec, CLI tools and deps.edn |
| 1.10 | December 17, 2018 | Improved error messages, prepl, Java 11 support |
| 1.11 | March 22, 2022 | Native keyword args, parse-long/parse-double |
| 1.12 | September 5, 2024 | Method values, qualified methods, array class syntax |

Releases since 1.10 have been bug-fix dominant with carefully scoped feature additions, reflecting the project's preference for backward compatibility over fashion-driven changes. By the State of Clojure 2024 survey, taken shortly after release, 58% of respondents had already adopted Clojure 1.12 [19][22].

## Strengths and trade-offs

**Strengths.**

* **REPL-driven development** is unusually well supported. Connecting an editor to a live process and modifying running code is the default workflow.
* **Immutability by default** removes a wide class of concurrency and aliasing bugs and makes equality, hashing, and caching trivially safe.
* **Tight Java interop** means the entire JVM ecosystem (Kafka, Spark, Netty, JDBC drivers, every cloud SDK) is one require away.
* **Stable language design.** Almost no Clojure code ever breaks across versions, a major reason for low maintenance burden in long-running systems.
* **Data orientation.** Most programs traffic in plain maps, vectors, and keywords rather than custom classes, simplifying serialization, debugging, and library composition.

**Trade-offs.**

* **JVM startup latency.** A standard Clojure process historically took close to one second to start, awkward for command-line tools and serverless deployments. Babashka and GraalVM native-image have largely closed this gap.
* **Smaller community** than mainstream languages. Hiring for Clojure-specific experience is harder, although motivated engineers typically learn the language in weeks.
* **Dynamic typing** surfaces a class of errors at runtime that static type systems would catch at compile time. clojure.spec and Malli help but are not replacements for compile-time inference.
* **Tooling learning curve.** Effective Clojure requires comfort with a connected REPL, structural editing (paredit or parinfer), and a Lisp's unfamiliar surface syntax.
* **Smaller talent pool for specialized domains.** ML, mobile-native UI, and game development all have far stronger ecosystems in other languages.

In the experience of teams who use the language at scale, these trade-offs are vastly outweighed by the long-term maintainability benefits of immutability, REPL-driven development, and a stable language [5][19].

## See also

* [Lisp](/wiki/lisp)
* [Common Lisp](/wiki/common_lisp)
* [Scheme](/wiki/scheme)
* [Rich Hickey](/wiki/rich_hickey)
* [ClojureScript](/wiki/clojurescript)
* [Cognitect](/wiki/cognitect)
* [Datomic](/wiki/datomic)
* [Nubank](/wiki/nubank)
* [Software transactional memory](/wiki/software_transactional_memory)
* [Hash array mapped trie](/wiki/hash_array_mapped_trie)
* [Simple Made Easy](/wiki/simple_made_easy)
* [Babashka](/wiki/babashka)
* [GraalVM](/wiki/graalvm)
* [Machine learning](/wiki/machine_learning)
* [Python](/wiki/python)

## References

1. Hickey, R. (2008). "The Clojure Programming Language." *Proceedings of the 2008 Symposium on Dynamic Languages (DLS '08)*. ACM. https://dl.acm.org/doi/10.1145/1408681.1408682
2. Clojure project home page. https://clojure.org/
3. Hickey, R. "Clojure Rationale." https://clojure.org/about/rationale
4. Bagwell, P. (2001). "Ideal Hash Trees." EPFL Technical Report. https://infoscience.epfl.ch/record/64398
5. "Cognitect Is Now Part of Nubank," Cognitect Blog, July 8, 2020. https://www.cognitect.com/blog/2020/7/8/cognitect-is-now-part-of-nubank
6. Fogus, M. "Codequarterly: Rich Hickey Q&A." https://www.codequarterly.com/2011/rich-hickey/
7. Hickey, R. (October 16, 2007). "ANN: Clojure." comp.lang.lisp newsgroup. https://groups.google.com/g/comp.lang.lisp/c/9ATHGbXxR_o
8. Clojure About: Differences with Other Lisps. https://clojure.org/reference/lisps
9. Halloway, S. (2009). *Programming Clojure*. Pragmatic Bookshelf. ISBN 978-1934356333.
10. Hickey, R. (2009). "Are We There Yet?" JVM Languages Summit. https://www.infoq.com/presentations/Are-We-There-Yet-Rich-Hickey/
11. Hickey, R. (2011). "Simple Made Easy." Strange Loop. https://www.infoq.com/presentations/Simple-Made-Easy/
12. Sierra, S. "Clojure core.async Channels." Cognitect Blog, June 28, 2013. https://clojure.org/news/2013/06/28/clojure-clore-async-channels
13. Hickey, R. (2014). "Inside Transducers." Conj 2014. https://www.youtube.com/watch?v=4KqUvG8HPYo
14. Hickey, R. (2011). "ClojureScript." Strange Loop, July 20, 2011. https://www.infoq.com/presentations/ClojureScript/
15. Borkent, M. "Babashka: a Clojure Babushka." https://github.com/babashka/babashka and https://book.babashka.org/
16. Hagelberg, P. "Leiningen for Clojure." https://leiningen.org/
17. "Cognitect: About." https://www.cognitect.com/who-we-are
18. Marcar, A. (2015). "Clojure at Scale @ Walmart." Clojure/west. https://www.youtube.com/watch?v=av9Xi6CNqq4
19. Miller, A. "State of Clojure 2024 Results." Clojure News, December 2, 2024. https://clojure.org/news/2024/12/02/state-of-clojure-2024
20. Clojure/conj official site. https://clojure-conj.org/
21. Fogus, M., and Houser, C. (2014). *The Joy of Clojure*, 2nd ed. Manning. ISBN 978-1617291418.
22. Clojure Changes. https://github.com/clojure/clojure/blob/master/changes.md
23. Hickey, R. (2020). "A History of Clojure." *Proceedings of the ACM on Programming Languages*, Vol. 4, HOPL, Article 71. https://dl.acm.org/doi/10.1145/3386321
24. Higginbotham, D. (2015). *Clojure for the Brave and True*. No Starch Press. https://www.braveclojure.com/
25. Halloway, S., and Bedra, A. (2018). *Programming Clojure*, 3rd ed. Pragmatic Bookshelf. ISBN 978-1680502466.
26. "Nubank Surpasses 100 Million Customers." Nu International, May 16, 2024. https://international.nubank.com.br/100m/nubank-surpasses-100-million-customers/
27. "The Current State of ML in Clojure." Code with Kira (SciCloj community), April 4, 2024. https://codewithkira.com/2024-04-04-state-of-clojure-ml.html
28. "libpython-clj: Python bindings for Clojure." clj-python. https://github.com/clj-python/libpython-clj