Customer Reviews


16 Reviews
5 star:
 (5)
4 star:
 (6)
3 star:
 (2)
2 star:
 (2)
1 star:
 (1)
 
 
 
 
 
Average Customer Review
Share your thoughts with other customers
Create your own review
 
 

The most helpful favorable review
The most helpful critical review


27 of 28 people found the following review helpful
4.0 out of 5 stars A clear, concise introduction, but not a "practical" book
Published in June 2010, Practical Clojure by Luke VanderHart and Stuart Sierra is the latest Clojure book to hit stores. Despite the Clojure 1.0 jar shown at the beginning of the book, this title tries to cover the current version of the language, including references to concepts that will be introduced by the upcoming 1.2 version.

The target audience of this...
Published on July 19, 2010 by Antonio Cangiano

versus
4 of 4 people found the following review helpful
2.0 out of 5 stars Disappointing
Disappointing book because the authors are Clojure experts and I have tremendous respect for their work in the Clojure community. However, this book is a dry, rote description of the Clojure language without any practical examples, making the title misleading and the content, not much more useful than the online API documentation. I was looking forward to this book but...
Published on August 25, 2011 by Frederic Daoud


‹ Previous | 1 2 | Next ›
Most Helpful First | Newest First

27 of 28 people found the following review helpful
4.0 out of 5 stars A clear, concise introduction, but not a "practical" book, July 19, 2010
By 
Published in June 2010, Practical Clojure by Luke VanderHart and Stuart Sierra is the latest Clojure book to hit stores. Despite the Clojure 1.0 jar shown at the beginning of the book, this title tries to cover the current version of the language, including references to concepts that will be introduced by the upcoming 1.2 version.

The target audience of this book is programmers who are absolutely new to Clojure. It didn't strike me as being particularly aimed at developers who are coming from the Java camp, or the Lisp camp; in this regard, the book is rather "background agnostic", even though Lisp programmers will feel much more at home than Java programmers will, due to the nature of the language itself.

The authors of the book are clearly well versed in this new language (Sierra is part of Clojure/core, the equivalent of the A-Team in Clojureland) and their confidence with the concepts presented is demonstrated throughout the book. Their explanations tend to be clear and to the point. Longer discussions are occasionally included when required to introduce concepts that are novel to most programmers, like the Software Transactional Memory (STM), refs, atoms and agents.

The book starts out by presenting a short but well-argued case for why Clojure is a worthwhile language, and then focuses almost exclusively on the core of the language. I'm afraid they do so to the detriment of the ecosystem surrounding Clojure. The authors don't talk about how to install Clojure, recommend editors and IDEs (albeit a few are casually mentioned), or how to use build tools like Ant, Maven or Leiningen.

clojure.contrib, a fundamental extension library, is barely mentioned and there is no coverage of other important libraries or emerging frameworks. For instance, perhaps expectedly, Compojure (a web framework) and Incanter (a statistical and graphical environment) are only mentioned as examples of DSLs, however examples of their usage are not provided. (I believe the authors mistakenly refer to Compojure as Enclojure, which is a different project).

Despite the narrow focus, Practical Clojure doesn't shy away from complex subjects and manages to include a chapter on Java interoperability, parallel programming, metaprogramming, and performance considerations. It does so briefly however, favoring a cursory presentation of the fundamental concepts rather than in-depth coverage, which would provide the reader with the degree of confidence required to approach real world problems.

The core language is covered in a manner that acts as both a tutorial and a reference. Major concepts, data structures, and common functions are presented to the reader with an endless supply of tiny examples. It's easy to fly through them, but typing along in the REPL will be a far more valuable exercise for readers who hope to retain the information presented.

This leads us to another shortcoming of this book, which is the lack of more structured and complex examples. When I define their examples as "tiny", with very few exceptions, I really mean it. For the first few chapters of the book the examples don't get much larger than calculating the square root of a number through Newton's method or adding contacts to an address book. Most of the other examples do a good job of illustrating the point they are trying to make with one, two, or just a handful of lines of code.

This is an actual sample of the kind of examples you'll find throughout the book to illustrate many core API functions:

user=> (reduce + [1 2 3 4 5])
15

Note that this approach is didactically valid, because it isolates the function to show exactly how it works. After dozens of these functions though, you may expect larger examples to show how to integrate the use of some of these functions and data structures you've learned about. Such examples are seldom included. Furthermore, the book lacks any exercise for the reader. Foundational books that fail to offer many articulated examples and that lack exercises, tend to make it hard for the reader to retain the information and get some hands-on practice.

I have lots of respect for short books that get to the point and avoid wasting the reader's time. C Programming Language (2nd Edition) (aka K&R) is notoriously acclaimed thanks to its clear and concise nature. However, Clojure is not C, and I feel that the 198 pages fall a little short when it comes to introducing this wonderful language to new readers. There is more to Clojure than simply surveying the language itself, even though I suspect that certain readers may appreciate this extremely narrow focus.

Overall the book is well-edited, despite the presence of minor issues. Aside from a few typos (e.g., "becauseall" on page 79), readers may find the formatting to be slightly inconsistent at times. For example in chapter 5 when presenting sequences, after the map function has been introduced, the font for the subsequent functions is substantially decreased for no apparent reason. Readers may be misled into thinking that the functions presented afterward are somehow different from the previous ones, when in fact they're all defined in clojure.core. In Listing 6-3, at page 103, the authors present their first "complex" example (the address book) and they do so by using, among others, doseq. This macro was not introduced before that page nor is it really explained within the example.

From a physical standpoint, this book is a rather thin and wide paperback. A small font, coupled with small margins and a wide layout, imply that the readability of the book suffers a little. The paper itself is off-white, fairly thick and slightly textured, not as pleasant to the touch as other books by Apress or most other technical publishers, even though I recognize that this is a matter of taste (some people may actually love it because of these characteristics).

With two introductory Clojure books on the market, drawing comparisons is unavoidable. Stuart Halloway's Programming Clojure (Pragmatic Programmers) is a slightly older book (published in May 2009), which grants Practical Clojure a distinct advantage. This is not to say that Programming Clojure is obsolete, on the contrary it's still a valid choice, but it doesn't illustrate some of the new features that are available today. For example, in chapter 13 Practical Clojure introduces protocols and datatypes that will be available in Clojure 1.2 for the first time. Given that Halloway's book was published more than a year ago, there was no possible way he could have included such powerful abstractions at the time.

Despite being older and less methodical than Practical Clojure, Programming Clojure tends to offer more complex examples. In the introduction of Programming Clojure you'll see examples which Practical Clojure fails to include until much later in the book. Practical Clojure, the subject of this review, may leave you wanting for more practical examples of how all the language features fit together. Whereas Programming Clojure may leave you longing for more consistent explanations of how each part of the language works on its own.

Practical Clojure and Programming Clojure are competitors in the marketplace, but it wouldn't be a bad idea to get a hold of both, because they complement each other quite well, in my opinion. Having to pick just one, I would probably recommend Practical Clojure, given its more consistent and up to date presentation. The sizzle offered by Programming Clojure, can be found to a much greater degree in upcoming and less introductory books, such as The Joy of Clojure: Thinking the Clojure Way. In this sense, reading Practical Clojure first followed by The Joy of Clojure, would be a solid learning path (Clojure in Action is another worthy addition, but it doesn't replace The Joy of Clojure, which is a real gem).

In conclusion, Practical Clojure is not the Clojure equivalent of the highly praised Practical Common Lisp, from the same publisher. Reading it cover to cover and typing all the snippets included within, will not give you enough knowledge to start writing complex, idiomatic Clojure programs out of the gate.

However, if you are learning Clojure today, I do recommend this book. It's a clear, well thought-out, concise introduction to the language that will give you a solid foundation as you go on to learn more about Clojure and Lisp in general.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


23 of 24 people found the following review helpful
4.0 out of 5 stars JUST an introduction, June 8, 2010
Verified Purchase(What's this?)
Presently there are two books out on the clojure language: Stuart Halloway's Programming Clojure and this one (hereafter referred to as V&S). Both are quick romps through the main concepts and features of the 3-year old language.

Generally, I found V&S conceptually better organized and with better prose. Halloway's prose is a frenetic interleave of brief 1-3 sentence paragraphs and single-line repl examples. V&S actually uses whole paragraphs and graphical diagrams which I found more conceptually elucidating, in some cases tying up loose ends from reading Halloway.

Somewhat ironically then, a major setback of V&S is the almost complete lack of example application code. Whereas Halloway develops at least two programs throughout the book (the Lancet example and the Snakes game) in addition to the plethora of repl snippets, V&S rely entirely on short illustrative repl snippets. V&S would have benefited greatly from including more complex applications than singular repl functions.

Both books are useful introductions to the main conceptual novelties of clojure (stm, java interop, etc.), but neither will produce competent functional programmers from those coming from the imperative mainstream. Do not buy this book if you have no functional experience and expect to be an idiomatically competent clojure programmer after reading it.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


6 of 6 people found the following review helpful
5.0 out of 5 stars Best introduction so far (Aug. 2010), August 20, 2010
By 
H. Yang (San Jose, CA) - See all my reviews
(REAL NAME)   
Clojure was first announced in 2007. So far (Aug. 2010) there are two books on the market. The first book, Programming Clojure, was written in a chatty prose, so it is less usable as a language reference book. The current book under review is organized more like a traditional language reference book, so it is easier to look up things. This suits a programmer like me better, who are more used to learn by doing: building small applications and looking up needed pieces when problems are encountered. In addition, this book covers features of Clojure 1.2, which is just out.

There are also two other books that are not finalized yet, but available as electronic early access versions from the publisher (Manning). I am reading one of them, Joy of Clojure, which is a more in-depth book than the two on the market, but also written in chatty format. For my current level of experience (a few months of playing with small code, no previous Lisp experience), I feel the current book under review is the best choice.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


4 of 4 people found the following review helpful
2.0 out of 5 stars Disappointing, August 25, 2011
By 
Frederic Daoud (Montreal, Canada) - See all my reviews
Disappointing book because the authors are Clojure experts and I have tremendous respect for their work in the Clojure community. However, this book is a dry, rote description of the Clojure language without any practical examples, making the title misleading and the content, not much more useful than the online API documentation. I was looking forward to this book but the authors just mechanically go through the language, making it more of a reference rather than a page-turner. I would have accepted it as a good reference, but it fails even at that because they do not give enough examples of how to use Clojure's features, leaving you to go elsewhere to figure it out.

Better titles include Manning's "The Joy of Clojure" and the upcoming "Clojure in Action". I also very much look forward to O'Reilly's "Clojure Programming". Clojure is an excellent language and it deserves better books than this one.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


8 of 10 people found the following review helpful
5.0 out of 5 stars A tour of core language, rather than an in-depth tutorial, July 10, 2010
There are now 2 final edition clojure books, and 2 by Manning pre-released as draft "MEAPs". VDH and S have done a very clear overview of the core clojure language only, vs. Halloway and Fogus /Houser books, which are more comprehensive and dense presentations (I'm not saying dense is worse for all readers, just the other 2 take more effort. I havne't read Rathore's book, but I've heard mostly good things about it). I think VDH and S covers 1 sigma of what you need to know to code in clojure, and covers that material very well, given a moving target of clojure releases 1.0, 1.1 and what they knew of 1.2 when they put book to press. And that's important. A lot of programming language tutorial to intermediate books take a lot of effort to read, let alone do exercises. This book, liek the Pragmatic Scala book, encourages you to open emacs and start coding, it invites you in. I've been coding clojure for a little while, so it was mostly review, but i think this would be the best first exposure to clojure for both ruby and java types, and people starting out programming.

When i say language only, there's no discussion of clojure.contrib, or the emerging infrastructure of leiningen, sbt, testing libs, etc. Other reviewers have noted that. Also no exercises and few of the little sidebars that Oreilly, Pragmatic and Manning give you(the animal tracks and traps). Another thing that might be a drawback for some, is small fonts and very small page margins. This is fine for me, but it's a lot of eye movements per line. But the important thing is this is a very clear presentation of the core concepts of the language (data structures, concurrency, macro's, java interop, performance tuning)
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


8 of 10 people found the following review helpful
5.0 out of 5 stars Finally, a good book on Clojure, June 15, 2010
Verified Purchase(What's this?)
This may be the best computer book I've ever read - and with 30 years experience as a programmer I've read a lot of them. Why is it so good? Mostly because of what they don't do. They don't spend page after page telling you how great the language is. They don't give long explanations of what you SHOULDN'T do. They don't create some long involved example that you have no interest in and will never use. And they don't go off on tangents about things that seem to have no relation to the task at hand. Instead, they explain the language in great detail but in terms any programmer will understand. I have been using Clojure for about six months now and I still learned a lot from this book. Clojure is a very important new language and may be one of the best Lisp dialects ever. If you don't know Lisp, it does not matter. If you know Java you will be amazed at how much simpler it is to write programs. This book is a huge step toward bringing Clojure into the mainstream. My hat is off the the authors.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5 of 6 people found the following review helpful
3.0 out of 5 stars More basic than practical., July 25, 2010
Verified Purchase(What's this?)
The book is easy to read and covers the basics. It however, doesn't offer any insight in how to put the pieces together to build programs.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


2 of 2 people found the following review helpful
4.0 out of 5 stars Latest Beginner's text (7/2010), July 13, 2010
By 
Bob Savage (Watertown, MA United States) - See all my reviews
Verified Purchase(What's this?)
There are a couple of ways of evaluating a book like this. The first is to compare it against other books of its kind. Since this is the first book I have read about the Clojure programming language, I can't really say if this is better than the (singular) alternative text. However, being recently published, it does have the opportunity to be a little more up-to-date, an opportunity that Practical Clojure utilizes to include a chapter on Datatypes and Protocols, two features added in Clojure 1.2 (still to be released). Of course the downside to a brand new book is that some mistakes creep in that might be corrected in future editions. The most prevalent mistakes that I noticed were inconsistencies in formatting. The most serious such mistake was use of the doseq form without explanation.

The other way that one might evaluate a book about a programming language is to explain the level at which it is aimed. Such levels might be characterized as Introductory (meaning the reader is ignorant of basic programming concepts), Beginner (emphasizing the rudiments of the language's syntax, and how to do basic things), Intermediate (usually a comprehensive reference of language elements, including standard libraries, as well as a walkthrough of some larger "realistic" example code), and Advanced (either a deep-dive on a particular topic, or explanations of the most esoteric features). Practical Clojure is a "Beginner" text in the sense explained above. The reader will find a description of core language features, but standard libraries are barely referred to. Sample code is extremely short, which means the reader won't find much guidance on idiomatic solutions for more realistic problems.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


8 of 11 people found the following review helpful
1.0 out of 5 stars Impractical and disappointing, May 12, 2011
By 
Amazon Customer (Montreal, Canada) - See all my reviews
Verified Purchase(What's this?)
This review is from: Practical Clojure (Expert's Voice in Open Source) (Kindle Edition)
If practical means learning by doing, then this book is the opposite. It's more like a tour in the language and very sloppy one at that.

I just finished reading this book and I feel that I can't do anything in clojure. Bear in mind that I'm an experienced c# programmer but I don't know lisp.

All the book does is goes through the various language features (lists, vectors, maps, stm, refs, agents, macros, jave-interop..etc) one after the other explaining what they're but will not show you how to connect them to do anything useful.

It even forgets to talk about fundamental things until very late in the book for example quoted expressions and the let bindings.

What's even more annoying is that it doesn't stop telling you how great, amazing, elegant, sexy and how object-oriented is crap and how clojure got it right. But you never get to see all this awesomeness even if you're willing to believe.

I'm very disappointed in this book and I don't exactly know where to go from here.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


1 of 1 people found the following review helpful
4.0 out of 5 stars A nice book, It's a good startpoint to clojure programming, November 16, 2011
This review is from: Practical Clojure (Expert's Voice in Open Source) (Kindle Edition)
it is nice book with a general vision of the clojure language, it is a well structured book, and the book gives to you a very solid idea about the functional programming with clojure language, if you want to start to know how to do things with a lisp flavored style language, this book is a good choice. This book is about clojure, not functional programming techniques.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


‹ Previous | 1 2 | Next ›
Most Helpful First | Newest First

Details

Search these reviews only
Rate and Discover Movies
Send us feedback How can we make Amazon Customer Reviews better for you? Let us know here.