CDN$ 48.62
  • List Price: CDN$ 64.82
  • You Save: CDN$ 16.20 (25%)
Usually ships within 2 to 4 weeks.
Ships from and sold by Gift-wrap available.
Clojure in Action has been added to your Cart
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See all 2 images

Clojure in Action Paperback – Nov 20 2011

See all 4 formats and editions Hide other formats and editions
Amazon Price
New from Used from
"Please retry"
CDN$ 48.62
CDN$ 16.39 CDN$ 23.15

There is a newer edition of this item:

Clojure in Action
CDN$ 56.15
In Stock.

Unlimited FREE Two-Day Shipping for Six Months When You Try Amazon Student
click to open popover

No Kindle device required. Download one of the Free Kindle apps to start reading Kindle books on your smartphone, tablet, and computer.

  • Apple
  • Android
  • Windows Phone
  • Android

To get the free app, enter your mobile phone number.

Product Details

  • Paperback: 432 pages
  • Publisher: Manning Publications; 1 edition (Nov. 20 2011)
  • Language: English
  • ISBN-10: 1935182595
  • ISBN-13: 978-1935182597
  • Product Dimensions: 18.7 x 2.3 x 23.5 cm
  • Shipping Weight: 680 g
  • Average Customer Review: Be the first to review this item
  • Amazon Bestsellers Rank: #678,230 in Books (See Top 100 in Books)
  •  Would you like to update product info, give feedback on images, or tell us about a lower price?

Product Description

About the Author

Amit Rathore is a VP of Engineering and has a decade of experience building highly performant, data-heavy web applications.

Customer Reviews

There are no customer reviews yet on
5 star
4 star
3 star
2 star
1 star

Most Helpful Customer Reviews on (beta) 4.4 out of 5 stars 9 reviews
25 of 26 people found the following review helpful
5.0 out of 5 stars I love this book Feb. 2 2012
By Amazon Customer - Published on
Format: Paperback
I'm coming to Clojure from C# and, as the author puts it, it's a daunting journey. There is a lot to learn. The functional paradigm, lisp specifics (macros etc), clojure specifics (STM, persitent data structures, protocols, etc). It's not like learning python or ruby. It's fundamentally differnt ball game. I read a lot of stuff online and I read "Practical Clojure" that was published before this book but all of them were ranting about how great and superior Clojure is to everything else which wasn't very helpful and actually is annoying.

This book was different. It's all practical and zero BS and it shows step by step the clojure way. For example I liked how clojure multi-methods polymorphism was explained. It starts by showing the limitation of single dispatch and then showing alternatives in Java through the visitor pattern and then shows clojure multimethods. All of course is done through writing code. Now I know exactly the problem that multimethods solves and I'm confident to apply them in my design.

A similar example is protocols where the author builds an equivalent functionality to protocols with multi-methods and then replaces them at the end with protocols which make you understand exactly why protocls exist and when to use them.

I also learned about things I wasn't expecting to learn when I bought this book like the expression problem, multiple dispatch and also HBase, Hadoop, RabbitMQ and other components that are essential to modern application architecture and how to work with them in clojure.

I would like to thank the author for the apparent effort and passion he put in this book. Congratulations, job perfectly done.

When you learn Clojure (and Lisp in general) you don't learn about a better technology only, you also learn about better people.
5 of 5 people found the following review helpful
4.0 out of 5 stars Good review, needs updating Aug. 30 2012
By 38megabyteemail - Published on
Format: Paperback
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 functions

The 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.
6 of 6 people found the following review helpful
5.0 out of 5 stars Learning Clojure with an emphasis on Real-world engineering issues April 7 2012
By Alexander Baranosky - Published on
Format: Paperback
This is one of the unsung greats in the Clojure book genre. This books brings the features of Clojure together and shows how they can be used cohesively to implement a number of engineering solutions. Each solution is stunningly simple and elegant. I highly recommend this book.
3 of 3 people found the following review helpful
5.0 out of 5 stars Fluid and Practical dive into Clojure Sept. 4 2012
By Uygur - Published on
Format: Paperback Verified Purchase
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.
6 of 8 people found the following review helpful
5.0 out of 5 stars Experiencing profound enlightenment on use of Clojure in real-world projects March 1 2012
By Jacek Laskowski - Published on
Format: Paperback
"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.