What mysteries do Clojure macros hold? This course jumps right into macros with gusto. It starts with the key to understanding macros, takes you through the implementation of 6 progressively more complex macros, and finishes with the three reasons you *need* macros.

Sometimes we want to see how individual components are built. We want to know how to reproduce common components easily using Re-frame. In this course, we take that approach. We build individual, interactive components, going through the design decisions we have to make.

Ever been completely baffled by Wikipedia articles on Monads and Functors? Are you curious about what everybody is raving about, but can’t find any good ways to learn it? It turns out that many of the ideas of category theory come almost directly from the real world. Wouldn’t you like to understand how those concepts relate to the real world?

Clojure is based on collections, but how are they used? What are some patterns for making the most of them? This course introduces you to the workhorses of the Clojure programming language, the immutable collections.

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.

Learning Paths

Clojure can be an excellent language to learn programming. The following courses should set you on a good path for getting up to speed in Clojure. Be sure to click those checkmarks to track your progress. Start with the best introduction to Clojure out there. It gently guides you through the language with fun exercises. […]

If you’re coming to Clojure from an Object-Oriented Programming background, this page is for you. Be sure to click those checkmarks to track your progress. Start with the best introduction to Clojure out there. It gently guides you through the language with fun exercises. You’ll learn the syntax and the thought processes behind Clojure programming. […]

If you’re looking to watch absolutely all of the courses on this site, I’ve put together a suggested order. Start at the beginning and just watch everything straight through. Be sure to click those checkmarks to track your progress.

Web development is an extremely popular use for Clojure. If you want to learn web programming, here are the courses I recommend you watch. I am assuming you already are familiar with Clojure. Be sure to click those checkmarks to track your progress. Backend You’ll want to learn Ring. It is a unifying set of […]

Sometimes we need to get a reference to the real DOM node that React normally manages for us. For instance, when we need to play an embedded video, the API requires access to the DOM node of the video element. React gives us a feature called Refs that let us get access to any DOM node it creates.

We tend to code using patterns that we repeat a lot. Learning these patterns can help you level up your macro skills very quickly. This reference sheet contains six annotated patterns that Clojure programmers use all the time.

Have you ever wondered what the symbols in Clojure macros do? I’m talking about `, ~, ~@, etc. This handy reference sheet tells you what they all do, when to use it, and shows examples. Never get lost in a macro again!

When we’re developing macros, it really helps to be able to see what code it will output. Fortunately, Clojure comes with three built-in functions for doing just that. They are so useful for debugging. This reference sheet shows what each one does. It also includes how to access macroexpansion in the three most popular Clojure […]

Want a handy reference for writing your tests? This cheatsheet contains everything you need to write tests, make assertions, and set up fixtures. It even shows the commands for runnings tests at the REPL.

Newsletter Issues

Issue 327 – May 20, 2019 · Archives · Subscribe Clojure Tip 💡 always be decomplecting Decomplecting is design. It’s a way to understand a problem better. And code is an encoding of the understanding we have of the problem. always be decomplecting asserts that our code should reflect the contours of the problem. Whenever […]

Issue 326 – May 13, 2019 · Archives · Subscribe Clojure Tip 💡 consult your repl I’ve often been surprised by beginners in Slack or on IRC who ask questions about the behavior of code. They will say “what happens when I divide by zero, like (/ 1 0)?” They are asking people to tell […]

Issue 325 – May 06, 2019 · Archives · Subscribe Clojure Tip 💡 don’t use a protocol to make testing easier Warning ⚠️: this may be a controversial tip. People often use protocols to make testing easier. For instance, they might make a protocol that represents the database. In production, they use a type that […]

Issue 324 – April 29, 2019 · Archives · Subscribe Clojure Tip 💡 use tuples for local data, entities for global data Tuples and entities serve a common purpose. They are both used to group related data together. The difference between them is that tuples use positions to denote the pieces of data, and entities […]

Issue 323 – April 22, 2019 · Archives · Subscribe Clojure Tip 💡 keep your workflow simple In my Repl-Driven Development in Clojure course, I recommend learning three commands for executing code: one to evaluate the whole file, one for a top-level form, and one for a single expression. With those three, you’ve got all […]

Issue 322 – April 15, 2019 · Archives · Subscribe Clojure Tip 💡 avoid flatten when possible I see a lot of people using flatten, but I wonder if they know that it’s kind of dangerous. It’s dangerous because it indiscriminately flattens all nested sequences. People usually call it just to flatten one level. Here’s […]

Programmers

Alan Kay invented Smalltalk and Object-Oriented Programming. He reads more than a book per day. He has worked at Xerox PARC, Atari, and Apple. He’s currently the president of the Viewpoints Research Institute.