Practical Clojure (Expert's Voice in Open Source)

enlarge

Authors: Luke VanderHart, Stuart Sierra
Publisher: Apress
Category: Book

List Price: ~~$49.99~~
Buy New: $25.55
as of 9/9/2010 05:24 EDT details
You Save: $24.44 (49%)

New (22) Used (10) from $24.70

Seller: sweethomeliquid2
Rating: 4.0 out of 5 stars

9 reviews
Sales Rank: 576253

Media: Paperback
Edition: 1
Pages: 232
Number Of Items: 1
Shipping Weight (lbs): 1.1
Dimensions (in): 9 x 7.4 x 0.8

ISBN: 1430272317
Dewey Decimal Number: 005
EAN: 9781430272311
ASIN: 1430272317

Publication Date: June 7, 2010
Availability: Usually ships in 1-2 business days

Features:

•	ISBN13: 9781430272311
•	Condition: New
•	Notes: BUY WITH CONFIDENCE, Over one million books sold! 98% Positive feedback. Compare our books, prices and service to the competition. 100% Satisfaction Guaranteed

Also Available In:

•	Kindle Edition - Practical Clojure

What you’ll learn

What Clojure is—more than just another Lisp
How to set up a Clojure environment
The structure and syntax of a Clojure program
Java interoperability
How to use Clojure for real-world tasks
Common idioms of Clojure code

Who is this book for?

There are two audiences for this book: any technical person desiring to know what Clojure is and why they might want to use it, and any programmer desiring to learn and use the language. The goals of these two audiences mesh nicely, given that Clojure has several new, cutting-edge features that programmers are unlikely to have encountered before.

Customer Reviews:

Showing reviews 1-5 of 9

1 2 Next »

Kind of Definitive Guide or Reference to the Clojure language - lots of how but not much where and why August 27, 2010
Jacek Laskowski (Warszawa, Poland)
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).

5 out of 5 stars

Best introduction so far (Aug. 2010) August 20, 2010
H. Yang (San Jose, CA)
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.

3 out of 5 stars

More basic than practical. July 25, 2010
GeoffK
1 out of 1 found this review helpful

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.

4 out of 5 stars

A clear, concise introduction, but not a "practical" book July 19, 2010
Antonio Cangiano (Toronto, Canada)
7 out of 8 found this review helpful

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.

4 out of 5 stars

Latest Beginner's text (7/2010) July 14, 2010
Bob Savage (Watertown, MA United States)
2 out of 2 found this review helpful

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.

Showing reviews 1-5 of 9

1 2 Next »

CERTAIN CONTENT THAT APPEARS ON THIS SITE COMES FROM AMAZON SERVICES LLC. THIS CONTENT IS PROVIDED ‘AS IS’ AND IS SUBJECT TO CHANGE OR REMOVAL AT ANY TIME.

Online since 1996

Ad unit2 160x90

Sponsors Ad

Ad unit3 120x240

Sponsors Ad

Your Title Here

Sponsors Ad

books and gifts