Curated Collections of Excellent Products for Subreddits


Books to make you a better Clojurist. Includes titles on Functional Programming and Lisp.

  • clojure
  • lisp
  • FP
  • logic
  • advanced
Clojure Programming
Chas Emerick, Brian Carper, Christophe Grand
Lowest Price: $25.62

This is the best book for learning Clojure itself. It explains Clojure's philosophy and effectively shows how to use it. It's also a decent introduction to functional programming.

Clojure is a practical, general-purpose language that offers expressivity rivaling other dynamic languages like Ruby and Python, while seamlessly taking advantage of Java libraries, services, and all of the resources of the JVM ecosystem. This book helps you learn the fundamentals of Clojure with examples relating it to the languages you know already, in the domains and topics you work with every day. See how this JVM language can help eliminate unnecessary complexity from your programming practice and open up new options for solving the most challenging problems.

Clojure Programming demonstrates the language's flexibility by showing how it can be used for common tasks like web programming and working with databases, up through more demanding applications that require safe, effective concurrency and parallelism, data analysis, and more. This in-depth look helps tie together the full Clojure development experience, from how to organize your project and an introduction to Clojure build tooling, to a tutorial on how to make the most of Clojure's REPL during development, and how to deploy your finished application in a cloud environment.

  • Learn how to use Clojure while leveraging your investment in the Java platform
  • Understand the advantages of Clojure as an efficient Lisp for the JVM
  • See how Clojure is used today in several practical domains
  • Discover how Clojure eliminates the need for many verbose and complicated design patterns
  • Deploy large or small web applications to the cloud with Clojure
Programming Clojure
Stuart Halloway, Aaron Bedra
Lowest Price: $26.23

Though perhaps not as useful as Clojure Programming, this is still a solid book.

If you want to keep up with the significant changes in this important language, you need the second edition of Programming Clojure. Stu and Aaron describe the modifications to the numerics system in Clojure 1.3, explain new Clojure concepts such as Protocols and Datatypes, and teach you how to think in Clojure.

Programming Clojure, 2nd Edition is a significant update to the classic book on the Clojure language. You'll get thorough coverage of all the new features of Clojure 1.3, and enjoy reorganized and rewritten chapters that reflect the significance of new Clojure concepts. Many code examples have been rewritten or replaced, and every page has been reevaluated in the light of Clojure 1.3.

As Aaron and Stu show you how to build an application from scratch, you'll get a rich view into a complete Clojure workflow. And you'll get an invaluable education in thinking in Clojure as you work out solutions to the various parts of a problem.

Clojure is becoming the language of choice for many who are moving to functional programming or dealing with the challenges of concurrency. Clojure offers:

  • The simplicity of an elegantly designed language
  • The power of Lisp
  • The virtues of concurrency and functional style
  • The reach of the JVM
  • The speed of hand-written Java code

It's the combination of these features that makes Clojure sparkle._ Programming Clojure, 2nd Edition shows you how to think in Clojure, and to take advantage of these combined strengths to build powerful programs quickly.

What You Need:

  • Oracle JDK 6
  • A text editor
On Lisp: Advanced Techniques for Common Lisp
Paul Graham
Lowest Price: free online

THE book on Lisp macros. Get it free online. It uses Common Lisp, so keep _Practical Common Lisp_ and the Common Lisp HyperSpec handy.

Written by a LISP expert, this is the most comprehensive tutorial available on the advanced LISP features and programming techniques. It shows how to program in the bottom-up style that is ideal for LISP programming, and includes a unique, practical collection of LISP programming techniques that shows how to take advantage of the languages design for highly efficient programming in a wide variety of (non-artificial intelligence) applications.

  • uses an innovative bottom-up approach to programming in LISP - an approach that is ideally suited to LISP and especially effective in dealing with unusually large or difficult programs.
  • offers a complete tutorial on valuable LISP macros and LISP macro programming techniques, including practical advice on when - and when not - to use macros.
  • shows how to put Lisp macros to work in a variety of real applications.explains what makes LISP different from other languages - how to do in LISP what cant be done - or done easily - in other languages.
  • begins with two comprehensive chapters on functions and shows how to use functions to extend LISP.
  • covers embedded languages, showing how to use LISP for a database application and how to build a programming environment on top of LISP.
  • covers object-oriented programming and advanced data structures.
  • contains hundreds of working examples - ranging from single expressions to a working Prolog implementation.
Land of Lisp: Learn to Program in Lisp, One Game at a Time!
Conrad Barski
Lowest Price: $26.90

Learn Lisp by creating games! A super-fun intro to Common Lisp. Even though it targets Common Lisp and not Clojure, you'll learn valuable concepts common to all Lisps. It's hard to put this book down, an important quality when you're bending your brain around a new paradigm.

When you're done with LOL, grab Clojure Programming to learn Clojure's specific flavor of Lisp. The transition is very easy.

Official product description:

Lisp has been hailed as the world's most powerful programming language, but its cryptic syntax and academic reputation can be enough to scare off even experienced programmers. Those dark days are finally over? Land of Lisp brings the power of functional programming to the people!

With his brilliantly quirky comics and out-of-this-world games, longtime Lisper Conrad Barski teaches you the mysteries of Common Lisp. You'll start with the basics, like list manipulation, I/O, and recursion, then move on to more complex topics like macros, higher order programming, and domain-specific languages. Then, when your brain overheats, you can kick back with an action-packed comic book interlude!

Along the way you'll create (and play) games like Wizard Adventure, a text adventure with a whiskey-soaked twist, and Grand Theft Wumpus, the most violent version of Hunt the Wumpus the world has ever seen.

You'll learn to:

  • Master the quirks of Lisp's syntax and semantics
  • Write concise and elegant functional programs
  • Use macros, create domain-specific languages, and learn other advanced Lisp techniques
  • Create your own web server, and use it to play browser-based games
  • Put your Lisp skills to the test by writing brain-melting games like Dice of Doom and Orc Battle

With Land of Lisp, the power of functional programming is yours to wield.
An Introduction to Functional Programming Through Lambda Calculus
Greg Michaelson
Lowest Price: $13.41

This accessible book covers the Lambda Calculus independently of any programming languages, and then shows how the concepts relate to Lisp.

This well-respected text offers an accessible introduction to functional programming concepts and techniques for students of mathematics and computer science. The treatment is as nontechnical as possible, assuming no prior knowledge of mathematics or functional programming. Numerous exercises appear throughout the text, and all problems feature complete solutions.

Let Over Lambda
Doug Hoyte
Lowest Price: $35.75

This book is about pushing the boundaries of what we know about programming. While this book teaches useful skills that can help solve your programming problems today and now, it has also been designed to be entertaining and inspiring. If you have ever wondered what lisp or even programming itself is really about, this is the book you have been looking for.

Let Over Lambda is one of the most hardcore computer programming books out there. Starting with the fundamentals, it describes the most advanced features of the most advanced language: Common Lisp. Clojurists should be able to adjust - just make sure you have the Common Lisp Hyperspec handy, or perhaps Practical Common Lisp.

Only the top percentile of programmers use lisp and if you can understand this book you are in the top percentile of lisp programmers. If you are looking for a dry coding manual that re-hashes common-sense techniques in whatever langue du jour, this book is not for you.

To Mock a Mockingbird
Lowest Price: $10.85

An entertaining collection of logic puzzles which, incidentally, explores fundamental functional programming concepts.

In this entertaining and challenging collection of logic puzzles, Raymond Smullyan - author of Forever Undecided - continues to delight and astonish us with his gift for making available, in the thoroughly pleasurable form of puzzles, some of the most important mathematical thinking of our time.

In the first part of the book, he transports us once again to that wonderful realm where knights, knaves, twin sisters, quadruplet brothers, gods, demons, and mortals either always tell the truth or always lie, and where truth-seekers are set a variety of fascinating problems. The section culminates in an enchanting and profound metapuzzle in which Inspector Craig of Scotland Yard gets involved in a search for the Fountain of Youth on the Island of Knights and Knaves.

In the second part of To Mock a Mockingbird, we accompany the Inspector on a summer-long adventure into the field of combinatory logic (a branch of logic that plays an important role in computer science and artificial intelligence). His adventure, which includes enchanted forests, talking birds, bird sociologists, and a classic quest, provides for us along the way the pleasure of solving puzzles of increasing complexity until we reach the Master Forest and - thanks to Godel's famous theorem - the final revelation.

Learn You a Haskell for Great Good!: A Beginner's Guide
Miran Lipovaca
Lowest Price: free online

Why should a Clojurist read a Haskell book? Besides being enormously entertaining, Learn You a Haskell goes over vital functional programming concepts. Additionally, Haskell is used in other seminal functional programming books which Clojurists should read. Plus! It's free online.

It's all in the name: Learn You a Haskell for Great Good! is a hilarious, illustrated guide to this complex functional language. Packed with the author's original artwork, pop culture references, and most importantly, useful example code, this book teaches functional fundamentals in a way you never thought possible.

You'll start with the kid stuff: basic syntax, recursion, types and type classes. Then once you've got the basics down, the real black belt master-class begins: you'll learn to use applicative functors, monads, zippers, and all the other mythical Haskell constructs you've only read about in storybooks.

As you work your way through the author's imaginative (and occasionally insane) examples, you'll learn to:

  • Laugh in the face of side effects as you wield purely functional programming techniques
  • Use the magic of Haskell's "laziness" to play with infinite sets of data
  • Organize your programs by creating your own types, type classes, and modules
  • Use Haskell's elegant input/output system to share the genius of your programs with the outside world

Short of eating the author's brain, you will not find a better way to learn this powerful language than reading Learn You a Haskell for Great Good!

Excerpt from the Introduction Haskell is fun, and that?s what it?s all about!

This book is aimed at people who have experience programming in imperative languages -- such as C++, Java, and Python -- and now want to try out Haskell. But even if you don't have any significant programming experience, I'll bet a smart person like you will be able to follow along and learn Haskell.

My first reaction to Haskell was that the language was just too weird. But after getting over that initial hurdle, it was smooth sailing. Even if Haskell seems strange to you at first, don?t give up. Learning Haskell is almost like learning to program for the first time all over again. It's fun, and it forces you to think differently.


If you ever get really stuck, the IRC channel #haskell on the freenode network is a great place to ask questions. The people there tend to be nice, patient, and understanding. They're a great resource for Haskell newbies.

So, What's Haskell?


Haskell is a purely functional programming language.

In imperative programming languages, you give the computer a sequence of tasks, which it then executes. While executing them, the computer can change state. For instance, you can set the variable a to 5 and then do some stuff that might change the value of a. There are also flow-control structures for executing instructions several times, such as for and while loops.

Purely functional programming is different. You don't tell the computer what to do -- you tell it what stuff is. For instance, you can tell the computer that the factorial of a number is the product of every integer from 1 to that number or that the sum of a list of numbers is the first number plus the sum of the remaining numbers. You can express both of these operations as functions.

Pearls of Functional Algorithm Design
Richard Bird
Lowest Price: $47.52

Richard Bird takes a radically new approach to algorithm design, namely, design by calculation. These 30 short chapters each deal with a particular programming problem drawn from sources as diverse as games and puzzles, intriguing combinatorial tasks, and more familiar areas such as data compression and string matching. Each pearl starts with the statement of the problem expressed using the functional programming language Haskell, a powerful yet succinct language for capturing algorithmic ideas clearly and simply. The novel aspect of the book is that each solution is calculated from an initial formulation of the problem in Haskell by appealing to the laws of functional programming. Pearls of Functional Algorithm Design will appeal to the aspiring functional programmer, students and teachers interested in the principles of algorithm design, and anyone seeking to master the techniques of reasoning about programs in an equational style.

Note that code is written in Haskell. I recommend Learn You a Haskell for Great Good!.

Purely Functional Data Structures
Chris Okasaki
Lowest Price: $39.55

This book inspired the immutable data structures in Clojure.

Most books on data structures assume an imperative language such as C or C++. However, data structures for these languages do not always translate well to functional languages such as Standard ML, Haskell, or Scheme. This book describes data structures from the point of view of functional languages, with examples, and presents design techniques that allow programmers to develop their own functional data structures. The author includes both classical data structures, such as red-black trees and binomial queues, and a host of new data structures developed exclusively for functional languages. All source code is given in Standard ML and Haskell, and most of the programs are easily adaptable to other functional languages. This handy reference for professional programmers working with functional languages can also be used as a tutorial or for self-study.

Learn Prolog Now!
Patrick Blackburn, Johan Bos, Kristina Striegnitz
Lowest Price: $18.10

A useful book for those interested in core.logic.

Prolog is a programming language, but a rather unusual one. "Prolog" is short for "Programming with Logic", and the link with logic gives Prolog its special character. At the heart of Prolog lies a surprising idea: don't tell the computer what to do. Instead, describe situations of interest, and compute by asking questions. Prolog will logically deduce new facts about the situations and give its deductions back to us as answers.

Why learn Prolog? For a start, its "say what the problem is, rather than how to solve it" stance, means that it is a very high level language, good for knowledge rich applications such as artificial intelligence, natural language processing, and the semantic web. So by studying Prolog, you gain insight into how sophisticated tasks can be handled computationally. Moreover, Prolog requires a different mindset. You have to learn to see problems from a new perspective, declaratively rather than procedurally. Acquiring this mindset, and learning to appreciate the links between logic and programming, makes the study of Prolog both challenging and rewarding. Learn Prolog Now! is a practical introduction to this fascinating language. Freely available as a web-book since 2002 (see Learn Prolog Now! has became one of the most popular introductions to the Prolog programming language, an introduction prized for its clarity and down-to-earth approach. It is widely used as a textbook at university departments around the world, and even more widely used for self study. College Publications is proud to present here the first hard-copy version of this online classic. Carefully revised in the light of reader's feedback, and now with answers to all the exercises, here you will find the essential material required to help you learn Prolog now.

The Reasoned Schemer
Daniel P. Friedman, William E. Byrd, Oleg Kiselyov
Lowest Price: $19.98

Another important tome for core.logic users. core.logic is based on minikanren, and the minikanren's creators authored this book.

The goal of The Reasoned Schemer is to help the functional programmer think logically and the logic programmer think functionally. The authors of The Reasoned Schemer believe that logic programming is a natural extension of functional programming, and they demonstrate this by extending the functional language Scheme with logical constructs -- thereby combining the benefits of both styles. The extension encapsulates most of the ideas in the logic programming language Prolog.The pedagogical method of The Reasoned Schemer is a series of questions and answers, which proceed with the characteristic humor that marked The Little Schemer and The Seasoned Schmer. Familiarity with a functional language or with the first eight chapters of The Little Schemer is assumed. Adding logic capabilities required the introduction of new forms. The authors' goal is to show to what extent writing logic programs is the same as writing functional programs using these forms. In this way, the reader of The Reasoned Schemer will come to understand how simple logic programming is and how easy it is to define functions that behave like relations.

Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp
Peter Norvig
Lowest Price: $71.98

A seminal Lisp text. It uses Common Lisp, so if you're not familiar with that check out Practical Common Lisp:

Paradigms of AI Programming is the first text to teach advanced Common Lisp techniques in the context of building major AI systems. By reconstructing authentic, complex AI programs using state-of-the-art Common Lisp, the book teaches students and professionals how to build and debug robust practical programs, while demonstrating superior programming style and important AI concepts. The author strongly emphasizes the practical performance issues involved in writing real working programs of significant size. Chapters on troubleshooting and efficiency are included, along with a discussion of the fundamentals of object-oriented programming and a description of the main CLOS functions. This volume is an excellent text for a course on AI programming, a useful supplement for general AI courses and an indispensable reference for the professional programmer.

Structure and Interpretation of Computer Programs
Harold Abelson, Gerald Jay Sussman
Lowest Price: $46.08

Another seminal Lisp text, this book will expand your mind as a programmer.

Structure and Interpretation of Computer Programs has had a dramatic impact on computer science curricula over the past decade. This long-awaited revision contains changes throughout the text. There are new implementations of most of the major programming systems in the book, including the interpreters and compilers, and the authors have incorporated many small changes that reflect their experience teaching the course at MIT since the first edition was published.

A new theme has been introduced that emphasizes the central role played by different approaches to dealing with time in computational models: objects with state, concurrent programming, functional programming and lazy evaluation, and nondeterministic programming. There are new example sections on higher-order procedures in graphics and on applications of stream processing in numerical programming, and many new exercises. In addition, all the programs have been reworked to run in any Scheme implementation that adheres to the IEEE standard.

Learn You Some Erlang for Great Good!: A Beginner's Guide
Fred Hebert
Lowest Price: free online

Erlang takes a very different approach to programming which Clojurists will find valuable. While some have complained about Erlang's idiosyncrasies, it embodies useful concepts that you can employ in Clojure. This (very goofy) text is available free online.

Erlang is the language of choice for programmers who want to write robust, concurrent applications, but its strange syntax and functional design can intimidate the uninitiated. Luckily, there's a new weapon in the battle against Erlang-phobia: Learn You Some Erlang for Great Good!

Erlang maestro Fred Hebert starts slow and eases you into the basics: You'll learn about Erlang's unorthodox syntax, its data structures, its type system (or lack thereof!), and basic functional programming techniques. Once you've wrapped your head around the simple stuff, you'll tackle the real meat-and-potatoes of the language: concurrency, distributed computing, hot code loading, and all the other dark magic that makes Erlang such a hot topic among today's savvy developers.

As you dive into Erlang's functional fantasy world, you'll learn about:

  • Testing your applications with EUnit and Common Test
  • Building and releasing your applications with the OTP framework
  • Passing messages, raising errors, and starting/stopping processes over many nodes
  • Storing and retrieving data using Mnesia and ETS
  • Network programming with TCP, UDP, and the inet module
  • The simple joys and potential pitfalls of writing distributed, concurrent applications

Packed with lighthearted illustrations and just the right mix of offbeat and practical example programs, Learn You Some Erlang for Great Good! is the perfect entry point into the sometimes-crazy, always-thrilling world of Erlang.
Java Concurrency in Practice
Brian Goetz, Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes, Doug Lea
Lowest Price: $25.00

Oft-cited for its Clojure relevance, this book covers core concurrency concepts.

"I was fortunate indeed to have worked with a fantastic team on the design and implementation of the concurrency features added to the Java platform in Java 5.0 and Java 6. Now this same team provides the best explanation yet of these new features, and of concurrency in general. Concurrency is no longer a subject for advanced users only. Every Java developer should read this book." --Martin Buchholz JDK Concurrency Czar, Sun Microsystems

"For the past 30 years, computer performance has been driven by Moore's Law; from now on, it will be driven by Amdahl's Law. Writing code that effectively exploits multiple processors can be very challenging. Java Concurrency in Practice provides you with the concepts and techniques needed to write safe and scalable Java programs for today's--and tomorrow's--systems." --Doron Rajwan Research Scientist, Intel Corp

"This is the book you need if you're writing--or designing, or debugging, or maintaining, or contemplating--multithreaded Java programs. If you've ever had to synchronize a method and you weren't sure why, you owe it to yourself and your users to read this book, cover to cover." --Ted Neward Author of Effective Enterprise Java

"Brian addresses the fundamental issues and complexities of concurrency with uncommon clarity. This book is a must-read for anyone who uses threads and cares about performance." --Kirk Pepperdine CTO,

"This book covers a very deep and subtle topic in a very clear and concise way, making it the perfect Java Concurrency reference manual. Each page is filled with the problems (and solutions!) that programmers struggle with every day. Effectively exploiting concurrency is becoming more and more important now that Moore's Law is delivering more cores but not faster cores, and this book will show you how to do it." --Dr. Cliff Click Senior Software Engineer, Azul Systems

"I have a strong interest in concurrency, and have probably written more thread deadlocks and made more synchronization mistakes than most programmers. Brian's book is the most readable on the topic of threading and concurrency in Java, and deals with this difficult subject with a wonderful hands-on approach. This is a book I am recommending to all my readers of The Java Specialists' Newsletter, because it is interesting, useful, and relevant to the problems facing Java developers today." --Dr. Heinz Kabutz The Java Specialists' Newsletter

"I've focused a career on simplifying simple problems, but this book ambitiously and effectively works to simplify a complex but critical subject: concurrency. Java Concurrency in Practice is revolutionary in its approach, smooth and easy in style, and timely in its delivery--it's destined to be a very important book." --Bruce Tate Author of Beyond Java

" Java Concurrency in Practice is an invaluable compilation of threading know-how for Java developers. I found reading this book intellectually exciting, in part because it is an excellent introduction to Java's concurrency API, but mostly because it captures in a thorough and accessible way expert knowledge on threading not easily found elsewhere." --Bill Venners Author of Inside the Java Virtual Machine

Threads are a fundamental part of the Java platform. As multicore processors become the norm, using concurrency effectively becomes essential for building high-performance applications. Java SE 5 and 6 are a huge step forward for the development of concurrent applications, with improvements to the Java Virtual Machine to support high-performance, highly scalable concurrent classes and a rich set of new concurrency building blocks. In Java Concurrency in Practice , the creators of these new facilities explain not only how they work and how to use them, but also the motivation and design patterns behind them.

However, developing, testing, and debugging multithreaded programs can still be very difficult; it is all too easy to create concurrent programs that appear to work, but fail when it matters most: in production, under heavy load. Java Concurrency in Practice arms readers with both the theoretical underpinnings and concrete techniques for building reliable, scalable, maintainable concurrent applications. Rather than simply offering an inventory of concurrency APIs and mechanisms, it provides design rules, patterns, and mental models that make it easier to build concurrent programs that are both correct and performant.

This book covers:

  • Basic concepts of concurrency and thread safety
  • Techniques for building and composing thread-safe classes
  • Using the concurrency building blocks in java.util.concurrent
  • Performance optimization dos and don'ts
  • Testing concurrent programs
  • Advanced topics such as atomic variables, nonblocking algorithms, and the Java Memory Model
John Carter: Barsoom Series (7 Novels)
Edgar Rice Burroughs
Lowest Price: $0.99

When John Carter goes to sleep in a mysterious cave in the Arizona dessert, he wakes up on the planet Mars. There he meets the fifteen foot tall, four armed, green men of mars, with horse-like dragons, and watch dogs like oversized frogs with ten legs. His adventures continue as he battles great white apes, fights plant men, defies the Goddess of Death, and braves the frozen wastes of Polar Mars. In other adventures, the Prince of Helium encounters a race of telepathic warriors, the Princess of Helium confronts the headless men of Mars, Captain Ulysses Paxton learns the secret of human immortality, and Tan Hadron's idealized notion of love is tested as he fights off gigantic spiders and cannibals.

Edgar Rice Burroughs vision of Mars was loosely inspired by astronomical speculation of the time, especially that of Percival Lowell, who saw the red planet as a formerly Earth-like world now becoming less hospitable to life due to its advanced age. Burroughs predicted the invention of homing devices, radar, sonar, autopilot, collision detection, television, teletype, genetic cloning, living organ transplants, antigravity propulsion, and many other concepts that were well ahead of his time.