Learn Clojure: the best books in order
This curriculum takes an intermediate programmer from Clojure's core syntax and functional fundamentals all the way to idiomatic design, concurrency, and real-world application architecture. Each stage builds directly on the last — establishing the language model first, then deepening functional thinking, and finally tackling advanced patterns and production-grade Clojure.
Foundations: The Clojure Mental Model
BeginnerUnderstand Clojure's syntax, core data structures, REPL-driven workflow, and the functional programming model that underpins everything else.
▸ Study plan for this stage
Pace: 4–5 weeks, ~40–50 pages/day (alternating between books; ~200 pages total per week)
- Clojure's immutable data structures (lists, vectors, maps, sets) and their persistent semantics
- The REPL as a live development environment and how to use it for iterative programming
- Functional programming fundamentals: pure functions, first-class functions, and higher-order functions
- Clojure's syntax: symbols, keywords, forms, and the homoiconicity principle (code as data)
- Sequence abstraction and lazy evaluation for working with collections efficiently
- Destructuring and pattern matching to extract and bind values elegantly
- The distinction between identity and state; atoms and refs for managing mutable state safely
- What are the core immutable data structures in Clojure, and why does immutability matter for functional programming?
- How does the REPL enable a different development workflow compared to traditional compile-and-run languages?
- What is homoiconicity, and how does it allow Clojure code to manipulate code as data?
- Explain the difference between a pure function and a function with side effects, and why pure functions are central to Clojure's design.
- What is destructuring, and how can you use it to simplify binding and function parameters?
- How do lazy sequences work in Clojure, and when would you use them instead of eager evaluation?
- What are atoms and refs, and how do they differ in managing state changes in a functional paradigm?
- Set up a Clojure development environment (install Leiningen or Clojure CLI) and spend 30 minutes exploring the REPL: create variables, call built-in functions, and experiment with different data structures.
- Work through the first 5 chapters of *Clojure for the Brave and True* (syntax, data structures, functions) and replicate every code example in the REPL; modify examples to deepen understanding.
- Create a small utility function that takes a collection of maps (e.g., a list of people with names and ages) and uses destructuring and higher-order functions (map, filter) to extract and transform data.
- Implement a function that generates an infinite lazy sequence (e.g., Fibonacci numbers or counting numbers) and demonstrate how to consume only the first N elements without computing the entire sequence.
- Build a simple command-line program (e.g., a word frequency counter or a to-do list tracker) that uses atoms to manage mutable state and demonstrates the difference between identity and value.
- Read and annotate the chapters on sequences and lazy evaluation from *Programming Clojure*, then write a function that chains multiple lazy transformations (map, filter, take) and explain why this is more efficient than eager evaluation.
Next up: This stage establishes the mental model and syntax foundations necessary to understand Clojure's approach to control flow, state management, and concurrency in the next stage, where you'll learn macros, advanced functional patterns, and how to build larger systems.
The most accessible and engaging entry point into Clojure — it builds intuition for Lisp syntax, immutability, and the REPL without assuming prior Lisp experience. Its humor and clear examples make the paradigm shift feel natural for intermediate programmers.
A thorough, authoritative tour of the language by core contributors — best read right after Brave and True to fill in gaps, solidify vocabulary, and see the full standard library with precision.
Core Depth: Functional Thinking and Idiomatic Style
IntermediateInternalize idiomatic Clojure patterns — sequences, higher-order functions, laziness, destructuring, and the 'Clojure way' of solving problems — and write code that feels native to the language.
▸ Study plan for this stage
Pace: 8–10 weeks, ~25–30 pages/day (alternating between both books; start with "The Joy of Clojure" for conceptual depth, then "Clojure Applied" for practical patterns)
- Sequences as the primary abstraction: lazy sequences, infinite sequences, and the seq interface
- Higher-order functions and function composition: map, filter, reduce, and building custom abstractions
- Destructuring patterns in function arguments, let bindings, and data structures to write concise, readable code
- Laziness and delayed evaluation: when and why to use lazy-seq, and performance implications
- Immutability and persistent data structures as the foundation for reasoning about state
- Idiomatic Clojure style: favoring composition over inheritance, data-driven design, and the 'Clojure way' mindset
- Practical application patterns from 'Clojure Applied': building real systems with idiomatic techniques
- Transducers and advanced sequence operations for composable, efficient transformations
- What is a lazy sequence, and why does Clojure prefer lazy evaluation over eager evaluation?
- How do you use destructuring to extract values from nested data structures, and what are the benefits?
- Explain the difference between map, filter, and reduce—when would you use each, and how do they compose?
- What does it mean to write 'idiomatic Clojure,' and how does it differ from writing Clojure that looks like imperative code?
- How would you design a solution using data-driven patterns rather than object-oriented inheritance?
- What are transducers, and how do they improve performance and composability compared to chained sequence operations?
- Implement a custom lazy sequence generator (e.g., Fibonacci, primes) using lazy-seq and verify it doesn't compute values until accessed
- Refactor an imperative loop-based solution into a functional pipeline using map, filter, and reduce
- Write a function that uses destructuring in multiple contexts: function parameters, let bindings, and sequence unpacking
- Build a small data-driven system (e.g., a simple rules engine or configuration processor) that treats data as code
- Create a higher-order function that takes other functions as arguments and returns a composed function; test it with different inputs
- Implement a transducer that performs a multi-step transformation (e.g., filter, map, take) and use it with both sequences and channels
Next up: This stage equips you with the mental models and practical patterns needed to tackle advanced topics like concurrency, state management, and architectural design—you'll now think in terms of immutable data flows and composable functions, which are essential for building robust, scalable systems.
Goes beyond syntax to explain *why* Clojure is designed the way it is — covering laziness, metaprogramming, and deep functional idioms. It is the essential bridge from knowing Clojure to thinking in Clojure.
Focuses on real-world modeling — how to structure namespaces, manage state, and build production-ready systems idiomatically. It answers the practical 'how do I organize a real project?' questions The Joy of Clojure leaves open.
Concurrency and the JVM: Power Features
IntermediateMaster Clojure's concurrency primitives (atoms, refs, agents, core.async), understand its relationship with the JVM, and leverage Java interop confidently.
▸ Study plan for this stage
Pace: 6–8 weeks, ~40–50 pages/day (focusing on concurrency chapters in both books, with practice days interspersed)
- Atoms: immutable reference semantics with atomic compare-and-swap (CAS) operations for simple, uncoordinated state changes
- Refs and Software Transactional Memory (STM): coordinated, transactional updates across multiple references with ACID properties
- Agents: asynchronous, independent state management with send/send-off for fire-and-forget operations
- core.async: channel-based concurrency using go blocks and parking operations for composable async workflows
- JVM threading model: how Clojure concurrency primitives map to Java threads, locks, and the memory model
- Java interop: calling Java libraries, working with mutable state, and integrating concurrent Java code with Clojure
- Choosing the right primitive: understanding trade-offs between atoms, refs, agents, and core.async for different concurrency patterns
- Practical patterns: producer-consumer, work queues, rate limiting, and coordinated state management in real applications
- What is the difference between atoms and refs, and when would you use each one?
- How does Software Transactional Memory (STM) ensure consistency across multiple refs, and what happens if a transaction conflicts?
- Explain the role of agents in Clojure and how they differ from atoms in terms of synchronicity and coordination.
- What are go blocks in core.async, and how do they enable lightweight concurrency compared to thread-based approaches?
- How do you call Java methods and work with mutable Java objects from Clojure, and what concurrency considerations arise?
- Design a solution using atoms, refs, or agents for a specific concurrent scenario (e.g., a shared counter, a bank transfer, or an async task queue).
- Implement a thread-safe counter using an atom with compare-and-swap semantics; verify it works correctly under concurrent increments from multiple threads.
- Build a simple bank account system using refs and transactions (transfer money between accounts); test it with concurrent transfers and verify no money is lost.
- Create an agent-based logging system that asynchronously writes log messages to a file; send multiple log messages from different threads and verify ordering.
- Implement a producer-consumer pattern using core.async channels and go blocks; measure throughput and latency compared to a thread-based version.
- Write a Java interop example that wraps a mutable Java collection (e.g., ArrayList) with Clojure concurrency primitives; demonstrate thread-safe access.
- Build a rate-limited task queue using core.async that processes jobs asynchronously with a configurable concurrency limit; test with a large batch of tasks.
Next up: This stage equips you with Clojure's full concurrency toolkit and JVM integration skills, preparing you to tackle advanced topics like distributed systems, performance optimization, and production-grade application architecture in the next stage.
The most comprehensive single-volume reference for Clojure, with exceptional coverage of concurrency models, Java interop, and the broader ecosystem — essential reading before tackling advanced architectural topics.
Reinforces concurrency and real-world application patterns through hands-on projects, complementing Emerick's reference-style depth with worked examples that tie concepts together.
Advanced Design: Macros, Abstractions, and Architecture
ExpertWrite powerful macros, design reusable abstractions with protocols and multimethods, and architect large Clojure systems with confidence and elegance.
▸ Study plan for this stage
Pace: 8–10 weeks, ~25–30 pages/day, with 2–3 days per week dedicated to macro implementation and architecture exercises
- Macro fundamentals: quote, unquote, syntax-quote, and gensym for hygienic macro writing
- Advanced macro patterns: recursive macros, macro-generating macros, and compile-time code transformation
- Protocols and multimethods as abstractions for polymorphism and extensible system design
- Abstraction layers: separating interface from implementation to manage complexity in large systems
- Code as data philosophy: leveraging Clojure's homoiconicity to write self-modifying and domain-specific languages
- Architectural patterns: composing abstractions into coherent, maintainable systems with clear boundaries
- Performance and correctness trade-offs when using macros versus functions in system design
- Testing and debugging macros: macroexpand, macro testing patterns, and common pitfalls
- What is the difference between quote, unquote, and syntax-quote, and when should you use each in macro writing?
- How do you write hygienic macros that avoid variable capture, and what role does gensym play?
- What are the key differences between protocols, multimethods, and simple functions as abstraction mechanisms, and when is each appropriate?
- How can you design a large Clojure system using layered abstractions to manage complexity and enable testing?
- What are macro-generating macros, and how do they enable powerful domain-specific language (DSL) construction?
- How do you test macros effectively, and what are common pitfalls to avoid when writing them?
- Write 5–10 progressively complex macros from 'Mastering Clojure Macros': implement when/unless variants, a cond-like macro, and a macro that generates functions with specific signatures
- Build a custom DSL using macros (e.g., a query builder, configuration language, or test framework) that demonstrates code-as-data principles
- Refactor an existing Clojure project to use protocols and multimethods instead of conditionals; document the abstraction boundaries and extensibility gains
- Implement a multi-layer architecture for a non-trivial system (e.g., a web service, data processing pipeline, or game engine) using protocols, multimethods, and clear separation of concerns
- Write and test 3–5 macros using macroexpand to verify correct expansion; test edge cases and variable capture scenarios
- Compare two implementations of the same feature—one using macros and one using functions—and analyze trade-offs in readability, performance, and maintainability
Next up: This stage equips you with the advanced metaprogramming and architectural tools to build sophisticated, extensible Clojure systems; the next stage will likely focus on applying these patterns to real-world domains (web development, data processing, concurrency) or exploring Clojure's ecosystem and production deployment strategies.
A focused, practical guide to one of Clojure's most powerful and misunderstood features — macros. Reading this after building solid idiomatic foundations ensures you use macros to solve real problems rather than create complexity.
A philosophical and deeply practical guide to naming, composition, and system design in Clojure — the capstone of this curriculum, best appreciated after hands-on experience with the language's full feature set.
Discussion
Keep reading
Paths that share books, cover the same subject, or open a related topic.
