£31.99
FREE Delivery in the UK.
Only 1 left in stock (more on the way).
Dispatched from and sold by Amazon.
Gift-wrap available.
Quantity:1
Trade in your item
Get a £2.00
Gift Card.
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 – 20 Nov 2011


See all formats and editions Hide other formats and editions
Amazon Price New from Used from
Paperback
"Please retry"
£31.99
£17.72 £4.00

There is a newer edition of this item:

Clojure in Action
£32.09
This title has not yet been released.

Frequently Bought Together

Clojure in Action + The Joy of Clojure
Price For Both: £55.68

Buy the selected items together


Trade In this Item for up to £2.00
Trade in Clojure in Action for an Amazon Gift Card of up to £2.00, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Learn more

Product details

  • Paperback: 432 pages
  • Publisher: Manning Publications; 1 edition (20 Nov 2011)
  • Language: English
  • ISBN-10: 1935182595
  • ISBN-13: 978-1935182597
  • Product Dimensions: 18.7 x 2.3 x 23.5 cm
  • Average Customer Review: 4.5 out of 5 stars  See all reviews (2 customer reviews)
  • Amazon Bestsellers Rank: 612,482 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, and more.

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.


Inside This Book (Learn More)
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index | Back Cover
Search inside this book:

What Other Items Do Customers Buy After Viewing This Item?

Customer Reviews

4.5 out of 5 stars
5 star
1
4 star
1
3 star
0
2 star
0
1 star
0
See both customer reviews
Share your thoughts with other customers

Most Helpful Customer Reviews

3 of 3 people found the following review helpful By Finn Newick on 18 Dec 2011
Format: 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).
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
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".
Read more ›
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Most Helpful Customer Reviews on Amazon.com (beta)

Amazon.com: 8 reviews
24 of 25 people found the following review helpful
I love this book 2 Feb 2012
By Amazon Customer - Published on Amazon.com
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
Good review, needs updating 30 Aug 2012
By Justin Tyler Wiley - Published on Amazon.com
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
Learning Clojure with an emphasis on Real-world engineering issues 8 April 2012
By Alexander Baranosky - Published on Amazon.com
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.
9 of 12 people found the following review helpful
Excellent intro to Clojure 21 Dec 2011
By Amazon Customer - Published on Amazon.com
Format: Paperback
This was the ideal book for me to start learning Clojure with. As an experienced programmer, but new to Lisp and Clojure, I found this book very helpful. It is clear and well written, and moves through concepts at just the right pace. I found Clojure in Action more palpable than The Joy of Clojure (which I plan to read next). I am also reading The Little Schemer at the same time as Clojure in Action and I highly recommend this approach. That said, there was a chapter or two that seemed like it could have used a bit more editing. Still, I highly recommend this book.
2 of 2 people found the following review helpful
Fluid and Practical dive into Clojure 4 Sep 2012
By Uygur - Published on Amazon.com
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.
Were these reviews helpful? Let us know

Look for similar items by category


Feedback