Browse Books

Reviewer: David E. Goldfarb

The foreword to this book begins, "As you read this hilarious book, you will at some point experience a very serious moment." Then, in his introduction, the author promises to teach Clojure by exploring four directions: setting up the development environment, syntax and semantics of the language, deployment and library integration, and language philosophy. All this is done in a playful way with, as the author says, "exercises like assaulting hobbits and tracking glittering vampires." The book was published in late 2015, and covers the current environment including Clojure 1.7, Cider/Emacs tooling, and both the Leiningen and Boot frameworks. Topics covered include getting started, using Emacs, Clojure fundamentals, namespaces, macros, concurrent programming and software transactional memory, core.async, Java Virtual Machine (JVM) interop, and protocols and records. The style is lighthearted, mixing the technical content with cute, if often irrelevant, illustrations and a steady stream of groan-worthy one-liners. (Example: "Strings represent text. The name comes from the ancient Phoenicians, who one day invented the alphabet after an accident involving yarn.") The technical style is also casual, but in a positive sense. Rather than writing a standard reference or tutorial manual, the author explains Clojure through many short examples illustrating key points. The coverage is, therefore, not totally complete, but is very pleasant to read and understand. The first section is about basic tooling and setup and includes a brief but excellent introduction to Emacs and Cider, with links to many external references. This is followed by a pretty standard introduction to the Clojure language. It covers all of the required basics, but occasionally jumps too fast for the novice reader. For example, Clojure's get-in function is afforded only one line and a single example, not enough to really explain its full generality. Similarly, the discussion of argument destructuring presents only some examples rather than complete documentation of this powerful and idiosyncratic Clojure feature. This weakness continues in the next chapters, as the author continues to teach purely by example. For instance, he first reads text from a file on page 94, using the slurp function without explaining it. A quick check of the index shows a more complete explanation on page 263. (And, distressingly, the same index line lists, but does not distinguish, the totally unrelated Emacs use of the term on page 20). The audience for this book includes practitioners and students who are looking for a soup-to-nuts presentation of how to get started with Clojure. It assumes a reasonable level of experience with other languages, for example implicitly assuming that the reader understands concepts like functions, scope, and even closures. The book gives a fine introduction to the Clojure language and environment, but is sometimes too brief. Becoming an effective Clojure programmer will require additional resources to fill in the details elided in this book. Fortunately, many such resources exist, both on paper and online. This book is a valuable starting point for exploring Clojure, supplying a coherent and current view of the full landscape. More reviews about this item: Amazon Online Computing Reviews Service