Customer Reviews

Programming Clojure (Pragmatic Programmers)

5 star:		(18)
4 star:		(2)
3 star:		(1)
2 star:		(4)
1 star:		(0)

 

 

It is hard to be objective when reviewing this book. I have struggled to separate my enthusiasm for "Clojure The Language" from my honest opinion of "Clojure The Book".

Clojure is a remarkable language.

Clojure The Language deserves five stars every day of the week and twice on Sunday.

Clojure "The Book", on the other hand, is simply passable. The book is "okay".

Clojure is remarkable partly because Lisp is remarkable, and partly because Clojure has taken the difficult concept of concurrency and turned it into an exhilarating, attractive, efficient, sensible tool. I highly recommend that all curious programmers try the Clojure language.

Unfortunately, I cannot give this book a high recommendation. This is not a bad book. But it is definitely not a 5-star book.

The 5-star score would place this book in the same category as such beloved books as the Flanagan/Matsumoto Ruby book, or Meyers' Effective C++, or even Rossum's original (now deprecated) An Introduction to Python. Scoring the Stuart Halloway book as "on par" with those other books just simply does not ring true.

The Stuart Halloway book is a fast and easy read. However, it is more like a series of really nice blog entries than a solid introductory programming language book. I enjoyed Stuart's writing style, and I even enjoyed all of the sample code.

However, at the end of the day, "there is no there there".

I needed to refer to other books in order to become PRODUCTIVE with Clojure. When I purchased the Halloway book, no other Clojure books had been written yet, so I relied upon books that were written about coding techniques in other flavors of Lisp.

Reading the Halloway book was like watching a really fun and captivating movie trailer. It made me stop and say "Wow! That was cool! ... um... okay. Now can I watch the entire movie?"

If you are already fluent in another Lisp dialect, then you probably do not need this book.

In fact, if you already know some variant of Lisp, then you need to learn about the JVM and various Java platform ideas far more than you need to study Clojure itself. Clojure itself will come naturally to a "lisper". Yet you may be mystified about where to put your jar files and about what the various Java exceptions are telling you. And if you want to debug your Clojure programs, you will likely be using a Java debugger.

If you know Lisp, you can combine that previous knowledge with the Clojure API documentation, and the excellent Mark Volkmann website, and that will probably be enough. An "industrial strength" book on Java (including various compilation and deployment techniques) will help you much more than a book on Clojure.

If you have never programmed in any sort of Lisp at all, then I can almost guarantee that this book on Clojure will not be enough to get you fully "up and running" with Clojure. Most certainly you will learn how to write small scripts and games like the ones demonstrated in the book, but you will probably start to feel the weakness of this book as soon as you want to build something larger.

The chances are slim that you are considering buying this book because your job requires you use Clojure, but rather, like me, you are wondering whether Clojure is worth your time. Is it just another programming language fad? What can I do with it that I can't with more established languages like C++, Java or Python? If and only if you are satisfied that it is worth your time will you begin to want to know all of the details of how to use Clojure.

Programming Clojure strikes a nice balance between these two jobs, both justifying Clojure's existence, and lucidly explaining its key features. After a Foreword by Rich Hickey, the language's founder, the preface highlights its key features, and provides a frame of reference for how to think about Clojure from a variety of perspectives (coming from an OO, functional or lisp background). From there it's off to the races.

I bought a preview of this book and actually spent the better part of a Saturday plowing through much of it on my laptop, switching over to the command line to play along. Since then, I have gone back to re-read different sections as needed. Though the public documents at clojure.org are quite good, this book is definitely worth paying for if you are serious about learning Clojure.

Finally, it's worth mentioning that my experience buying the ebook / print combo directly from the publisher's site was good, providing both pdf and a variety of ebook formats (including one that looks nice on the kindle).

This book lacks anything close to sufficient depth. Clojure is a deep language and Programming Clojure simply fails to do it justice. Most of the book reads like API documentation. The example code, mostly one liners, leave the reader feeling unsatisfied. What if I want to write a program that's more than five lines of code?

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.

Clojure is a breath of fresh air as well as a history lesson to all of us Java programmers who were raised on object-orientation and (possibly) over-medicated with design patterns. Functional programming with a dynamic, Lisp-based language that has the power of the libraries within the Java ecosystem is both extremely freeing as well as extremely fun.

Progamming Clojure provides gentle yet thorough coverage to what is a new world for many of us. I've found Clojure great for new, green-field development projects but it's also very nice in existing Java environments. For example, I've used the skills acquired in this book to use Clojure for writing Eclipse plug-ins, JSR-286 portlets and even for REST/JSON services running on Google App Engine. Frankly, coming from a person who has also tried out many other alternative languages (including Python, Groovy, Scala, Ruby, etc.), Clojure has made programming more cerebral, productive and exciting all at the same time.

The answer is, of course, that different is simply different. Whether it's good or bad depends on your tolerance for change. I've spent years as a Groovy/Java developer. That experience makes Clojure's dialect seem quite exotic. If, on the other hand, I was a Lisp programmer from way back, Clojure would most likely seem intuitively obvious.

As an object-oriented programmer, when learning a new language I immediately look for ways to do familiar things like define classes and declare variables. Clojure is a functional language -- there are no POCOs (for lack of a better metaphor), but there are defstructs. Everything is a function. Immutability is the default.

This impedance mismatch between my world view and Clojure's is captured best in the "Where's my for loop?" section. The answer -- "Clojure's for is not a loop but a sequence comprehension" -- tells me that I'm not dealing with a language that will simply require me to put my parentheses in a slightly different order. I'm dealing with some serious metaphor shear.

That said, I think that Programming Clojure does a great job of introducing these concepts in a brisk, approachable way. Another reviewer complained of spending too much time in REPL (an interactive Clojure shell -- think BeanShell for Java, groovysh for Groovy, irb for Ruby, etc.). I found Stuart's REPL-centric approach to learning Clojure to be a huge plus -- it gave me a sandbox to explore the language, experiment with the syntax, and run the code as I read it. This isn't a book that I could simply skim -- I had the Kindle edition open, sitting next to my laptop with a REPL session running at all times. Stuart also talks about compiling and deploying Clojure in production, but as a learning tool, REPL's pedagogic value simply cannot be overstated.

The fact that Clojure runs on the JVM, and allows you to call into any Java class, gave me the best chance to see these two very different worlds running side by side. There is an entire chapter dedicated to Clojure/Java interaction. As Stuart says, "When you call Java [from Clojure], you enter the familiar, mutable world. This offers a comfortable haven for beginners learning functional programming and a pragmatic alternative to functional style when you need it." The examples involving the Collections API, JDBC, and even simple HTML output, were the most helpful to me. They demonstrated not just the syntactic differences between these two languages, but the semantic differences as well.

As you can probably guess from my 5 star rating of Programming Clojure, I think that "different" in this case is unquestionably good. Reading this book has stretched me in new directions. Each time you learn a new language, it makes you better programmer -- even in languages you already know. It forces you to reconsider your existing, tried-and-true approach to solving problems. Programming Clojure is a long-term investment in my knowledge portfolio.

In short:

The book is great. Not too long, well-written, and covers the right amount of the language and libraries without going overboard.

In depth:

I was a technical reviewer for this book, so I got to read several revisions. Each was better than the last. Even the early versions were clear and concise...and the latter characteristic is particularly rare in technical books. With a comfortable style and weighing in at 200 pages, this is an easy read. It progresses through the language and libraries at a quick pace while managing to cover all the major features and API areas in enough depth to get you well-started. And let's face it: chapters covering every API in excruciating detail are unnecessary.

If you're looking to learn Clojure, I highly recommend this book. You'll need some minimal background in Java or a similar technology to get the most from the book. (I'm a C# guy with little Java experience, and the two are similar enough that I had no problem figuring out the concepts.) I had some familiarity with Common Lisp before plunging into Clojure, and that helped, but I think the book is still very approachable to those with none. You'll just need to spend a bit more time on a few of the chapters that cover language basics.

As one who promotes the concept of polyglot programming (particularly on the Java platform), I was intrigued about what Clojure had to offer. As a Clojure novice, I found this book to be a great way to learn about the Clojure language and why it matters.

One thing that irritates me about books on programming languages or frameworks is that they sometimes seem like a solution waiting for a problem. Why should I care about Closure? What problems does it solve? What scenarios would be a fit for Clojure and which ones wouldn't be a fit? Why would I choose Clojure over Java? Stuart does a good job of answering these questions and more at the beginning of the book, which is where I see many programming books fall short.

One of the many things I like about this book is the plethora of examples to back up the prose and concepts Stuart is trying to get across. Rather than long, complex examples, Stuart seems to have opted for shorter, easy to understand examples using REPL (read-eval-print loop), which makes it very easy to follow along and try out yourself while reading the book. This makes both reading and learning the language very fast and easy. However, don't let these short examples fool you - there are plenty of longer and more complete Clojure examples, particularly in chapter 6 (Concurrency) and chapter 8 (Multimethods).

Perhaps the one thing I like best about this book is the way it flows. Rather than page after page of pontification and prose, Stuart backs up almost everything he writes with a code example that is short enough to avoid the ceremony yet complete enough to get the concept across. For example, one of my favorite chapters is chapter 6 (Concurrency), where Stuart describes Clojure's STM (Software Transactional Memory) - cool stuff by the way - and also the use of agents. He uses plenty of examples, which help provide a concrete aspect to an otherwise abstract concept.

Another thing this book does well is describe the interaction and integration between Clojure and Java. Stuart does a great job of making sure you know the syntax and use cases for interacting with the Java API - even in the concurrency chapter (chapter 6 - my favorite), where he describes interacting with Java callback event handlers (more cool stuff!).

The bottom line is this - if you have ever wondered about Clojure and want to find out the what, why, and how, then this is the book to read. Now, if we can just do something about all those parenthesis....

In case you haven't heard of it yet, Clojure is a programming language designed by Rich Hickey, a Lisp dialect, that runs on the Java Virtual Machine and is designed support concurrent programming.

Clojure has excellent documentation and Rich has posted several great videos of talks he has given that cover the rational for Clojure as well as an introduction into the major concepts. I highly recommend that you watch those videos if you haven't already because Rich does a great job explaining why concurrency is hard using the typical Object-Oriented model that we program in today and how the features of Clojure support a better model for concurrency. Whether you are programming in Java, C#, Erlang, Haskell, Python, Ruby, etc., you will probably be able to learn something from these talks, and plus Rich is just an interesting guy to listen to.

So after all that, you might be saying why do we need a book about Clojure? The answer is that although the documentation is good, it can be a little intimidating when first learning Clojure. For programmers with little or no Lisp or functional programming experience, figuring out how to do basic things the idiomatic way in Clojure can be a daunting task. Stuart's book does an excellent job filling this gap.

The book covers all the major feature of Clojure and is very up-to-date. During the beta review period, chapters were often completely re-written to keep up with changes in the language that occurred before it stabilized in a 1.0 release. I think the final product greatly benefited from that work and is an excellent resource for learning Clojure. I encourage you to pick up a copy today.

One of the better technical books I've read in a while. It's concise, but not to the point of being dry - the author's voice still makes for an entertaining read. Avoids many common flaws (are you listening, ORA editors?) with recent programming language books: all of the examples I've tried compile as written; forward references to unexplained topics are rare, and clearly marked; introductory naive code examples are explicitly commented as such, with the "right" way to do it presented immediately thereafter.

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.

I have three different categories for programming books I've read - those I don't need anymore, those that I want to keep but generally won't read again, and those that I want to keep on hand because I know I'll go back to them frequently. Usually "language tutorial" programming books like this one are in either of the first two categories, but "Programming Clojure" is staying close to my desk.

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.