What do you think?
Rate this book
Programming Clojure
Clojure is a dynamic language for the Java Virtual Machine, with a compelling combination of
Clojure is elegant . Clojure's clean, careful design lets you write programs that get right to the essence of a problem, without a lot of clutter and ceremony.
Clojure is Lisp reloaded . Clojure has the power inherent in Lisp, but is not constrained by the history of Lisp.
Clojure is a functional language. Data structures are immutable, and functions tend to be side-effect free. This makes it easier to write correct programs, and to compose large programs from smaller ones.
Clojure is concurrent . Rather than error-prone locking, Clojure provides software transactional memory.
Clojure embraces Java . Calling from Clojure to Java is direct, and goes through no translation layer.
Clojure is fast . Wherever you need it, you can get the exact same performance that you could get from hand-written Java code.
Many other languages offer some of these features, but the combination of them all makes Clojure sparkle. Programming Clojure shows you why these features are so important, and how you can use Clojure to build powerful programs quickly.
Clojure is elegant . Clojure's clean, careful design lets you write programs that get right to the essence of a problem, without a lot of clutter and ceremony.
Clojure is Lisp reloaded . Clojure has the power inherent in Lisp, but is not constrained by the history of Lisp.
Clojure is a functional language. Data structures are immutable, and functions tend to be side-effect free. This makes it easier to write correct programs, and to compose large programs from smaller ones.
Clojure is concurrent . Rather than error-prone locking, Clojure provides software transactional memory.
Clojure embraces Java . Calling from Clojure to Java is direct, and goes through no translation layer.
Clojure is fast . Wherever you need it, you can get the exact same performance that you could get from hand-written Java code.
Many other languages offer some of these features, but the combination of them all makes Clojure sparkle. Programming Clojure shows you why these features are so important, and how you can use Clojure to build powerful programs quickly.
280 pages, Paperback
First published May 21, 2009
87 people are currently reading
510 people want to read
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 30 of 54 reviews
July 14, 2010
Context matters a lot. I am an avid functional programmer, and I read straight through this book without problem and found it to be at an entirely appropriate level. This makes me worried that this book might be too terse if this is your first book about a functional programming language. I would not call that a criticism so much as a fear, it is something to consider if you are thinking about buying this book. That aside, from my context, this is a pretty good book. This book focuses on a lot of high level ideas and syntax without getting bogged down in overly complicated examples or specific APIs. All of the writing is very clear and the examples generally seem well chosen. The high points are really nice coverage of macros and concurrency constructs. Those are two things that could have easily difficult to understand, but were not do the quality writing found in this book. I do have some criticisms of the book however. Way too much time in this book is spent covering Lancet, which seems to be an entirely dated topic just one year later. The chapter discussing sequences have some really great examples and explanations, but I am afraid I did not develop a very complete cognitive model of how everything is working, especially in terms of the ISeq interface versus specific implementations, next versus rest, etc.... One final criticism I have of the book is that the author does not discuss any of the potential drawbacks or pitfalls of using Clojure on a project. I think every book focused exclusively on one technology should have such a discussion, and I believe this especially holds for a technology as bleeding edge as Clojure. Overall this book is a pleasure to read and I would strongly recommend it.
April 27, 2025
A truly exceptionally well written book. It's comprehensive enough (except of course for the language features released after the book), contains just enough practical examples, and just enough explanation of the first principles of Clojure. An extremely rare tech book that gets a fluff factor of zero.
February 5, 2013
A really brilliant introduction into Clojure and functional programming in general. Highly recommended for anyone trapped into imperative languages.
December 25, 2013
Good concise book on Clojure. Although, it isn't as detailed as Clojure Programming, it provides enough information and examples to start to use Clojure.
Although some pieces are already outdated and it doesn't cover new topics that were introduced since release of Clojure 1.3 (reducers, for example)...
Although some pieces are already outdated and it doesn't cover new topics that were introduced since release of Clojure 1.3 (reducers, for example)...
July 6, 2019
4 stars
Disclaimer: I read the 2nd edition; the 3rd edition which is out now might be better.
Review: It's an okay first book on a new language, but oftentimes it serves up too much new information (in the form of new functions) on your plate. I had to make a note to come back to the treatment of several topics because the book made use of new concepts (e.g. multimethods, the -> macro, the ^ symbol for type hints, and many more functions and macros) without introducing them first. It often felt like the book threw names of concepts out there before motivating them with an example and/or explaining them. The chapter on protocols and datatypes felt unpolished and rushed. When chapter 7 (yes, 7, on Macros) in a book says 'lets build this one thing and introduce Clojure concepts as we go' you know it could be better organized. I also had minor issues with some example code that I had to research and correct. But since one of the famous Clojure books, the Joy of Clojure, says that _that_ shouldn't be your first Clojure book, I'd recommend this book over O'Reilly's Clojure Programming because of the relatively smaller size if you're just getting started with Clojure. After all's said and done, if you are willing to work with this book, you'll still learn a lot.
Disclaimer: I read the 2nd edition; the 3rd edition which is out now might be better.
Review: It's an okay first book on a new language, but oftentimes it serves up too much new information (in the form of new functions) on your plate. I had to make a note to come back to the treatment of several topics because the book made use of new concepts (e.g. multimethods, the -> macro, the ^ symbol for type hints, and many more functions and macros) without introducing them first. It often felt like the book threw names of concepts out there before motivating them with an example and/or explaining them. The chapter on protocols and datatypes felt unpolished and rushed. When chapter 7 (yes, 7, on Macros) in a book says 'lets build this one thing and introduce Clojure concepts as we go' you know it could be better organized. I also had minor issues with some example code that I had to research and correct. But since one of the famous Clojure books, the Joy of Clojure, says that _that_ shouldn't be your first Clojure book, I'd recommend this book over O'Reilly's Clojure Programming because of the relatively smaller size if you're just getting started with Clojure. After all's said and done, if you are willing to work with this book, you'll still learn a lot.
September 26, 2017
A good book about a programming language takes you on a journey. The goal is helping you "think in that language". This book failed the goal pretty badly for me because it provides a long list of "things the language" offer. The information is listed as opposed to explained, so it feels like a more verbose version of the official documentation.
The lack of the second star is a consequence of three things:
- In the first part of the book, the author makes a constant comparison with imperative programming and why clojure is a better choice. It's unnecessary clutter and distracted me from the goal of "learning more about clojure". If you really feel compelled to make the comparison, have an appendix so that it doesn't distract the reader from the flow.
- There’s a lot of "simply" and "easily" everywhere. The writing style is annoying and unwelcoming to newcomers.
- In the chapter about macros, there's this sentence: “If none of the macros in clojure seem complex to you, my company is hiring”. That’s really just gross.
Not recommended.
The lack of the second star is a consequence of three things:
- In the first part of the book, the author makes a constant comparison with imperative programming and why clojure is a better choice. It's unnecessary clutter and distracted me from the goal of "learning more about clojure". If you really feel compelled to make the comparison, have an appendix so that it doesn't distract the reader from the flow.
- There’s a lot of "simply" and "easily" everywhere. The writing style is annoying and unwelcoming to newcomers.
- In the chapter about macros, there's this sentence: “If none of the macros in clojure seem complex to you, my company is hiring”. That’s really just gross.
Not recommended.
July 29, 2022
It's a really nice book if you like to cover a lot of ground in relatively little pages.
This is a double-edged sword though. Sometimes things take a lot more time to explain than the book can offer to relative beginners like myself. That's okay though, it's a trade-off you should expect here.
Most valuable about this book is how it also emphasizes when to use certain tools and idioms over others. Even though I feel overwhelmed by many details that I've come across, and certainly will need to look up lots of things before they sink in deeper, I am armed much better to navigate what Clojure offers. Also, I "get" Clojure now at a deeper level in terms of its philosophy and design.
This is very nice book that I can definitely recommend. If you prefer thorough explanations and a slower pace, this might not be for you. Again: this will get you started with lots of Clojure concepts but it cannot teach you everything in-depth in its low page count.
This is a double-edged sword though. Sometimes things take a lot more time to explain than the book can offer to relative beginners like myself. That's okay though, it's a trade-off you should expect here.
Most valuable about this book is how it also emphasizes when to use certain tools and idioms over others. Even though I feel overwhelmed by many details that I've come across, and certainly will need to look up lots of things before they sink in deeper, I am armed much better to navigate what Clojure offers. Also, I "get" Clojure now at a deeper level in terms of its philosophy and design.
This is very nice book that I can definitely recommend. If you prefer thorough explanations and a slower pace, this might not be for you. Again: this will get you started with lots of Clojure concepts but it cannot teach you everything in-depth in its low page count.
April 19, 2019
A good introduction to Clojure for people with programming experience. Being familiar with Java is certainly a pre-condition for the parts that deal with Clojure/Java interoperability. Being familiar with either Lisp or another functional programming language may be an advantage, too, though some concepts of the functional paradigm are explained and recur throughout the book.
The book's quite filled with content, and the didactic side may not be the strongest point here, so a bit of self-motivation may also come as an advantage to the reader. The lack of repetition or exercise doesn't help to memorize anything, but the index is extensive and the book can then also be used as a reference after a first reading.
The book's quite filled with content, and the didactic side may not be the strongest point here, so a bit of self-motivation may also come as an advantage to the reader. The lack of repetition or exercise doesn't help to memorize anything, but the index is extensive and the book can then also be used as a reference after a first reading.
March 21, 2018
I was not a big fan of the way Programming Clojure is written. Too much information is being presented too quickly, and there is little time left for it to be absorbed by the reader. It feels more like reading documentation explaining everything that the language can do and less like a cohesive text showing me how to use it. I understand some people prefer this approach to a programming language book, but it just didn't work for me.
If you're already somewhat comfortable with Clojure then this book might work pretty well as a quick reference or refresher, but if you're newer and want something more fleshed out then you might want to look elsewhere.
If you're already somewhat comfortable with Clojure then this book might work pretty well as a quick reference or refresher, but if you're newer and want something more fleshed out then you might want to look elsewhere.
April 14, 2018
Good in-depth coverage of Clojure API with useful examples from novice to practitioner developers. Covers its integration with Java API by introducing its pros and cons.
Don't expect to learn about functional programming in this book, though. It doesn't cover any aspects of modularisation nor building an application. Also, lacks unit testing chapter which could be very helpful to create anything more than quick examples.
Don't expect to learn about functional programming in this book, though. It doesn't cover any aspects of modularisation nor building an application. Also, lacks unit testing chapter which could be very helpful to create anything more than quick examples.
April 27, 2018
This book in underwhelming. It's slow to start. You have to read at least half of the book to be able to do basic things. It doesn't get you excited about Clojure. It's not very deep either. It doesn't show how to use the Clojure standard library effectively. But it spends a lot of time to discuss irrelevant things like specs. I finished this book and it felt like a waste of time.
October 11, 2021
It's a good book, well written and organized but in the middle of the reading I felt that isn't a book for me as a beginner using Clojure. The book cover many aspects about basic Clojure functions, functional programming, macros and some internals but it's not straight to the point.
I think if you have some previous experience, it can be better enjoyed.
I think if you have some previous experience, it can be better enjoyed.
March 28, 2019
I gave up after reading a bit into the Protocol chapter, it’s just not for me. So badly organized especially compared to the Rust book that I recently read. Also so many Java stuff that I just don’t enjoy.
October 19, 2019
For now, the best clojure book I've read so far. Very well explained and with good examples of complex scenarios. I would recommend specially the chapters about concurrency, parallelism, protocols, multimethods and macros. (Y)
Read
October 21, 2019Decided to go for a Udemy course instead
July 20, 2020
There are plenty of typos and mistakes. Some topics are not covered or covered too brief. Some code examples are not optimal, facing with them raise additional questions.
August 29, 2020
Sometimes it gets a little confusing. I had to stop and think deeply about some parts
September 15, 2022
Good intro to Clojure language, but quite dry and lacks chapters on web programming. "Clojure Programming" from O'Reilly, albeit wordy, is much better alternative.
Read
November 15, 2022Clojure - a functional language based on the JVM.
Love Clojure, not a fan of the JVM for what I do.
Love Clojure, not a fan of the JVM for what I do.
July 1, 2013
This is an excellent introduction to Clojure, whether you've Lisped before or not. It doesn't go into great depth, but it's valuable both as an introduction and as a reference for the new Clojure developer. I personally like programming books with a language + standard library reference included (e.g., Programming Ruby), but the Clojure online docs are comprehensive enough that it's not entirely necessary here. Like just about every PragProg book I've read, this is an excellent survey of the subject matter.
Read
June 17, 2012I read the first version when I was just learning Clojure. I understand that the second version has been considerably revised and am looking forward to readying it. The first version was a good introduction to the basics of a modern functional programming language, very familiar in style and approach to any of the other Pragrmattic Programmers books. If I were recommending a book to someone wanting to learn Clojure today, I would recommend the confusingly named, Clojure Programming, from O'Reilly. While both are good books, the second shines at making the functional approach clear.
September 18, 2009
I thought this book was very well written and very well organized. The examples lead you through language features in a very progressive way. The sample app that wraps ant with a clojure dsl is also a very good example and offers good utility while providing good coverage of the language features. I think that anyone looking to learn a new JVM language should consider clojure, and the quality of this book is one of the reasons.
November 13, 2012
El libro es un curso introductorio e intensivo a Clojure, un dialecto de Lisp que se ejecuta sobre la máquina virtual de Java. Introduce algunos conceptos de programación funcional y expone varias de las ventajas de este paradigma.
Los conceptos son expuestos con poca profundidad, es posible que para alguien que no esté familiarizado al menos un poco con POO o funcional no comprenda ciertas partes del libro.
Los conceptos son expuestos con poca profundidad, es posible que para alguien que no esté familiarizado al menos un poco con POO o funcional no comprenda ciertas partes del libro.
September 15, 2013
Far too much “Ra! Ra! Clojure is the bestest!” for my taste.
The order in which concepts are introduced is not well suited to understanding the examples provided. The arrow macro, for example, is used repeatedly early in the book; well before any meaningful explanation is given for how it works or what it is doing. I found these unexplained intricacies distracted from understanding the examples as they were given.
A disappointing read, overall.
The order in which concepts are introduced is not well suited to understanding the examples provided. The arrow macro, for example, is used repeatedly early in the book; well before any meaningful explanation is given for how it works or what it is doing. I found these unexplained intricacies distracted from understanding the examples as they were given.
A disappointing read, overall.
March 12, 2015
I loved this book. The presentation was great, and the example were absolutely fantastic. They were at the perfect level for what they were trying to describe, and Halloway motivated and explained the code beautifully.
I would have liked chapters (or sections) on logic programming and transducers, but a case could be made that they're advanced Clojure programming. In which case, Halloway should write that book, too.
I would have liked chapters (or sections) on logic programming and transducers, but a case could be made that they're advanced Clojure programming. In which case, Halloway should write that book, too.
June 21, 2015
This book is a very pleasant introduction to Clojure as a programming language. The prose is well paced and there is a gentleness to the book that I enjoy. However I think that the material has aged badly in places and there is a feeling that some of the material is written knowing it will be out of date soon. Enjoy this book yet expect that there will be a new edition out soon.
July 9, 2013
Was an excellent, rather deeper introduction course into Clojure. As this language forces its users to really shift thinking, no book can make you an expert. I'm convinced now that Clojure has a lot to say. So probably it's going to be used by me even in production one day. This book gave me the first significant motivation for that.
August 21, 2013
Excellent and solid introduction to Clojure. The book is fairly concise, yet not boring; it gives you all needed to quickly start with Clojure.
Experience in functional programming paradigma would be useful, but not required. There is a chapter on this topic in the book, though I cannot tell is it enough to a novice.
Experience in functional programming paradigma would be useful, but not required. There is a chapter on this topic in the book, though I cannot tell is it enough to a novice.
September 6, 2010
Good introduction to the language and also includes some gentle introductions to certain aspects FP for those who are unfamiliar with them. Consider this a survey of the language and don't expect it to go too deep on too many parts. All in all it is a good intro and good first clojure book.
January 3, 2011
It's a bit outdated, but gives a good overview on all clojure features. I think it's best to use when you already have a bit of experience with the language... I may be a bit rough to use it as a starting point.
Displaying 1 - 30 of 54 reviews