Sign in to turn on 1-Click ordering.
Trade in Yours
For a 2.00 Gift Card
Trade in
More Buying Choices
Have one to sell? Sell yours here
Sorry, this item is not available in
Image not available for
Image not available

Tell the Publisher!
Id like to read this book on Kindle

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Clojure in Action [Paperback]

Amit Rathore
4.5 out of 5 stars  See all reviews (2 customer reviews)
Price: 31.99 & FREE Delivery in the UK. Details
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Only 3 left in stock (more on the way).
Dispatched from and sold by Amazon. Gift-wrap available.
Want it Tuesday, 22 April? Choose Express delivery at checkout. Details
Trade In this Item for up to 2.00
Trade in Clojure in Action for an Amazon.co.uk 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

Book Description

20 Nov 2011 1935182595 978-1935182597 1


Clojure in Action is a hands-on tutorial for the working programmer who has written code in a language like Java or Ruby, but has no prior experience with Lisp. It teaches Clojure from the basics to advanced topics using practical, real-world application examples. Blow through the theory and dive into practical matters like unit-testing and environment set-up, all the way through building a scalable web-application using domain-specific languages, Hadoop, HBase, and RabbitMQ.

About the Technology

Clojure is a modern Lisp for the JVM, and it has the strengths you'd expect: first-class functions, macros, support for functional programming, and a Lisp-like, clean programming style.

About this Book

Clojure in Action is a practical guide focused on applying Clojure to practical programming challenges. You'll start with a language tutorial written for readers who already know OOP. Then, you'll dive into the use cases where Clojure really shines: state management, safe concurrency and multicore programming, first-class code generation, and Java interop. In each chapter, you'll first explore the unique characteristics of a problem area and then discover how to tackle them using Clojure. Along the way, you'll explore practical matters like architecture, unit testing, and set-up as you build a scalable web application that includes custom DSLs, Hadoop, HBase, and RabbitMQ.

Purchase of the print book comes with an offer of a free PDF, ePub, and Kindle eBook from Manning. Also available is all code from the book.

What's Inside
  • A fast-paced Clojure tutorial
  • Creating web services with Clojure
  • Scaling through messaging
  • Creating DSLs with Clojure's macro system
  • Test-driven development with Clojure
  • Distributed programming with Clojure and more

This book assumes you're familiar with an OO language like Java, C#, or C++, but requires no background in Lisp or Clojure itself.


Table of Contents
  1. Introduction to Clojure
  2. A whirlwind tour
  3. Building blocks of Clojure
  4. Polymorphism with multimethods
  5. Clojure and Java interop
  6. State and the concurrent world
  7. Evolving Clojure through macros
  9. Test-driven development and more
  10. Data storage with Clojure
  11. Clojure and the web
  12. Scaling through messaging
  13. Data processing with Clojure
  14. More on functional programming
  15. Protocols, records, and type
  16. More macros and DSLs

Frequently Bought Together

Clojure in Action + The Joy of Clojure: Thinking the Clojure Way + Clojure Programming
Price For All Three: 92.08

Buy the selected items together

Product details

  • Paperback: 432 pages
  • Publisher: Manning Publications; 1 edition (20 Nov 2011)
  • Language: English
  • ISBN-10: 1935182595
  • ISBN-13: 978-1935182597
  • Product Dimensions: 23.4 x 18.8 x 2.3 cm
  • Average Customer Review: 4.5 out of 5 stars  See all reviews (2 customer reviews)
  • Amazon Bestsellers Rank: 429,131 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:

Sell a Digital Version of This Book in the Kindle Store

If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store. Learn more

What Other Items Do Customers Buy After Viewing This Item?

Customer Reviews

3 star
2 star
1 star
4.5 out of 5 stars
4.5 out of 5 stars
Most Helpful Customer Reviews
2 of 2 people found the following review helpful
4.0 out of 5 stars 0 to 50 in 2.1 seconds 18 Dec 2011
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?
"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?
Most Helpful Customer Reviews on Amazon.com (beta)
Amazon.com: 4.9 out of 5 stars  7 reviews
23 of 24 people found the following review helpful
5.0 out of 5 stars I love this book 2 Feb 2012
By Amazon Customer - Published on Amazon.com
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
5.0 out of 5 stars Learning Clojure with an emphasis on Real-world engineering issues 8 April 2012
By Alexander Baranosky - Published on Amazon.com
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.
4 of 4 people found the following review helpful
4.0 out of 5 stars Good review, needs updating 30 Aug 2012
By Justin Tyler Wiley - Published on Amazon.com
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.
9 of 12 people found the following review helpful
5.0 out of 5 stars Excellent intro to Clojure 21 Dec 2011
By SteveSJ76 - Published on Amazon.com
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
5.0 out of 5 stars 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
Search Customer Reviews
Only search this product's reviews

Customer Discussions

This product's forum
Discussion Replies Latest Post
No discussions yet

Ask questions, Share opinions, Gain insight
Start a new discussion
First post:
Prompts for sign-in

Search Customer Discussions
Search all Amazon discussions

Look for similar items by category