Programming Clojure (Pragmatic
Programmers) by Stuart Halloway
Makes The Big Ideas Easy To Grasp.
Clojure is a dynamic language for the Java Virtual Machine, with a
compelling combination of features: Clojure is elegant. Clojures clean,
careful design lets you write programs that get right to the essence of a
problem, without a lot of clutter and ceremony. Clojure is Lisp reloaded.
Clojure has the power inherent in Lisp, but is not constrained by the history
of Lisp. Clojure is a functional language. Data structures are immutable,
and functions tend to be side-effect free. This makes it easier to write
correct programs, and to compose large programs from smaller ones.
Clojure is concurrent. Rather than error-prone locking, Clojure provides
software transactional memory. Clojure embraces Java. Calling from
Clojure to Java is direct, and goes through no translation layer. Clojure is
fast. Wherever you need it, you can get the exact same performance that
you could get from hand-written Java code. Many other languages offer
some of these features, but the combination of them all makes Clojure
sparkle. Programming Clojure shows you why these features are so

important, and how you can use Clojure to build powerful programs
quickly.
Personal Review: Programming Clojure (Pragmatic
Programmers) by Stuart Halloway
This is an excellent book. It's a fast read. It presents a fairly large amount
of practical clojure programming information to the reader in a manner
that's easy to learn and digest.
I've just finished reading it, though I can't say "got it all, thanks." Becoming
a fluent lisp coder takes more than reading a book: it's going to take
building fluency with the language by writing programs with it. With this
book, Stu gets you going.
I know Stu: he has an uncanny ability to learn new stuff from raw materials
quickly. I'm not surprised therefore that he's the first "out of the gate" with
a book on Clojure (I on the other hand waited for his book to come out).
Stu also has a way of explaining away difficult concepts and using the right
metaphors and examples to help you see how it's all really quite simple.
It's worthwhile to any reader to read what Stu has to say if only to see
things from his perspective.
Given the fact that this book was published in record time, I'm rather
amazed at its quality and its flow. Also I believe that the lancet code
example is brilliant: few other books build, in so few lines of code,
something so compelling and useful.
This book makes sense to you if you:
[a] are or were a java developer in a past life
[b] have some familiarity with, and basic understanding of lisp/scheme
It helps knowing some of the concepts in advance so you can focus on
understanding just Clojure and the concepts it brings to the table.
I heartily recommend reading the SICP as a prerequisite. For example, it
makes more sense to understand macros if you can think about how the
repl works and has to deal with special forms. I can understand macros as
plugins to the repl engine. This book dives into macros without really
explaining to the lisp novice what special forms really are (or forms for that
matter). I'm no lisp maven and I bought this book to help kickstart myself
into understanding and programming Clojure. This book is a good choice
for the task. In fact at the moment I believe it's the only choice in print. It
helps tremendously if you've previously seen/understood basic lisp
commands such as (do) and (let) before (one less thing to try to
understand as you go through the book).
The book doesn't give all the answers and is not perfect; i.e. there's room
for further editions. I would personally welcome a reference section of the
most common commands and idioms, and perhaps a list of recipes for

performing various common tasks. There is also room for deeper
explanations of topics, specifically for Java developers not so familiar with
lisp (e.g. macros, comprehensions). At least the book should refer the
reader to sources for deeper information on specific topics.
For the developer who comes from the c language family tree, I'd welcome
a brief discussion on "where did my curly braces go?" or "how to make
sense of code without curly braces."
For More 5 Star Customer Reviews and Lowest Price:
Programming Clojure (Pragmatic Programmers) by Stuart Halloway 5 Star Customer
Reviews and Lowest Price!