Clojure in Action: Elegant Applications on the JVM

I find Amit's book very easy to follow. It starts with great introduction of Clojure. Then it dives into how to use Clojure in real world application. One thing that I really liked about the book is TDD in action namely test, repl and refactoring in easy to follow examples, which the book offers plenty. I strongly recommend the book to anyone as the first book to read before starting with other great Clojure books such as Joy of Clojure.

A very good book to get started with Clojure

A basic presentation of clojure with a syntax walkthrough and disjointed examples.

CiA has gotten me farther down the road towards understanding functional programming, and it includes one of the best introductions to the Lisp family and the theory behind functional programming I have read. The book strives to teach concepts from the ground-up, which is it's biggest strength and weakness. Instead of expalining -how- you use Clojure to create programs, it also strives to give you the background behind the -why- of Clojure, delving into concepts like abstract-syntax-trees, polymorphic inheritence, and software transactional memory in depth.The author does an admirable job of covering these difficult topics in the first part of the book called "Getting Started". After discussing syntax and key concepts, the second part, "Getting Real" tries to bridge the divide between theory and practice by walking through TDD and common application implementations.The second half of the book is definitely the weaker of the two. It feels like Amit bites off more than he can chew by blasting through concepts like data storage, messaging and DSLs. For someone new to functional programming languages, this is a lot like drinking from the fire hose. Because so much ground is covered, I was left floundering.The book also glosses over the layout of the clojure architecture itself, which leads to trouble when following along with examples. For example, he seems to assume you know theres a "src" directory, and are familiar enough with Java to work through issues related to requiring files and classpaths.The book does not do an adequate job covering tools like lein which greatly simplify tasks like setting up testing environments, the REPL, etc. I think the ground-up approach is laudible, but building a real-world application realistically requires some sort of framework and set of guiding principles, and CiA fails to provide this kind of guidance. Apparently lein and other tools were not heavily used in 2011 when the book was released, and so this is a somewhat understandable omission, would love to see a second edition with another who section with this info.The good: * an excellent explanation of functional programming concepts * a good introduction to Clojure syntax and common functionsThe bad: * Too much detail, too fast * Does not cover Clojure structure or programming tools like Lein in depth * The author succumbs to the annoying language cheerleader role technical book writers always seem to fall into. For example he says on page 6: "Clojure is an extremely simple language to learn; from a syntax point of view, there's nearly nothing to it." This is followed by 150 pages of syntax description, and another 200 pages of implementation examples, which stretches a reasonable definition of the concept of simple.Other examples of wide-eyed optimism like "We'll write own little web framework to demonstrate how easy and straightforward Clojure is." and "Clojure makes the complicated task of writing multi- threaded programs that work correctly downright easy." are sprinkled liberally throughout the book. Learning a new language and a new programming paragigm is a marathon, and it's hard (albeit enjoyable) work, and telling me polymorphic multimethods are easy doesn't make them easy, any more than telling me mile 20 is easy magically gets me to mile 26.

"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.

Brilliant intro to any LISP-like language not just Clojure. Good to know there's more out there than just the C-family of languages.