Customer Reviews

Practical Clojure (Expert's Voice in Open Source)

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

 

 

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.

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.

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.

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)

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.

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.

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.

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.

When I first heard about Luke VanderHart's and Stuart Sierra's "Practical Clojure", I was really anxious to get my hands on it. I had already read a book about Clojure - Stuart Halloway's "Programming Clojure, so I was pretty much equipped to write Clojure applications. I however needed more practical guidance and the title of "Practical Clojure" seemed to have guaranteed so. As it eventually turned out, the word "practical" in the title came out synonymous to "Definitive Guide" or "Reference" and the book was more tutorial-oriented not practical one. Although it explained the concepts of Clojure way better than "Programming Clojure" I didn't expect to have read a book about Clojure's architecture and overview of available functions. The title made me think that it was supposed to have helped me understand where and why it should be used. The word "practical" upped my expectations high and therefore the book fell short. It's not to belittle this book in any way - the book is highly valued, but the title should've been different.

I'm still faced with the trouble of getting the gist of programming real-world applications in Clojure and "Practical Clojure" didn't yield much increased understanding. I think the title spoiled the real intent of the authors to lend readers a helping hand and turn them into Clojurians which I think was pretty much achieved (once practical aspect's left aside). However, the title still bothers me and was very misleading. Having yet another look at Clojure in a introductory manner surely doesn't hurt. It appears to me that "Programming Clojure" is more practical than "Practical Clojure" despite its name. Both are a must-read and well-written. I don't remember knowing or even hearing about many of the functions mentioned in "Practical Clojure". I really liked reading side notes like the one about recur on page 40 or the caution about conj on page 77 that hit the nail on the head. Figures helped enormously understand the topic. One could say that the book paved the way for a more detailed exploration of Clojure and its practical's part might've stemmed from the fact that I found out a lot without even having noticed or expected it? It could be that way since the writing style is very comprehensible and pleasurable. The authors showed their fluency in writing clearly and straight to the point with many short examples. Introduction-sample-explanation-sample-repeat writing style worked very well.

Many chapters, e.g. chapter 4. "Data in Clojure" and chapter 5. "Sequences", were kind of summary of available data structures and/or appropriate functions. It's very handy when needed, but reading them one by one turned out a quite boring experience. It was not something I'd expect in a book with "Practical" in its title.

The chapter 6. "State Management" paid a great deal of attention to Clojure's STM and I'm quite comfortable with the concept. The authors spared no efforts to explain Clojure with a great care. At some point, I had to stop reading as felt mind-exhausted. So many low-level explanations were terribly helpful, but required constant attention. I'm going to read it over and over again to grasp the concepts in their entirety. Very effective in teaching Clojure's STM and STM in general.

The summaries served as a final guideline how to use Clojure effectively. They weren't only to fill out pages with not-much-useful knowledge. They were as much helpful as the material outlined in the chapter itself. The summary of the chapter 10. "Java Interoperability" could very well serve as an introduction to Clojure.

When I read about multimethods and inheritance in the chapter 9. "Multimethods and Hierarchies" it was quick and very comprehensible. It's of much value when I can flow through formerly-hard concepts easily and be sure to understand them well.

I put the final rating of 4 stars down to the fact that the title of "Practical Clojure" seemed to have introduced a practical use of Clojure not elaborate on Clojure's architecture and available functions. It's highly recommended though (provided you consider "practical" in the book's title less important).

it's clear & well written introduction to clojure,
but is a bit skimpy on the details. i often found
myself asking, but what about this or that, and
not finding the answer in the following sentence,
as i would have in the truly great technical texts.

it also has some major omissions: testing and
even list comprehensions are never mentioned.

for a $50 cover price, i think another 100 pages
to fill it out would have been justified.