Facility Spring Cleaning Spring Reading 2016 Amazon Fashion Learn more nav_sap_cbcc_7_fly_beacon The Jayhawks Fire TV Stick Grocery Made in Italy Amazon Gift Card Offer out2 out2 out2  Amazon Echo  Echo Dot  Amazon Tap  Echo Dot  Amazon Tap  Amazon Echo Introducing new colors Kindle Paperwhite UniOrlando Shop Now SnS

Your rating(Clear)Rate this item

There was a problem filtering reviews right now. Please try again later.

on March 19, 2014
The best resource I have found for getting started with the Clojure language, including other books. Clear and concise explanations, relevant examples, and a nice style in general.
0Comment|Was this review helpful to you?YesNoReport abuse
on February 28, 2011
I whole-heartedly agree with Kelly Jones and Robert P. Seaton. This book is very overrated. While Halloway's style is easy to read, the book lacks depth and is seemingly unordered. Clojure is a marvelous language, and this shallow introduction simply doesn't do it justice. I haven't read any other books on Clojure, but I'd be quick to recommend any one of them over this one.
11 comment|2 people found this helpful. Was this review helpful to you?YesNoReport abuse
on November 9, 2010
I think of myself as a Java aficionado, but it's been on my to-do list for years to learn more about functional programming languages. This book was perfect for me, because it's not just a great tour of Clojure, but also a pretty good introduction to the functional style of programming.

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.).
0Comment|2 people found this helpful. Was this review helpful to you?YesNoReport abuse
on September 28, 2010
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.
0Comment|14 people found this helpful. Was this review helpful to you?YesNoReport abuse
on May 18, 2010
This book is a very good guide about the Clojure programming language. It is not a reference, so, you need to complement this book with another resources like the official API, the very good screencasts that are around the web, slides, etc. In general, a very good book about a very promising programming language.
0Comment|Was this review helpful to you?YesNoReport abuse
on May 5, 2010
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.
0Comment|4 people found this helpful. Was this review helpful to you?YesNoReport abuse
on March 23, 2010
Clojure is the most elegant and effective language to cross my path in recent times. This book captures the essence of that elegance, while opening your eyes to the many defects common to mainstream practices in software engineering. Seasoned Java practitioners will feel right at home here, despite the functional hurdle, thanks to the elegant Java interoperability of this Lisp reloaded for the JVM. Highly recommended.
0Comment|Was this review helpful to you?YesNoReport abuse
on January 30, 2010
You really need some programming experience to follow this book. Still, if you are new to functional programming and Clojure, this is a good place to start. I have referenced the book constantly as I learn Clojure, and find the book extremely useful.
0Comment|One person found this helpful. Was this review helpful to you?YesNoReport abuse
on January 8, 2010
This book gave the right amount of detail for me, in about the right order, and I expect it to be a useful reference going forward. If you have a passing familiarity Lisp, and have done a modicum of metaprogramming in some language or other, this book will strike a chord: "Yes, that's how a modern programming language should look."

Clojure may not be quite "there" yet, mainly because it is not yet battle-hardened and library supported in the same way as my native C++, but it's promising enough that I'm starting to do real work with it.

This is the only title from this publisher that has not let me down: Data Crunching is a horrid book, in that it is filled with bad advice, and Programming Ruby just lacked information density, i.e. the information could have been covered in a much shorter book. After the good experience with Programming Clojure, I tried one of the PDF books from PragProg (on Google Web Toolkit), and my only complaint so far is that the examples need tweaking to work with the latest version of the software.
0Comment|2 people found this helpful. Was this review helpful to you?YesNoReport abuse
on December 17, 2009
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.
22 comments|91 people found this helpful. Was this review helpful to you?YesNoReport abuse

Send us feedback

How can we make Amazon Customer Reviews better for you?
Let us know here.