We’ll work hard to guide you through the features and semantics of Clojure to help you build the mental model needed to use the language effectively. Most of the samples in this book are designed to be run in Clojure’s interactive programming environment, commonly known as the Read-Eval-Print Loop, or REPL, an extremely powerful environment for experimentation and rapid prototyping.

By the time you’re done with this book, the Clojure way of thinking about and solv- ing problems will be another comfortable tool in your toolbox. If we succeed, then not only will you be a better Clojure programmer, but you’ll also start seeing your pro- gramming language of choice—be it Java, C#, Python, Ruby, J, or Haskell—in an entirely different light. This reassessment of topics that we often take for granted is essential for personal growth.

This book isn’t a beginner’s guide to Clojure. We start fast and don’t devote much space to establishing a running Clojure environment, although there are many available online resources for use as reference, refresh, or autodidacticism:

• The official Clojure API docs
• Community-driven Clojure docs
• Guide to Programming in Clojure for Beginners
• Clojure Koans
• Clojure Wikibook

Fogus is a member of Clojure/core with experience in distributed simulation, machine vision, and expert systems. He can be found on the Internet at:

• Twitter
• Blog
• Tumblog

Some of Fogus’ Clojure-related side-projects include:

• Marginalia
• clache
• unk
• Trammel
• core.unify

Chouser is a key contributor to Clojure who has implemented several of its features. He can be found on the Internet at:

• Twitter
• Blog

Some of Chouser’s Clojure-related side-projects include:

• data.xml
• data.finger-tree

• Verbosity
• Essential boilerplate
• A long thought-code-feedback loop
• Incidental complexity
• Difficulties in extension
• Deficiencies in supporting crucial programming paradigms

In contrast, Clojure provides a mixture of power and practicality fostering rapid development cycles. But its benefits don’t stop with its agile nature.

Clojure provides a unique mix of functional programming and host symbiosis—an embrace of and direct support for its host platform, in this case the Java Virtual Machine. Additionally, the simplification and often elimination of the complexities involved in coordinated state change have positioned Clojure as an important lan- guage moving forward. All software developers must eventually address these prob- lems as a matter of course, and the study, understanding, and eventual utilization of Clojure is an essential path toward conquering them. From topics such as software transactional memory to laziness to immutability, this book will guide you on your way to understanding the “why” of Clojure, in addition to the “how.”

Clojure information, source, and official documentation is found at http://clojure.org.

Abadi, Martin, and Luca Cardelli. 1996. A Theory of Objects New York: Springer. Although not a mathematical concept, object-oriented programming has obtained rigor with this gem.

Abelson, Harold, and Gerald Jay Sussman. 1988. “Lisp: A Language for Stratified Design.” AI Memo (MIT) 986.

———. 1996. Structure and Interpretation of Computer Programs Cambridge, MA: MIT Press. There is no better book for learning Scheme and the fine art of programming.

Abiteboul, Serge, Richard Hull, and Victor Vianu. 1995. Foundations of Databases: The Logical Level. Boston: Addison-Wesley. Clojure’s clojure.set namespace is actually modeled more on the named conjunctive algebra, for which this book provides a great reference.

Armstrong, Joe. 2007. Programming Erlang: Software for a Concurrent World. Raleigh, NC: Pragmatic Bookshelf.

———. 2007. “A History of Erlang.”. Proceedings of the Third ACM SIGPLAN Conference on History of Programming Languages.

Bagwell, Phil. 2001. Ideal Hash Trees. Technical report. Clojure’s persistent data structures owe a lot to Phil Bagwell’s paper.

Baker, Henry. 1993. “Equal Rights for Functional Objects or, The More Things Change, The More They Are the Same.” ACM SIGPLAN OOPS Messenger 4, no. 4.

Beck, Kent. 2002. Test Driven Development: By Example.. Boston: Addison-Wesley.

Bloch, Joshua. 2008. Effective Java. Upper Saddle River, NJ: Addison-Wesley. Perhaps the most essential Java book (1/3).

Boncz, Peter, Zukowski Marcin, and Niels Nes. 2005. “MonetDB/X100: Hyper-Pipelining Query Execution.”. Proceedings of the CIDR Conference. This paper motivated the implementation of chunked sequences.

Bratko, Ivan. 2000. PROLOG: Programming for Artificial Intelligence. New York: Addison Wesley. An utterly fantastic book on Prolog.

Budd, Timothy. 1995. Multiparadigm Programming in Leda. Reading, MA: Addison-Wesley. This is an expanded discussion of the complexities wrought from a mono-paradigm approach to software development.

Clinger, William. 1998. “Proper Tail Recursion and Space Efficiency.”. Proceedings of the ACM SIGPLAN 1998 Conference on Programming Language Design and Implementation.

Cormen, Thomas, Charles Leiserson, Ronald Rivest, and Clifford Stein. 2009. Introduction to Algorithms. Cambridge, MA: MIT Press. This is a great reference on algorithmic complexity and Big-O, and as an added bonus, you could use it to stop a charging rhinoceros.

Crockford, Douglas. 2008. JavaScript: The Good Parts. Yahoo Press.

Date, C.J. 2009. SQL and Relational Theory: How to Write Accurate SQL Code. Sebastopol, CA: O’Reilly.

Dijkstra, Edsger Wijbe. 1959. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1, no. 1. You could change the h function in listing 7.9 to (def dijkstra-estimate-cost (constantly 0)) to conform to the ideal presented in this paper.

Flanagan, David. 2006. JavaScript: The Definitive Guide. Sebastopol, CA: O’Reilly.

Forman, Ira, and Nate Forman. 2004. Java Reflection in Action. Greenwich, CT: Manning. Although reflection provides some meta-level manipulation, it’s quite apart from the notion of functions as data.

Friedl, Jeffrey. 1997. Mastering Regular Expressions. Sebastopol, CA: O’Reilly.

Friedman, Daniel, Mitchell Wand, and Christopher T. Haynes. 2001. Essentials of Programming Languages. Cambridge, MA: MIT Press.

Gabriel, Richard, and Kent Pitman. 2001. “Technical Issues of Separation in Function Cells and Value Cells.”. This is a more thorough examination of the differences between Lisp-1 and Lisp-2.

Gamma, Erich, Richard Helm, Ralph Johnson, and John Vlissides. 1995. Design Patterns: Elements of Reusable Object-Oriented Software.. Reading, MA: Addison-Wesley. Another essential book for Java programmers (2/3).

Ghosh, Debasish. 2010. DSLs in Action. Greenwich, CT: Manning. There is a much finer level of distinction determining what constitutes whole cloth, including that between internal and external DSLs. In this book, we focus on the classical Lisp model of internal DSLs, but DSLs in Action provides a survey of many DSL-creation techniques.

Glickstein, Bob. 1997. Writing GNU Emacs Extensions. Sebastopol, CA: O’Reilly.

Goetz, Brian. 2006. Java Concurrency in Practice. Upper Saddle River, NJ: Addison-Wesley. Why haven’t you read this yet? Essential for Java and concurrent programmers alike (3/3).

Goldberg, David. 1991. “What Every Computer Scientist Should Know About Floating-Point Arithmetic.” Computing Surveys (March). More bug reports are written against the limitations of floating point numbers than anything else. Essential knowledge for all programmers.

Graham, Paul. 1993. On Lisp. Englewood Cliffs, NJ: Prentice Hall. Is there any book or any author more influential to the current generation of dynamic programmers than Graham and On Lisp? (free version also available).

———. 1995. ANSI Common Lisp. Englewood Cliffs, NJ: Prentice Hall.

Gray, Jim, and Andreas Reuter. 1992. Transaction Processing: Concepts and Techniques. San Mateo, CA: Morgan Kaufmann Publishers.

Halloway, Stuart. 2009. “Clojure is a better Java than Java.” Presented at the Greater Atlanta Software Symposium, Atlanta. The origin of the phrase “Java.next” most likely stems from this talk by Halloway.

Hart, Peter, Nils Nilsson, and Bertram Raphael. 1968. “A Formal Basis for the Heuristic Determination of Minimum Cost Paths.” IEEE Transactions on Systems Science and Cybernetics In Systems Science and Cybernetics 4, no. 2.

Hewitt, Carl, Peter Bishop, and Richard Steiger. 1973. “A Universal Modular ACTOR Formalism for Artificial Intelligence.” Proceedings of the Third International Joint Conference on Artificial Intelligence.

Heinlein, Robert. 1966. The Moon Is a Harsh Mistress. New York: Putnam. We had considered offering an implementation of Mike as an appendix, but we ran over our page count.

Herlihy, Maurice, and Nir Shavit. 2008. The Art of Multiprocessor Programming. Amsterdam; Boston: Elsevier/Morgan Kaufmann.

Hickey, Rich. 2009. “Are We There Yet?” Presented at JVM Languages Summit. This wonderful presentation made firm the popular view of Rich as Philosopher Programmer.

Hofstadter, Douglas. 1979. Gödel, Escher, Bach: An Eternal Golden Braid. New York: Basic Books. See the sections “Classes and Instances,” “The Prototype Principle,” and “The Splitting-off of Instances from Classes” for more detail of the topics in section 9.2.

Hoyte, Doug. 2008. Let Over Lambda. Lulu.com. This is an amazing look into the mind-bending power of Common Lisp macros that provided the motivation for the DSLs section of this book. It will blow your mind—in a good way.

Hudak, Paul. 2000. The Haskell School of Expression: Learning Functional Programming Through Multimedia. New York: Cambridge University Press.

Huet, Gerard. 1997. “Functional Pearl: The Zipper.” Journal of Functional Programming.

Hutton, Graham. 1999. “A Tutorial on the Universality and Expressiveness of fold.” Journal of Functional Programming 9, no. 4.

Kahan, William, and Joseph Darcy. 1998. “How Java’s Floating-Point Hurts Everyone Everywhere.” Presented at the ACM Workshop on Java for High-Performance Network Computing. This paper provides more information on the cyclopian nightmares awaiting you in Java floating point.

Keene, Sonya. 1989. Object-Oriented Programming in Common Lisp: A Programmer’s Guide to CLOS. Boston: Addison-Wesley. The best book on CLOS ever written.

Knuth, Donald. 1997. The Art of Computer Programming: Volume 1 – Fundamental Algorithms. Reading, MA: Addison-Wesley. This book goes into exquisite detail about the primary characteristics of FIFO queues and is highly recommended reading.

———. 1998. The Art of Computer Programming, Vol. 3: Sorting and Searching. Reading, MA: Addison-Wesley. Running quick-sort on a sorted sequence is an O(n2) operation, which for our implementation in chapter 6 completely defeats its laziness.

Koenig, Dierk, Andrew Glover, Paul King, Guilaume LaForge, and Jon Skeet. 2007. Groovy in Action. Greenwich, CT: Manning.

Kuki, Hirondo, and William James Cody. 1973. “A Statistical Study of the Accuracy of Floating Point Number Systems.” Communications of the ACM 1973 16, no. 4.

Laddad, Ramnivas. 2003. AspectJ in Action: Practical Aspect-Oriented Programming. Greenwich, CT: Manning. We do not do justice to the notion of aspects—so read this instead.

Martin, Robert. 2002. Agile Software Development: Principles, Patterns, and Practices. Upper Saddle River, NJ: Prentice Hall.

McCarthy, John. 1960. “Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I.” Communications of the ACM. This is the essay that started it all.

———. 1962. LISP 1.5 Programmer’s Manual. Cambridge, MA: MIT Press. Lisp had an array type at least as early as 1962. Sadly, this fact is little known.

McConnell, Steve. 2004. Code Complete: A Practical Handbook of Software Construction. Redmond, WA: Microsoft Press.

Meyer, Bertrand. 1991. Eiffel: The Language. New York: Prentice Hall. The programming language Eiffel relies heavily on contract-based programming methodologies, a cornerstone element of Fogus’s philosophy of Apperception-Driven Development.

———. 2000. Object-Oriented Software Construction. Upper Saddle River, NJ: Prentice Hall.

Michie, Donald. 1968. “Memo Functions and Machine Learning.” Nature 218.

Mooers, Calvin, and Peter Deutsch. 1965. “TRAC, A Text-Handling Language.”

Moseley, Ben, and Peter Marks. 2006. “Out of the Tar Pit.” Presented at SPA2006.

Mozgovoy, Maxim. 2009. Algorithms, Languages, Automata, and Compilers: A Practical Approach. Sudbury, MA: Jones and Bartlett Publishers.

Noble, James, and Brian Foote. 2003. “Attack of the Clones.” Proceedings of the 2002 Conference on Pattern Languages of Programs 13. The clone function is inspired by this paper.

Norvig, Peter. 1991. Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp. San Francisco: Morgan Kaufman Publishers.

Odersky, Martin, Lex Spoon, and Bill Venners. 2008. Programming in Scala: A Comprehensive Step-by-step Guide. Mountain View, CA: Artima.

Okasaki, Chris. 1996. “The Role of Lazy Evaluation in Amortized Data Structures.” Presented at the International Conference on Functional Programming. This is a much more thorough discussion of incremental vs. monolithic computation.

———. 1999. Purely Functional Datastructures. Cambridge University Press. Chris Okasaki to the rescue again! Clojure’s persistent queue implementation is based on Okasaki’s batched queue from this seminal work.

Olsen, Russ. 2007. Design Patterns in Ruby. Upper Saddle River, NJ: Addison-Wesley

Papadimitriou, Christos. 1986. Theory of Database Concurrency Control. New York: Computer Science Press, Inc.

Pierce, Benjamin. 2002. Types and Programming Languages. Cambridge, MA: MIT Press. Fun fact: Representing numbers using lambda calculus is known as church encoding. The church-encoded number 9 would be represented as (fn [f] (fn [x] (f (f (f (f (f (f (f (f (f x))))))))))) in Clojure.

Raymond, Eric. 2003. The Art of Unix Programming. Reading, MA: Addison-Wesley Professional.

Rosenberg, Doug, Mark Collins-Cope, and Matt Stephens. 2005. Agile Development with ICONIX Process: People, Process, and Pragmatism. Berkeley, CA: Apress.

Skeel, Robert. 1992. “Roundoff Error and the Patriot Missile.” SIAM News 25, no. 4: 11.

Steele, Guy L. 1977. “Lambda: the Ultimate GOTO.” ACM Conference Proceedings.

———. 1990. Common LISP: The Language. Bedford, MA: Digital Press. This is a very witty book, in addition to being packed with information.

Steele, Guy L., and Gerald Sussman. 1978. “The Art of the Interpreter.” AI Memo (MIT) 453.

Stewart, Ian. 1995. Concepts of Modern Mathematics. New York: Dover. These Dover math books are often true gems. It would be great to see an adventurous publisher print a similar series revolving around C.S.-relevant topics—monads, category theory, lambda calculus, and so on.

Sussman, Gerald, and Guy L. Steele. 1975. “Scheme: An Interpreter for the Extended Lambda Calculus.” Higher-Order and Symbolic Computation 11, no. 4. This is a discussion of Scheme’s early implementation of lexical closures.

Symbolics Inc. 1986. Reference Guide to Symbolics Common Lisp: Language Concepts. Symbolics Release 7 Doc- ument Set.

Thompson, Simon. 1999. Haskell: The Craft of Functional Programming. Reading, MA: Addison-Wesley.

Ullman, Jeffrey. 1988. Principles of Database & Knowledge-Base Systems Vol. 1: Classical Database Systems. Rockville, MD: Computer Science Press.

Ungar, David, and Randal Smith. 1987. “SELF: The power of simplicity.” Presented at the Conference on Object-Oriented Programming Systems, Languages, and Applications (OOPSLA), Orlando. The Self programming language is the greatest influence on languages based on prototypal inheritance.

Van Roy, Peter, and Seif Haridi. 2004. Concepts, Techniques, and Models of Computer Programming. Cambridge, MA: MIT Press.

Wadler, Philip. 1989. “Theorems for Free!” Presented at the fourth International Conference on Func- tional Programming and Computer Architecture.

Wampler, Dean, and Alex Payne. 2009. Programming Scala. Sebastopol, CA: O’Reilly.

Whitehead, Alfred North. 1929. Process and Reality: An Essay in Cosmology. Cambridge University Press. For a general overview of Whitehead, see The Wit And Wisdom of Alfred North Whitehead by A.H. Johnson (Boston, Beacon Press, 1947).

Williams, Laurie. 2002. Pair Programming Illuminated. Boston: Addison-Wesley Professional. The limitations of the book format only shadow the idealistic model of pair programming.

Online resources

Braithwaite, Reginald. 2007. “Why Why Functional Programming Matters Matters.” http://weblog.raganwald.com/2007/03/why-why-functional-programming-matters.html. This column discusses language-level separation of concerns.

Clementson, Bill. 2008. “Clojure could be to Concurrency-Oriented Programming what Java was to OOP.” http://bc.tech.coop/blog/081201.html. A much deeper discussion concerning Erlang actors and Clojure agents.

Dekorte, Steve. Io. http://iolanguage.com.

Fogus, Michael. Lithp. http://github.com/fogus/lithp.

Fowler, Martin. 2005. “Fluent Interface.” http://martinfowler.com/bliki/FluentInterface.html.

———. 2007. “Mocks Aren’t Stubs.” http://martinfowler.com/articles/mocksArentStubs.html.

Graham, Paul. Arc. http://www.paulgraham.com/arc.html.

———. 2001. “What Made Lisp Different.” http://www.paulgraham.com/diff.html. As Paul Graham states, “The whole language always available” appears as a theme throughout this book and as a finale in section 13.5.

Houser, Chris. error-kit API. http://richhickey.github.com/clojure-contrib/error-kit-api.html. The clojure.contrib.error-kit namespace contains an open error system similar to CL conditions that don’t require recompilation when defining new error types.

Krukow, Karl. 2009. “Understanding Clojure’s PersistentVector Implementation.” http://blog.higher-order.net/2009/02/01/understanding-clojures-persistentvector-implementation/.

Lindholm, Tim, and Frank Yellin. 1999. Java Virtual Machine Specification. http://java.sun.com/docs/books/jvms/.

Norvig, Peter. 1998. “Design Patterns in Dynamic Programming.” http://norvig.com/design-patterns/. The section on design patterns was inspired by this presentation.

Tarver Mark. 2008. Functional Programming in Qi. http://www.lambdassociates.org/Book/page000.htm. Some programming languages perform partial application automatically when a function is supplied with fewer than the expected number of arguments. One such language is Qi — a truly elegant language.

———. 2009. “The Next Lisp: Back to the Future.” http://www.lambdassociates.org/blog/nextlisp(1).htm. The notion of Lisp as a programming language genotype is explored.

_why. Shoes. http://github.com/shoes/shoes.

Yegge, Steve. 2006. “Execution in the Kingdom of Nouns.” http://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-nouns.html.

———. 2008. “The Universal Design Pattern.” http://steve-yegge.blogspot.com/2008/10/universal-design-pattern.html. Like many programmers of our generation, we were in many ways inspired and influenced by Steve Yegge’s work—which is why we asked him to write this book’s foreword.