- Paperback: 630 pages
- Publisher: O'Reilly Media; 1 edition (April 22, 2012)
- Language: English
- ISBN-10: 1449394701
- ISBN-13: 978-1449394707
- Product Dimensions: 7 x 1.3 x 9.2 inches
- Shipping Weight: 2 pounds (View shipping rates and policies)
- Average Customer Review: 46 customer reviews
- Amazon Best Sellers Rank: #194,183 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Clojure Programming: Practical Lisp for the Java World 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
The Amazon Book Review
Author interviews, book reviews, editors picks, and more. Read it now
Frequently bought together
Customers who bought this item also bought
From the Publisher
|Living Clojure||Clojure Programming||Clojure Cookbook||Learning Clojure - DVD||Learning Clojure - PC||Learning Clojure - Mac|
|Further Clojure Resources||An Introduction and Training Plan for Developers||Practical Lisp for the Java World||Recipes for Functional Programming||Visual Training DVD||Visual Training (Online Code PC/Windows)||Visual Training (Online Code for Mac/OS X)|
About the Author
Chas Emerick is the founder of Snowtide Informatics, a small software company in Western Massachusetts. Since 2008, he has helped to develop the core Clojure language and many Clojure open source projects. Chas writes about Clojure, software development practices, entrepreneurship, and other passions at cemerick.com.
Brian Carper is a professional programmer in the field of psychological research. He uses Clojure for data analysis and web development. He's the author of a Clojure-to-CSS compiler and relational database library, and writes about Clojure and other topics at http://briancarper.net.
Christophe Grand is an independent consultant, based near Lyon, France. He tutors, trains and codes primarily in Clojure. A participant in developing the core Clojure language, he also authored the Enlive and Moustache libaries and is a contributor to Counterclockwise, the Clojure IDE for Eclipse. Christophe writes on Clojure at clj-me.cgrand.net.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
When the book describes a language construct, it seems like the author tries to present all the features *at once* - no matter it is a basic feature or an advanced feature. Furthermore, the examples in the book contain too many "future references", which point to later chapters. For example, material presented in Chapter 2 contains tons of references to Chapter 3, Chapter 4, Chapter 5, etc. The code examples unnecessarily use language constructs and functions which are not yet mentioned. This forces the readers to give up completely understanding the code examples at the moment, and go back after they read a later chapter.
In my opinion, if the book is arranged in a "spiral", "incremental" sense, I will give it a 5-star rating.
* The prose was clear; there isn't a point at which I was confused by which of two things the authors meant
* The book's structure facilitated a lot of picking-and-choosing, with a lot of reference between sections to let you attack the problem as you liked;
* Edge-cases and gotchas were clearly highlighted in Warning sections; which takes a lot of the sting out of getting used to a new language, with its own idioms and idiosyncrasies;
* The mix of theoretical explanation and practical application (including mentioning and demonstrating the use of common tools) was fantastic.
After picking it up on a friday, I couldn't put it down until the following Sunday night - I'd thoroughly recommend this to anyone looking for an easy way to get into Clojure. I honestly can't think of a bad word to say about it.
* I loved that Clojure Programming drives home the advantages of Clojure's approach to functional programming, not just in a dedicated chapter, but through the span of all its chapters.
* It successfully draws a bridge between your current language (Java, Ruby or Python) and how Clojure can complement or replace it.
* The order in which everything is presented works very well, too.
* It equips you very solidly to make your future decisions between different features. For example, when should you use gen-class, reify, proxy, defprotocol, defrecord and deftype?
* Although Clojure Programming's writing style isn't on par with Programming Clojure, I believe the former may be more useful overall to the practitioner, while the latter would be a great introductory textbook.
I've been doing some work with Clojure and started reading your book
on Safari and have found it to be an excellent guide as I dig more deeply into
the language. So much so, in fact, that I ordered a paper copy so I can read it
away from the computer as well. It is very well written. I found the language
and tone to be very lucid and mature. It is refreshing to find a contemporary
book that expects a level of competence from the reader and doesn't pander
in an effort to be "approachable". I also appreciate your focus on the language
and its features and not on "How to build X with clojure".
The section on Tools, Platforms, and Projects is, alone, worth the price of the book.
This is probably the most difficult part of learning Clojure and this book provides a comprehensive
set of guidelines to smooth the process.
Anyway, this book answered all of my questions and so many more. It covers each topic in an in-depth, but concise manner. It has 600 pages of content and covers such a breadth of topics that it will be of use to Clojure programmers of all levels: as an introductory text as well as an in depth reference guide of when and how to use the different features of Clojure.
This is the one that's really made it stick. Not only is it well suited to sitting down and working through it linearly, it makes a great "I'll read a few pages then go back to hacking" companion which is how I used it after working through the first half of the book.
Not only that, the book is so well constructed and clear that I'll be using the section on promises and futures to teach a non-Clojure programmer how they work in the abstract.
Just fantastic, if you want to learn Clojure , or only know the basics and bone up a bit, this is the book of choice as of December 2012.