- 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: #550,543 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.
Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and Amazon Prime.
If you're a seller, Fulfillment by Amazon can help you increase your sales. We invite you to learn more about Fulfillment by Amazon .
"Rebound" by Kwame Alexander
Don't miss best-selling author Kwame Alexander's "Rebound," a new companion novel to his Newbery Award-winner, "The Crossover,"" illustrated with striking graphic novel panels. Pre-order today
Frequently bought together
Customers who bought this item also bought
Customers who viewed this item also viewed
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.
Author interviews, book reviews, editors picks, and more. Read it now
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
The introductory chapters seem to hurry things long so they can get to the "good stuff." Unfortunately, that will leave people who are new to the language behind. So, think of this as a good second book. Perhaps "Programming Clojure, 2nd Edition" by Halloway and Bedra should be a begginer's first book, followed by this one to take the knowledge deeper. This means that if by chapter 4 you're not really "up to speed" on clojure, the rest of the book will not make much sense to you.
Another word of advice to people new to functional programming in general. A language is just the embodiment of programming concepts. If you are coming from a OO background and you are used to the imperative family of languages ie C, C++, Java, C#, etc, then do not assume because you have mastered them that FP will flow easily. There are several concepts in FP that don't map -- they are concepts you have not yet seen. If you do not learn the concepts, the syntax in the language supporting those things won't make sense. When you read people saying "think in clojure" they are meaning to think more in terms of FP and how you'd solve problems in that sense, as opposed to say an OO sense. The problem with most books on functional languages is that they don't spend enough effort teaching the concepts but rather do a quick treatment of the concept and go right to syntax. This approach makes it a bit harder for people to grasp FP.
This book tries to come back to thinking in FP -- but way too far into it for beginners. This should have been done more up front, rather than deep in the book. But, if you're not a beginner, then I definitely recommend this book.
Whether it is a book you can read (or practice the examples contained therein) and then go write your first purposed Clojure programs? not sure yet. I am not sure it was meant to be, but in any event it is probably not. Not enabling writing real-purposed code probably relates to the organization, which is story-like and evolving rather than making sure it could also be used to later find what you need to recollect in more of a reference style. Acknowledging many programming books are like that, this is not particular to this book. And so my 3 star rating relates to not fulfilling this expectation of going from background-only to coding-ability along with reading the book, which probably means much about me not only about the book. Otherwise it would be 4.
Apart from the above, I have several specific comments that may possibly be useful to consider for some future edition. Chapter 6 dealing with datatypes and protocols is not as clear in my mind as I could wish for. It leaves me wondering how is it all related to the long discussions of functional beauty that precede, and a bit unclear as to when should they be used, likewise the discussion about multi-methods in chapter 7. It seems the book should be more careful in connecting these topics to the long discussions about pure functional programming and data immutability spread throughout the book. Discussions of mutating data should deal with the overall aspect of encouraging immutability in a more balanced way, rather than 'slipping them through' as if you won't notice they break that paradigm. The last chapters should optimally be not a book chapter but an online site.
Clojure showtime-readiness seems to be over glorified in the book. I found the power of the REPL a bit over-glorified. The sections about using the REPL in production and hot-swapping code in production seem to be representing a bit of a naive approach, which perhaps should have been curbed or better delineated. Likewise some of the mentioned IDE setups don't work that well or are just laborious or barely documented in detail on the Internet. Comments about performance penalties and mentioning of 'performance hinting' are spread around raising some doubts about scaling the code. Clojure compilation errors are very ugly, blending Java and somewhat vague Clojure error descriptions. Working with Clojure is much more brittle than the book tries to imply, waiting for the light-table project to improve that... so this book may portray the correct picture that will exist a year from now when these 'language readiness aspects' are more carefully dealt with in the community, but bestows excessive credit to ease-of-use at present. These problems relate to the Clojure ecosystem but the book could have been more realistic in acknowledging them. It could have said that Clojure is a cutting-edge ecosystem and you can get cut when dealing with the cutting edge until you get it tamed.
I disclaim that I am not a battle-proven Java, Ruby or Python developer, and so my review should be taken in this context and may not apply to those who are.
Indeed perhaps I am not the audience for this book. Whether you can *learn* a new language from a book is questionable. This book is a very good exposition. The many code snippet examples require using your head not just reading abstract texts, so be ready to exercise your neurons while reading this book. It will give you a good basis in exchange for many hours of reading, but will leave you looking for practical ways to learn the language into your fingers.
You have to appreciate that Clojure information on the Internet is scant and possibly at times misleading.
Without this exposition, maybe you would not even be able to start off. I would say this book is an exposition to practicing in 4clojure.com and to learning in a more deliberate way. Frankly, as such it may serve its purpose very well!
The book is huge and covers a lot of ground. Beyond teaching the language, this book explains how to work with Clojure on a daily basis and it was very valuable to me.
I have a sound background of OO programming in Java and this book suits perfectly well my profile. The examples are well chosen and pleasant.
The book is very well written and very understandable for a French native speaker like I am.
This book really helped me rewire my brain to embrace LISP and FP philosophy.
I have read carefully Part I to III and beside the fact that I already knew the language,
I found new insights and a ton of good new tips.
On some points specific points, the explanations and examples are clear, I finally understood the difference between the laziness of rest and next ;-)
The section "Putting Clojure's Collections to Work" is a real gem if studied carefully ! By carefully I mean : implement your own solution and then analyse the beauty of theirs. You will be enlightened, I promise...
For me It changed the way I solve problems and use Clojure's expressiveness to implement solutions with the minimum of accidental complexity.
I didn't read Part IV in extenso because this is more à la carte. This part covers practical aspects of the real world. You will find there all the important point to start a real project.
I greatly recommend this book to anyone who wants to learn Clojure or really want to grasp the language and his very high potential.