- Series: Pragmatic Programmers
- Paperback: 304 pages
- Publisher: Pragmatic Bookshelf; 1 edition (June 7, 2009)
- Language: English
- ISBN-10: 1934356336
- ISBN-13: 978-1934356333
- Product Dimensions: 7.5 x 0.9 x 9 inches
- Shipping Weight: 1.4 pounds
- Average Customer Review: 26 customer reviews
- Amazon Best Sellers Rank: #2,352,259 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.
Programming Clojure (Pragmatic Programmers) 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
All Books, All the Time
Read author interviews, book reviews, editors picks, and more at the Amazon Book Review. Read it now
Customers who viewed this item also viewed
What other items do customers buy after viewing this item?
About the Author
Stuart Halloway is a member of Clojure/core and CTO at Relevance, where he spends his time on secret projects for world domination, and watching Phineas and Ferb.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
Halloway's enthusiasm for Clojure really shines, as his writing has an engaging personality that evangelizes the language without being irritating. The code samples are plentiful yet lean, so they're easy to digest even if you're just reading the book a few pages at a time (which is how I read it, while commuting). The curriculum is also fairly well-designed, this is one book you'll probably read from start to finish and then return to the sections that you want to spend more time with.
I applaud the team that put this book together for not rushing it, as errors of any kind, but in code samples especially, are incredibly distracting for readers trying to understand complex concepts. I don't remember finding too many spelling mistakes or code errors while reading this book, which you know is unusual if you read a lot of programming books. My one criticism is that the last chapter, "Clojure in the Wild", was well-intentioned but felt a little too quick. Rather than just cover a few popular libraries briefly, I'd love to see more time spent on guidance for structuring larger projects.
As of this review (May 2010), Clojure has continued to evolve in features that this book obviously couldn't have included, but it's still a worthwhile read if your goal is to learn the language. If you've read "Programming Clojure" and you plan to use the language, catching up on what's new is just a matter of reading a few blog posts (protocols, etc). This book is a solid introduction to the language - if Halloway updates this book for some future version of Clojure, I'll pay for it all over again.
This book is clear, easy to read, and well-organized (e.g., few forward-references). It's tied together by the "Lancet" example application, a small but useful build tool that provides a Clojure interface to ant tasks. The language features discussed in each chapter are used to add functionality to Lancet in an illustrative way. Well done.
The only down side is that this book is out-of-date and doesn't cover new features in Clojure 1.2. (I've had to search the web for information about deftype & defrecord, for example.)
Practical Clojure (Expert's Voice in Open Source) may be more up-to-date, but I can't comment on that as I haven't read it.
This book is about the Clojure programming language itself, and has only glancing coverage of its libraries (XML, SQL, etc.).
Although I've had some experience with other lisps, I still found the book useful because Clojure has enough new ideas to make it quite a different language. I think it would also be worthwhile to those with no prior functional programming experience.
Perhaps most importantly, after finishing it I was EXCITED about doing more programming in Clojure.
Stuart Halloway glosses over Clojure's fundamental language paradigms, like functional programming, recursion, and Java. While I suspect it would be near impossible to explain functional programming without devoting an entire book to it, Stuart Halloway doesn't even try, instead hoping that the reader will magically figure it out on his own.
The layout of the book is plain frustrating, leading me to wonder if Halloway actually wrote the chapters in the order that they're presented. More than once, Halloway uses the obnoxious literary device of referring to chapters after the current one. "We'll talk about this more in Chapter 18!" Just let me read the chapters in order, Stuart!
Save yourself some mental anguish and purchase The Joy of Clojure: Thinking the Clojure Way or Practical Clojure (Expert's Voice in Open Source) instead.