Clojure Programming by Chas Emerick, Brian Carper and Christophe Grand
Publisher: O'Reilly Media
It's been three years since I embarked on my Clojure journey. I'd been following the language for some time before I wrote my first small programs. Clojure was this promising new language designed for a multi-core age and fueled by the potent open-source eco-system of the Java world. Most important to me, it was a Lisp. I've never got to spend enough time with Clojure. But I tried to keep up to date with the development, waiting for an opportunity to pick up Clojure where I left. As the opportunity knocked, Clojure Programming turned out to be a great guide to the simplicity and practicality of Clojure.
To really take-off any technology needs either a killer app or a seminal book directed towards the practical oriented developer that considers to adapt the technology. Something that guides the learning effort and makes the technology accessible. C had it's classic K&R. C++ was well served by Stroustrup's hard but accurate The C++ Programming language. Common Lisp, my personal favorite, was introduced to a modern audience by Peter Seibel's excellent Practical Common Lisp. I'm happy that Clojure finally joined the ranks with this competitive introduction to an exciting language.
Clojure is still a fairly new language. Given some years of experience with functional languages (most prominently Common Lisp and Erlang) I expected to pick-up Clojure in a breeze. I started with Programming Clojure by Stuart Halloway. It was a decent start. I wrote my first small programs: an automated test environment and a pretty straightforward code generator replacing an overly complex lex/yacc solution. But I never got into Clojure. While I managed to produce programs that solved real-world problems they never felt quite right. Common Lisp was still a more natural technology to me. Perhaps that's one of the reasons; Clojure parts with traditional Lisps in both philosophy and surface. It has a different solution space and it took me some time to really get into the mindset.
I recently decided to perform an on-line experiment for my master thesis in psychology. Although slipping somewhat in scope, there was no way I could resist the technical temptation; I just had to develop my app in Clojure using MongoDB as back-end through the excellent Clojure Monger client. Clojure turned out great ( MongoDB was a pleasure too). It was quite fascinating and rewarding to note how my solutions grew shorter and simpler as my skill set grew. After many hard hours, the power of Clojure started to shine as each refactoring now left me with less yet more expressive code. That's what I like about Lisp; there are no artificial constraints enforced upon the programmer. Sure, the restrictions on what you can express are still there. But those restrictions are right where they should be: on the skills and creativity of the programmer.
Clojure Programming came just right for my project. I still got a lot to learn but the book smoothed my initial learning curve and finally taught me efficient and idiomatic Clojure. It's the book I've been waiting for and I do put it on par with Practical Common Lisp. Clojure Programming introduces the language in a straightforward way, carefully explaining the details without leaving any dark corners unexplored. It has a practical feel to it and you will get to know several high-class open-source libraries. Clojure Programming is such a beautifully executed head start for every new Clojure programmer. If you have any interest in Clojure, this is the book to learn the basics from. My only concern is around the library usage. Perhaps it's inevitable but practical chapters don't tend to age too well. For example, the book refers to the Noir framework. At this time of writing, Noir has already been officially deprecated. It's a minor and unavoidable nit that has to be balanced against the immediate value the approach adds. Don't let it keep you away from this masterpiece. It's that good and I hope to see future editions evolve together with Clojure and its growing eco-system. The future looks bright for Clojure. Programming hasn't been this rewarding for years.
Reviewed January 2013