Buy it!
(35% off with code infoq35)

The Joy of Clojure

Thinking the Clojure Way

A book by Michael Fogus and Chris Houser

We’re really enjoying Clojure, and we’d like to share our knowledge and experience with you. The Joy of Clojure can now be pre-ordered, which gives you access to the first four chapters now, plus more as we write them. If you're not quite ready to buy, you can read the first chapter for free. A large excerpt of chapter 4 is available on InfoQ. Check it out before you decide to buy. For updates on the book itself and Clojure in general, check back here or subscribe at any of our news links listed below.

The table of contents is very much subject to change, but here are our current plans for the book:

News

Fogus:
Chouser:
TABLE OF CONTENTS
    1. Clojure
    2. A Book for the Adventurous
    3. Useful Examples
    4. A Word About Notation
    5. Getting Clojure
    6. Building Clojure
    7. Running Clojure
    FOUNDATIONS
    1. Clojure Philosophy
      1. The Clojure Way
      2. Why a(nother) Lisp?
      3. Functional Programming
      4. Why Clojure is Not Especially Object-oriented
      5. Clojure's Bare Necessities
      6. Summary
    2. Dipping Our Toes Into the Pool
      1. Observe Basic Clojure Style
      2. Using Clojure As a Scripting Language
      3. Truthiness
      4. nil Pun With Care
      5. Using Destructuring
      6. Use the REPL to Experiment
      7. Summary
    DATA TYPES
    1. On Scalars
      1. Understanding Precision
      2. Try To Be Rational
      3. When To Use Keywords
      4. Symbolic Resolution
      5. Regular Expressions - The "Second Problem"
      6. Summary
    2. Composite Data Types
      1. Persistence, Sequences, and Complexity
      2. Vectors: Creating and Using Them in All Their Varieties
      3. Lists: Clojure's Code Form Data Structure
      4. How to Use Persistent Queues
      5. Sets: Persistent and Mathematical
      6. Map Varieties and How to Use Them
      7. Case Study: Finding the Position of Items in a Sequence
      8. Summary
    FUNCTIONAL PROGRAMMING
    1. Being Lazy and Set in Your Ways
      1. On Immutability
      2. Designing a Persistent Toy
      3. On Laziness
      4. Summary
    2. Functional Programming
      1. Functions
      2. Closures
      3. Recursion
      4. Summary
    LARGE-SCALE DESIGN
    1. Macros
      1. Evaluation of Data as Code
      2. Defining Control Structures
      3. Macros Combining Forms
      4. Using Macros When Changing Forms
      5. Using Macros to Control Symbolic Resolution Time
      6. Using Macros to Manage Resources
      7. Macros Returning Functions
      8. The Clojure Arrows
      9. Summary
    2. Combining Data and Code
      1. Namespaces
      2. Exploring Multimethods with the Universal Design Pattern
      3. Types, Protocols, and Reify
    3. Java.next
      1. Generating Java On the Fly
      2. GUI Programming With Clojure gen-class
      3. Understand Clojure's Relationship to Java Arrays
      4. All Clojure Functions Implement...
      5. Be Wary of Exceptions
      6. Extending Clojure
      7. Using Clojure In Your Java Programs
      8. Summary
    4. Concurrency / Mutation Idioms
      1. What STM and Agents Make Easy
      2. When To Use Refs
      3. When To Use Agents
      4. When To Use Atoms
      5. When To Use Primitive Locking
      6. When To Use Futures
      7. When To Use Promise and Deliver
      8. When To Use pmap
      9. Cells
      10. Understanding per-thread Bindings
      11. Summary
    TANGENTIAL CONSIDERATIONS
    1. Performance
      1. Type Hints
      2. Transients
      3. Chunked Sequences
      4. Memoization
      5. Primitives and Coersion
      6. Avoiding Boxed Args with Macros or definline
      7. Hotspot Inlining and Escape Analysis
      8. Summary
    2. Clojure Will Change the Way You Program
      1. DSLs
      2. Testing
      3. Refactoring
      4. A Lack of Design Patterns
      5. Summary
    1. Appendix A: Clojure's Bare Necessities
    2. Appendix B: Tool Support