Clojure in Action [Paperback]

Wow, what a thrilling ride this book was! It takes you from the standard "Hello World" one liner (thankfully covered in one line unlike a lot of books) through the standard language features and then all the way up to handling things like STM (software transactional memory), map-reduce, using RabbitMQ and connecting to non-relational data stores such as Redis and HBase. Of course there's a limit to how much depth can be covered in about 400 pages but the author still manages to make all the code samples feel 'real world'-like enough that the techniques could applied to concrete problems.

The author takes the approach of describing each topic in a reasonable amount of detail before introducing any code - an approach that works particularly well with Lisp/Clojure's fairly compact syntax and the non-trivial applications covered in part 2 of the book.

I came to this book with a little bit of Lisp (but no Clojure or Java) but I don't think that's required to follow the book's content - but you will definitely need to be fully familiar with some other OO language such as Java, C# (as in my case), Python, C++, etc.

One thing that is a little tiresome in the book, particularly at the beginning, is the constant reference to other languages as being 'lesser' to Clojure. Different languages have their pluses and minuses but it's a bit of a stretch to imply that one language is globally superior. Maybe it's the author's way of trying to excite the reader, but for me at least it was completely unnecessary (the language can speak for itself).

Overall a superb book though which makes me want to explore this language further (probably Joy of Clojure next, which has so far been sitting on my bookshelf).

"Clojure in Action" was not an easy reading nor was it a tough one. The book simply deserves a great deal of patience and enough time to study. Without such an attitude, you may find no prospect of success in understanding the concepts. I fell into this trap few times when I cared more about scoring a chapter over understanding the subject completely.

I'm wholeheartedly delighted that Manning offered me a review copy of "Clojure in Action" as I tend to believe I would not have understood functional programming in Clojure as much as I did with the book. That's doubtlessly the book you ought to read if you really want to delve into Clojure. Reading the book will have an enormous effect on your state of mind about functional programming applied to practical use cases.

Quoting the book (page xviii):

"There are dozens of other popular languages"

So how could one expect Clojure will ultimately become such, if ever? It's certainly a challenge, isn't it? Yet, despite homoiconicity that seems to scare people to death only because they seem reluctant to spare a tiny fraction of their time to understand and ultimately appreciate it, Clojure draws attention. The book certainly helps achieve more in trying to understand why it happens.

Imagine reading a book that explains the language syntax, its goals, and makes its uses from the very first pages. Imagine reading a book that delves into details without wasting time for gory details unnecessary for the task at hand. Finally, imagine reading a book that simply gets you feel comfortable with Clojure. That's "Clojure in Action". Perhaps the most satisfactory aspect of this book is the fact that while reading the book you feel guided and warmly encouraged to try out what you learn as if you were in a class with a teacher.

When I first noticed "Clojure in Action", I imagined it's kind of a cookbook - a book with recipes to achieve something practical. I'd already read "The Joy of Clojure", "Practical Clojure", "Programming Clojure", "Programming Concurrency on the JVM", and was wondering what the book could offer that the others didn't. The many references to the concepts of programming languages like classes vs maps, homoiconicity, inheritance, duck typing, single dispatch, polymorphism and such allowed me to become a more conscious Java programmer as I was learning Clojure.

Read the book for your good.

Section 1.2.1 about XML and parentheses should be a mandatory reading for anyone who deals with either - certainly for those who can't live with parentheses in Clojure (or any Lisp language). It's written in a simple and easy way, so with its reading you may ultimately appreciate simplicity of Clojure's syntax. I hope Chapter 1 becomes public domain one day so everybody could read it.

The book may however seem uneasy for newbies in Clojure. It uses idiomatic Clojure constructs freely, often without explanation beforehand. You'll find many examples that are very basic while many will take quite large chunk of your time to grasp. Many, many examples of varying level of complexity are what I was after when I picked the book and I was not disappointed at all.

Figures, many use cases with inspiring code snippets, and finally gentle explanation of solutions equipped with the mental process that led to them makes the book a mandatory reading for every programmer, regardless of the language of choice. I bet no one would regret its reading. Fair explanation of Clojure features invites for reading from cover to cover. No typos, comprehensive writing style and a slew of examples encourages reading the book many times.

A perfect book for someone is the worse for another person. "Clojure in Action" has its itches that I would barely accept as a technical reviewer, esp. Section 2.1.1 "Installing Clojure" goes through its compilation to get Clojure installed while Leiningen may have done it better. There's no mention of Leiningen, but it's the project management tool of choice for many (all?) Clojure projects. I also found one place repeated almost word by word. Not much about the difference between let and binding forms in Clojure. Some may also find too few pages about Clojure's approach to state, mutation and concurrency in Chapter 6.

The book once more proves that books written by experts in a field are excellent resource of practical knowledge. Not only does it teach Clojure, but also the way of thinking attached to the process of developing Clojure applications.

Should you need some bullets to smash Clojure off the ground or want immensely well-thought-out examples of its uses, grab the book and have a nice reading. You miss no minute as you read along.