- Paperback: 304 pages
- Publisher: Pragmatic Bookshelf; 1 edition (7 Jun. 2009)
- Language: English
- ISBN-10: 1934356336
- ISBN-13: 978-1934356333
- Product Dimensions: 19 x 2.3 x 22.9 cm
- Average Customer Review: 3 customer reviews
- Amazon Bestsellers Rank: 1,431,058 in Books (See Top 100 in Books)
Programming Clojure (Pragmatic Programmers) Paperback – 7 Jun 2009
There is a newer edition of this item:
Customers who bought this item also bought
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.
About the Author
Stuart Halloway is a co-founder and CEO of Relevance, Inc. Relevance provides development, consulting, and training services based around agile methods and leading-edge technologies such as Ruby and Clojure. Stuart has authored several other books including Component Development for the Java Platform and Rails for Java Developers.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
This isn't necessarily one of those books. But as a book you read once, enjoy very much, and come out with what you came for - an understanding of what Clojure does, how to use it and how to think about it - it's excellent.
Part of the pleasant experience is to do with Clojure itself, because it's a genuinely nice language and the process of learning it is a nice little series of "aha!" moments. But partly it's the book itself. The online resources on Clojure are great; much like Java itself, tha API documentation is voluminous and helpful. But Stuart Halloway's book imposes a very intuitive order on the learning process. There are interesting sidebars and digressions, but the layout is such that you can pick and choose without getting sidetracked, if that's what you want. If you already know exactly what functional programming is, you can follow the thread past those explanations and just see how it applies to Clojure. But it's worth reading even if you do, because it's well-written and might help you explain it to someone else one day.
Obviously it can't cover everything (in particular, I quickly found myself wanting to get more information about interfacing with Java code than was in the book), and the state of the art moves faster than the paper world. Fortunately there are plenty of entry-points and references to online resources, all of which have proved very relevant.
Books on Clojure are a bit thin on the ground as yet, but no doubt they will be raining from the sky as the language gathers momentum, then mindshare, then publishers catch up with the hype. When that happens, if you're learning Clojure or know it a little bit but want to take it a bit more seriously, buy this book. It will still be the right one.
Most helpful customer reviews on Amazon.com
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.