Sign up for weekly Clojure tips, software design, and a Clojure coding challenge.

The 100 Most Used Clojure Expressions

Would you like to optimize your learning of Clojure? Would you like to focus on learning only the most useful parts of the language first? Take this lesson from second language learning: learn the expressions in order of frequency of use.

13 hours of Lisp

My personal notes from the Lisp50 event at OOPSLA 2008.

3 Things Java Programmers Can Steal from Clojure

Many of the cool parts of Clojure are written in Java. That means you can access those parts from any Java code. Just include the Clojure JAR, import the classes, and you've got better tools.

A Model of Interceptors

A reduce Example Explained

A deep-dive into a single reduce example shows how much can happen in a short bit of code.

Ambrose Bonnaire-Sergeant Interview about Typed Clojure

Some Annotated clojure.core/reduce Examples

reduce is a very useful function. You can use it for many calculations over a collection. Code annotations are useful, as are physical metaphors.

Annotated map

map is one of the staples of functional programming. It's totally useful and also surprisingly simple. Let's look at some examples and annotated code.

Announcing: LispCast Intro to clojure.test

The next course will be about clojure.test. Sign up to be notified when it is published.

apple == orange

The arguments against web frameworks

We explore three arguments against frameworks, address them, then turn them into challenges to be overcome.

The Surprising Benefits of Automation

The benefits of automation are not limited to saving time. We go over many advantages, some pitfalls to avoid, and some principles to follow.

Avoid Naming at All Costs

If naming is one of the two hardest things in programming, it follows that every other possible solution (except those few involving cache invalidation) should be attempted before naming something. As a corollary, bad names are a code smell.

The Bootstrapping Mindset

One of the great things about very robust and powerful abstractions is that they can give you tremendous leverage. The leverage can be so great that you can build something much greater than the sum of its parts. However, I worry that the web is an end to this kind of abstraction. I'd like to explore why that is and what we can do about it.

Building Composable Abstractions Rehearsal 3

My third rehearsal for my upcoming Clojure/conj talk.

Separation, Abstraction, and Cascading in CSS

LESS and Sass (and similar solutions) have saved CSS for three reasons: separation, abstraction, and cascading. While I welcome them, CSS still has other problems which I believe can be solved.

Church vs Curry Types

Static vs dynamic typing debates often flounder because the debators see from two different perspectives without knowing it. Learning to identify the two perspectives can calm the discussion. The tension between the two perspectives has led to Gradual Typing and other technologies.

Class AbstractSingletonProxyFactoryBean

clj-refactor cheatsheets

I've made some cheatsheets to help me learn clj-refactor, some Emacs software that helps you make systematic changes to code.


Are there any DOM manipulation libraries in ClojureScript?

ClojureScript has some nice DOM manipulation options, including jQuery and more idiomatic libraries.

Clojure 1.4 Reader Literals Test

What my daughter's blocks teach us about learning

My daughter's blocks taught her to match shapes with a lot of fast feedback. Fast feedback is a powerful tool to learn any skill. I analyze how the blocks helped my daughter learn and compare it to learning Clojure.

Clojure vs. The Static Typing World

Rich Hickey explained the design choices behind Clojure and made many statements about static typing along the way. I share an interesting perspective and some stories from my time as a Haskell programmer. I conclude with a design challenge for the statically typed world.

Two rehearsals for my Clojure/conj talk

My upcoming Clojure/conj talk is fast approaching. I recorded two rehearsals in two days. Watch them!

2 Features of Clojure Editors Professionals Won't Do Without

Professional Clojure programmers rely on certain features of their editors to help them program. When choosing an editor, it's important to pick one that has these two important features: REPL integration and structural editing.

Clojure Error Messages are Accidental

I've recently shifted my thinking about Clojure error messages. It is more useful to think of them as non-existent than to think of them as bad. We end with the role Spec can play in improving error messages.

Clojure for dummies: a kata

Clojure is a better Java than Java

How is it possible that Clojure is better than Java at its own game? Hear me out, then decide for yourself.

Clojure is Imperative

Clojure is an imperative language. Its operations are defined in terms of concrete actions. But those actions are often the same actions available to the programmer at runtime. This makes it easy to bootstrap.

Clojure + Ruby

If you're a Rubyist and you've heard some buzz about Clojure, these videos and links will be just for you. Rubyists teaching Clojure, Clojurists introducing Clojure to Ruby programmers, and Rubyists pontificating on Clojure.

clojure.test cheatsheet

I made a clojure.test cheatsheet that you can get for free.

Recommendations for Next-Level Clojure

There are many classics of functional programming that can help you take your thinking to the next level. My recommendations are for making you think in a new way.

What should a Clojure framework look like?

After exploring why frameworks and why not frameworks, I dive into the design priorities I think a web framework should have.

Clojure Web Security

Use the OWASP Top Ten Project to minimize security vulnerabilities in your Clojure web application.


Clojure's Hosted Legacy

Clojure was designed as a hosted language. So what is Clojure, the language, if it relies on the features of a host? And what are the disadvantages of choosing the JVM as a host?

Clojure's unsung heroics with concurrency

People know about the immutable data structures and the STM. But there's something going on at a much deeper level that is really hard to get right in Java. It has to do with the optimizations the JIT will run on your code.

ClojureScript Anatomy

Will having ClojureScript, yet another asset type, slow down my deploys?

ClojureScript builds can take a long time. But the extra time is worth it. It reduces the download size significantly.

Knowing this one ClojureScript gotcha will save you hours

ClojureScript optimizes names by replacing them with shorter ones. Usually, that's a good thing. But it can get carried away. Externs are how you help it know what's unsafe to optimize.

Javascript to Clojurescript

Should Cognitect do More for Clojure?

Poor open-source development practices, neglect for the beginner experience, and lack of communication have come up as complaints against how Cognitect stewards Clojure. I address the complaints with a plea that we do more as a community.

Complex Syntax

Lisps are revered for their simple syntax, but parens are complex. They complect function calls and macro calls, which have drastically different semantics.

Composable parts

Composition is an important idea in programming, and Functional Programming brings it to the forefront. But what does it mean to say things are composable?

Concurrency and Parallelism in the Real World

Concurrency and parallelism are concepts that we make use of every day off of the computer. I give some real world examples and we analyze them for concurrency and parallelism.

Why does Clojure's conj add to the end of vectors but the beginning of lists?

conj can be confusing if you're used to other languages. It is not a commonly defined operation. Most languages define common positional adding operations. conj, however, has more useful semantics. How do you use conj usefully if you can't guarantee the position?

core.async in Browsers

Javascript's concurrency model forces code to give up control of when a callback will be called. `core.async` gives you back that control and hence lets you code in a more natural style.

Conveyor Belts: Nature's core.async Channels

Conveyor belts are strikingly similar to Clojure core.async channels. While it could be a coincidence, there is speculation that conveyor belts were influenced by a deep understanding of core.async.

CSS has Weak Forms of Abstraction and Combination

According to the requirements proposed by Abelson and Sussman, CSS does not provide adequate means of combination and abstraction to be considered a powerful language.

CSS and the Lambda Calculus

Using LESS, we can almost achieve the expressive power of the Lambda Calculus as applied to styling. The expressive power is enough to create reusable styles applied to reusable HTML components.

Data-First Programming

If something is important, you should deal with it sooner and more often. That's the approach Clojure takes to data representations. It means serialization of internal data is a non-issue.

Data > Functions > Macros. But why?

"Prefer data over functions" is a common adage in Clojure circles. It is poorly debated because it is a terse statement in generalities. A valuable perspective is that data is transparent at runtime, while functions are not. This perspective gives a firm ground for discussion and design.

On the configurations of data and functions

Deconstructing Functional Programming

Deferring Type Errors to Runtime

Douglas Crockford on Javascript

Dynamic Languages Wizards Series - Panel on Language Design

Elm FRP in Clojure core.async

Elm is an exciting FRP language. I implemented the FRP part in Clojure using core.async.

Escape from the Ivory Tower

Exponential Backoff

A common failure in distributed systems is a server with a rate limit or with no limit but begins failing due to load. A standard solution is to retry after waiting a small time, increasing that time after each failure. We create a macro to handle this waiting and retrying.

Extreme Cleverness: Functional Data Structures in Scala

Faith, Evolution, and Programming Languages

4 Features Javascript can steal from Clojure(Script)

ClojureScript adds a lot of value on top of the Javascript platform. But some of that value can be had directly in Javascript without using a new language.

Can I do FP in my language?

We address the question directly, but then look deeper to the beliefs behind the question.

Functional JavaScript

Many of us have to use JavaScript. But does that mean we can't use functional programming? Sure, with discipline. But can we make it even easier?

Functors, Applicatives, And Monads In Pictures

Global Mutable State

Global mutable state is one of the biggest drivers of complexity in software systems. We tackle a definition and how to reduce our reliance on it.

Google Common Lisp Style Guide

Google Python Style Guide

A Short Ballad Dedicated to the Growth of Programs

Hindley-Milner in Clojure

I wrote a lambda-calculus interpreter and an implementation of Hindley-Milner to type check it.

How do Clojure Programmers Deal with Long Startup Times

Clojure startup times suck. Let's just be honest. How do Clojure programmers live with that? Maybe that's the wrong way to think about it.

How The JVM Spec Came To Be

How to answer a question: a simple system

How to Write Clean, Testable Code

How to Write Software

Writing software alone and in a long term sustainable manner requires a lot of discipline. Upfront planning and avoidance of feature creep can turn a stressful project into a pleasure.

I remember the time before monads

The Idea of Lisp

How a programming language can be an idea.

Immutable Paper

Immutable data appear to contradict our observations of the real world. Things in the world are mutable, so shouldn't our data be mutable, too? It may be counterintuitive, but immutable data does a better job of modeling many of our expectations of the real world.

Why I start teaching Clojure with Imperative Programming

LispCast Introduction to Clojure starts with 30 minutes of imperative programming. We write programs for their effects, so imperative is a great place to start.

How to Switch from the Imperative Mindset

Functional programming, from one perspective, is just a collection of habits that affect our programming. I've identified the cues for those habits and a routine for replacing imperative code with functional code.

Indirection Mechanisms and Expressive Power

The Importance of Embodied Metaphors

LispCast Introduction to Clojure teaches Clojure with an "interactive bakery simulation". The reason is that metaphors that you can embody are a great way to learn abstract things like programming.

An Interview with Game Developer James Hague

Introducing playnice

Introduction to Haskell talk

Introduction to Logic Programming with Clojure

Is core.async Against the Clojure Philosophy?

Clojure core.async is a way to manage mutable state. Isn't that against functional programming?

Janki Method

Java Generational Garbage Collection

The JVM's garbage collector allows for Clojure's persistent data structures to be practical. It's one of the benefits of being a hosted language: you can take advantage of the millions of dollars invested into the JVM's development.

JSON and Algebraic Data Types

Just Hack Something Together

Lisp is viewed as difficult and academic but it is a great language for hacking a solution together.

JVM Deployment Options

When you're working at a company, you usually inherit their deployment system. And that's great because then you just do what they do. But what if you are on your own? What are the options for deploying a Clojure server?

JVM JIT Optimizations

The JVM JIT is a highly optimized compiler. I present some resources for learning what it does.

Knockbox, an Eventual Consistency Toolkit

Lambda Abstraction

Lambda abstractions are always leaky, but some are leakier than others. Clojure programmers recommend keeping most of your functions pure and containing the leaks as much as possible.

How to avoid "Makes sense if you already understand it."

Most technical writing is obtuse unless you already know the topic. Focus on the learner and their skills and it will clarify your writing.

LESS has Better Forms of Abstraction than CSS

LESS has obviously better forms of abstraction and combination than CSS. It has recursive style definitions, which is enough to consider it a "powerful language".


Lisp with Macros is Two Languages

Lisp with macros can be seen as two languages, each with different semantics. The base language can be interpreted directly, whereas the result of interpreting the macro language is to produce a new program in the base language.

Locks vs Concurrency Primitives

Many people have asked me why Clojure has concurrency primitives. Aren't locks good enough? A humorous metaphor is elaborated.

Making True/False Questions Easy

Master one skill at a time

Research shows that developing mastery of a large skill is best done by mastering smaller skills that you can achieve 90% accuracy in very quickly. LispCast Introduction to Clojure has broken the skills you need down for you.

Mastering ClojureScript Routing with Secretary and goog.History

The Google Closure Library provides a nice interface to the HTML5 History API. Coupling it with Secretary is very easy. But not all browsers support HTML5 History. In this post I'll talk about one way to make sure you have client-side routing in all browsers.

Modern Language Wishlist

Monads & Gonads

Monads and Objects

Monads in Pictures

How can more layers be more efficient?

It's common that adding more layers of abstraction or indirection will make things slower. However, React and ClojureScript make web pages faster than doing it by hand — essentially programming the bare web. The lesson is that if you choose your layers well, they can actually make your system faster.

Moving Average in Lodash

We write a clean, readable, functional implementation of Moving Average with Lodash.


New Course Format

LispCast video courses have a new, interactive format. It's easier for me to make courses (read: more, faster) and it's a better experience for learners.

New Orleans Clojure Workshop Retrospective

We organized a Clojure workshop. Here's what went right and what we should do next time.

NeXT, OpenStep, and the Return of Steve Jobs to Apple

Nil Punning (Or Null Pointers Considered Not So Bad)

Null pointers are still a problem in Clojure, but several design decisions have made them less problematic than other languages.

Notes from the Mystery Machine Bus

Object-Oriented Dispatch is the Dual of Functional Dispatch

Object-oriented dispatch is contrasted with functional dispatch, but they are shown to be two one-dimensional projections of the same two-dimensional data. Clojure does not provide the two-dimensional representation, but does interesting things to transcend the one-dimensional views.

Object-Oriented Programming is the Dual of Functional Programming

Object-Oriented Programming is often shown in contrast to Functional Programming. But they are so exactly opposite that they are duals, and so equivalent in important ways. Which one to use should be left up to the programmer, as is done in Clojure and Javascript.

On Type Unity

Languages with strong, dynamic types (like Scheme) are actually single-typed languages, not untyped languages. Some would say this is restrictive, but this unity of type is a source of their strength.

Osterhout's Dichotomy Isn't

The Paper Metaphor

Functional programs follow a simple rule: never write on the same paper twice. Imperative programs are free to define their own rules. Both have interesting consequences.

Programming Paradigms and Expressive Power

Parser Combinators: How to Parse (nearly) Anything

The Parts of Ring

Ring, the Clojure Web library, defines three main concepts that you use to construct web applications.

Pre-conj Prep 2014

Prepare for the Clojure/conj with media from around the web.

Pre-conj Prep: Brian Goetz

Brian Goetz will give the keynote at Clojure/conj.

Pre-conj Prep: Colin Fleming

Colin Fleming will talk about Cursive Clojure.

Pre-conj Prep: Glenn Vanderburg

Glenn Vanderburg will talk about implementing the TeX algorithms in Clojure.

Pre-Conj Interview: Colin Fleming

Colin Fleming interview about Cursive Clojure.

Pre-conj Prep: Jeanine Adkisson

Jeanine Adkisson will give a talk about Variants in Clojure at the Clojure/conj 2014.

Pre-conj Prep: Nathan Herzing and Chris Shea

Nathan Herzing and Chris Shea will talk about Pedestal, Om, Datomic, and core.async.

Pre-conj Prep: Rich Hickey

Rich Hickey will talk about Transducers.

Pre-conj: Scheme Workshop

Jason Hemann talks about the Scheme Workshop.

Pre-West Prep 2015

Prepare for Clojure/West with media from around the web and interviews.

Pre-West Prep: Boris Kourtoukov

Boris Kourtoukov will talk about Clojure and wearables.

Pre-West Prep: Dan Lidral-Porter

Dan Lidral-Porter will talk about computer-generated art in Clojure.

Pre-West Prep: Sean Johnson

Sean Johnson will talk about pattern matching.

Pre-West Prep: Soren Macbeth

Soren Macbeth will talk about data crunching in Clojure.

Pre-West Prep: Timothy Gardner and Ramsey Nasser

Timothy Gardner and Ramsey Nasser will talk about Arcadia.

Pre-West Prep: Zachary Kim

Zachary Kim will talk about mobile development in Clojure.

Problems with the JVM

The JVM is great but far from perfect. Here are some problems with the JVM that Clojure has to work around.

Programming Paradigms and the Procedural Paradox

I break down two perspectives (their features and their methodologies) for the three most common paradigms. I also explore why paradigms are so easy to argue about, and what we can do about it.

Programming and Scaling

Programming Language Checklist

Programming Languages and Piaget's Stages of Cognitive Development Early Access Program

The Early Access Program is a way to make courses in a more iterative and interactive way. I'll be publishing Intro to clojure.test this week under PEAP.

React: Another Level of Indirection

React provides a better abstraction over the DOM than MVC frameworks ever can. React is the last piece of the puzzle for ClojureScript web frontend development.

6 things Reacters do that Re-framers avoid

Down on React? You should check it out from the ClojureScript perspective.

Reasoning About Code

Functional programmers often use the term "reason about code". It's not very well defined generally, but I use it myself to refer to our ability to use our real-world intuition in our own code.

Redline Smalltalk

Reduce Complexity with Variants

The structure of our data should match the relevant structures in the real world. And to ensure that our data is structured well, we should reduce the potential for incorrect structure. Variants provide a great solution for it.

When in doubt, refactor at the bottom

We explore when it is safe to extract out an abstraction and when you need to go deeper and rebuild it from scratch.


Reification means making an abstraction into a concrete value that can be manipulated at runtime. Reification is the core of what makes a language dynamic. Three types of reification in Clojure are discussed.

Review: Clojure Programming by Chas Emerick, Brian Carper, and Cristophe Grand

Rich Hickey: Keynote

Ring 1.0.0 Released

Clojure Screencasts

Seesaw REPL Tutorial

Separation of Presentation and Content

One reason to separate style from content is to reuse HTML or CSS. Ultimately, we would like a solution where we can reuse both.

Simplicity Matters by Rich Hickey

3 models of software development as a factory

Agile software development came from borrowing processes and ideas from manufacturing. Is software engineering like factory work? I examine three metaphors of software engineering as a factory.

Solarized Cheat Sheet

Solarized is an awesome color scheme that I use all the time. I was tired of looking up the hex codes, so I made my own cheat sheet. You can download it.

SOLID Principles in Clojure

The SOLID principles are guidelines for writing good Object-Oriented code. It turns out that these principles are followed and embodied in Clojure.

Practice as soon as possible

Much of the difficulty of learning a new language is caused by knowing more than you are comfortable doing. It's so important to get started practicing real programming as soon as possible.

Static vs. Dynamic Typing

Stop Refactoring and Start Factoring

Refactoring is focused on the quality of code, while factoring aims to uncover the underlying beauty of the problem domain, as expressed in code. Instead of cleaning up your code, try factoring.

PDF version of Structure and Interpretation of Computer Programs

(take 5 daniel-spiewak)

Tap Into Your Social Brain

We can solve social problems much more easily than logic problems, even when they are equivalent. Convert a logic problem into a social problem to make it easier to solve.

Use Task Analysis to Break a Skill Into Steps

Many technical books skip very important skills you need to complete a task. To avoid skipping those skills, use task analysis to break a skill into steps.

Let's TDD clojure.core/map

Learning to write map is a good lesson because it has recursion, list building, and higher order functions. It's everything that makes Lisp great.

The Case Against Curly Quotes

The Coming War on General Purpose Computation

The Content of Your Code

Code style is important, but way less important than content. Yet everyone talks about style because it's easier. Let's talk about content.

The Datomic Architecture and Data Model

The DCI Architecture: Lean and Agile at the Code Level

The future is specific

The future of programming

The Heart of Unix

The Impedance Mismatch is Our Fault

Why Clojure starts up slowly — is it really the JVM?

One of the most common complaints about the JVM is the long startup time. But what is really taking so long? We analyze some commands to find out.

The Most Important Idea in Computer Science

Computer Science has ideas that are important to the broader world. The most important is the Universal Turing Machine. From one perspective, Lisp embodies the idea at its core. To really understand how, I ask you to implement your own Lisp interpreter.

But the World is Mutable

The world may be mutable, but people have been using the notion of immutability to build reliable systems for a long time.

ThinkRelevance: The Podcast - Episode 009 - Alan Dipert

Tips for using marginalia

Token Buckets with core.async

Token Bucket is a simple algorithm for rate limiting a resource. It's easy to understand because you can reason about it in terms of real-world objects. core.async makes this algorithm very clear and easy.

Tricks for Java interop

There are several features of Java that generate weird classnames. We look at how to refer to them from Clojure.

Try Three Times in Clojure

Distributed systems fail in indistinguishable ways. Often, retrying is a good solution to intermittent errors. We create a retry macro to handle the retries in a generic way.

Two Kinds of Bootstrapping

I like languages with a small core that is extensible. The languages tend to be weird and require less code to bootstrap.

Use Your Imagination

You can transfer the outline of a skill by guiding someone through a structured use of their imagination.

The User Wizard Scenario

We start with a Haskell type that models a feature very well. As the feature changes, the data model eventually evolves into something like Clojure's hash maps. Discussion follows.


Waving Our Tentacles

What are macros?

Macros are one of the most talked about features of Lisp. They are a powerful way to extend the language without modifying the compiler.

What is an abstraction?

We explore some of the background behind the meaning of the word abstraction and why we do it.

What is Clojure?

Clojure is a general purpose programming language designed for the fast-approaching future.

What is ClojureScript?

ClojureScript is Clojure that compiles to JavaScript. It combines the power of Clojure with the reach of JavaScript.

What is Functional Programming?

I prefer to define Functional Programming as making a distinction between pure and impure code. With this definition, you can program functionally in any language. What differentiates the functional languages is how much help they give you to make the distinction.

What is React?

React is a view library for web pages that makes DOM rendering in a functional style really easy. React makes web programming fun again.

Why Functional Programming?

There are many reasons to learn Functional Programming. I go over my 11 favorite reasons. Reason #1 is it's fun!

Why is a Monad Like a Writing Desk?

Why Re-frame instead of Om Next

I had to choose between Re-frame and Om Next when building a course. Here are the reasons why.

Why Ruby?

Why should I have written ZeroMQ in C, not C++ (part II)

Why technical explanation alone is not enough

Why do we use Web Frameworks?

While contemplating a Clojure web framework, I explore the reasons we use web frameworks in general. I conclude that the framework should support a learnable development process.

Willy Wonka and the core.async Guidelines

There are a few conventions in core.async that are not hard to use once you've learned them. But learning them without help can be tedious. This article presents three guidelines that will get you through the learning curve.

Wrangling Clojure Stacktraces

Clojure error messages and stacktraces are the number one most complained-about feature of Clojure. We look at some tips and resources for dealing with them.

Yahoo!'s Doug Crockford on Javascript

Your Coding Philosophies are Irrelevant