- Paperback: 432 pages
- Publisher: Manning Publications; 1 edition (November 20, 2011)
- Language: English
- ISBN-10: 1935182595
- ISBN-13: 978-1935182597
- Product Dimensions: 7.4 x 0.9 x 9.2 inches
- Shipping Weight: 1.5 pounds (View shipping rates and policies)
- Average Customer Review: 9 customer reviews
- Amazon Best Sellers Rank: #2,017,936 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Clojure in Action: Elegant Applications on the JVM 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
See the Best Books of 2017
Looking for something great to read? Browse our editors' picks for the best books of the year in fiction, nonfiction, mysteries, children's books, and much more.
Customers who viewed this item also viewed
What other items do customers buy after viewing this item?
About the Author
Amit Rathore is a VP of Engineering and has a decade of experience building highly performant, data-heavy web applications.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
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.
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.
* an excellent explanation of functional programming concepts
* a good introduction to Clojure syntax and common functions
* 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.