Already subscribed?

Reactivate course downloads

“Clojure is so frustrating for beginners! I don't know where to start.”

I hear that from people all the time. Clojure is a great language, but there's so much to understand just to get started. If you're teaching yourself, it can be difficult.

Have you struggled with these problems:

  • Getting Clojure set up
  • Figuring out how to start a project
  • Getting an editor working
  • The funky syntax
  • The terrible error message
  • Understanding functional programming basics

On top of those issues, the documentation is definitely not geared to beginners. It's nearly impossible to find even blog posts that are up to date and use simple language. Nobody explains the terms they use!

The bottom line is that Clojure is great but it's probably turning away tons of smart and excited people because it's so hard to get started.

Jalil Mohammed “This was the first time it all started to click for me with Clojure. The video's flow and structure was really good, and the explanations on Clojure are very easy to understand. Thanks to LispCast I am very confident in my understanding of Clojure now. I'm looking forward to more videos from LispCast.”

What if you could learn Clojure step-by-step, starting from zero? Wouldn't it be great if someone could guide you through each step? What if each step helped you master the material before moving on to the next? And what if it was fun and interactive? Would you like that? I sure would!


  • Muscle memory of the syntax of Clojure
  • Firm grasp of conditional, loops, and function definitions
  • Confidence in the fundamentals of Functional Programming
  • Fluency with the built-in data structures
  • A peek into the deeper power of Clojure


LispCast Introduction to Clojure

A fun and interactive Clojure tutorial — now part of Online Mentoring

Jennifer Eliuk “These videos are so good in so many ways. Audio/production quality is great, the curriculum is delivered in real English—not CS jargon, and takes you from zero to understanding the basics in a really thought-out way. They're not videos you just watch, you're actively coding along with Eric. I love that everything starts in the REPL, then progresses to working in files. If you're new to Clojure, this is where I recommend you start.”

I made LispCast Introduction to Clojure because I wanted to help people get started with what I knew was a great language. I focused on the fundamentals the beginners get stuck on: the syntax and functional programming.

Intro to Clojure is a three-part video course. But it's more than just some screencasts. It's got exercises, an interactive bakery simulation, and lots of visuals to help explain everything. Everything is taught one bit at a time, then practiced through exercises directly after. Each exercise builds on the last. By the end, what used to be difficult will be easy. You'll be ready for more advanced code.

This is not the typical "guy with some slides" or "guy sharing his screen" videos. These are animations, structured exercises, and carefully crafted curriculum to help you build real Clojure skills, from opening and closing parentheses to building elegant code using functional design patterns.

Who is this for?

Intro to Clojure is for anyone new to Clojure. Whether you've got prior programming experience or not, everything is taught new, without jargon, but without condescending. If you already know a Lisp or other functional programming languages, this isn't for you. And don't buy this if you don't want to do the exercises. The exercises are an integral part of the learning experience.

Charles Ko “LispCast was awesome! It progressed smoothly and the exercises became more challenging with each video. I'm still a beginner and I've always loved the elegance of Lisp and it was refreshing to find such a fun introduction. Definitely looking forward to more videos in the future.”

I used to sell Intro to Clojure separately, but now it's part of Online Mentoring. If you subscribe, you get full access to Intro to Clojure plus all of my other Clojure material, with new Clojure lessons coming out frequently.

Here's what you get:

  • Small lessons (3-12 minutes) with screencasts, code, exercises, and more, published regularly
  • Complete access to the entire backlog (including this and the other longer LispCast courses)
  • Active discussion forum where you can learn from others
  • Questions answered—ask me anything, give me advice, suggest topics, and talk with other Clojurists of all levels

The curriculum

People often ask me what they will learn. That's a great question. I've gone through and written down everything that's in the videos. Keep in mind that these aren't just bullet points on slides. These are skills I am confident you will be able to do yourself (because many others have) if you watch and do the exercises.

Blue Robot X5 Meet X5. X5 has always dreamed about being a baker.

The first part is his first day at bakery school. Through interactive exercises, you can help him learn to bake some recipes while you learn Clojure.

LispCast Introduction to Clojure Part 1

The purpose of the first part is to get you super comfortable with the basics of the language so that when you go deeper in Part 2, you'll have the skills necessary to learn them. Part 1 is 33 minutes long.

What you'll learn (not in this order)

  • Installing Clojure
  • REPL basics
    • Launching a REPL
    • Getting documentation at the REPL
  • How to call a function
  • Keyword syntax
  • How to define functions
    • with one argument definition
    • with multiple argument definitions
  • Conditional expressions
    • cond
    • if
    • what values count as true and false
  • do expressions
  • dotimes expressions

By the end of Part 1, you will be writing code that looks like this.

(defn add-simple
     (add-simple ingredient 1))
  ([ingredient amount]
     (if (simple? ingredient)
       (dotimes [i amount]
         (grab ingredient)
         (println "This function only works on simple ingredients. You asked me to add" ingredient)

Pink Robot JC Meet JC. JC is X5's baking instructor. She will teach you the Clojure you need to help X5.

In Part 2, X5 not only has to bake full recipes, but also manage ingredients. You'll need several functional programming techniquest to do this!

LispCast Introduction to Clojure Part 2

The purpose of the second part is to begin working in a real project structure and get into functional programming. Part 2 is 38 minutes long.

What you'll learn:

  • Clojure project structure
  • Rest arguments to functions
  • apply function
  • Collection types
    •   Sets
    •   Maps
  • IFn Interface
  • seq function
  • doseq expression
  • Introduction to functional programming
    • what is functional programming?
    • common functional idioms
      • merge-with function
      • into function
      • for expression
      • map function
      • reduce function
    • range function
  • let expression

By the end of Part 2, you'll be writing code that looks like this:

(defn multiply-ingredients [n ingredients]
  (into {} (for [[ingredient amount] ingredients]
             [ingredient (* amount n)])))

(defn order->ingredients [order]
   (multiply-ingredients (:cake (:items order) 0) {:egg 2
                                                   :flour 2
                                                   :sugar 1
                                                   :milk 1})
   (multiply-ingredients (:cookies (:items order) 0) {:egg 1
                                                      :flour 1
                                                      :butter 1
                                                      :sugar 1})))

X5 with cake In Part 3, X5 manages the entire bakery. He gets daily orders, has to calculate the ingredients he needs, and is learning lots of new recipes. Help him organize all of this with an in-memory index of recipes. At the end, he graduates!

LispCast Introduction to Clojure Part 3

The third and final part of Intro to Clojure is all about data-driven programming. That's where you define a data structure that looks like the thing it means. In our case, we're making a data structure that looks like a recipe. Then there's a function that can interpret that recipe and bake it. Part 3 is 24 minutes long.

What you'll learn:

  • How to represent something as data
    • Choosing a representation
    • Building an interpreter
  • group-by function
  • Anonymous functions
  • Refactoring functional code

By the end of Part 3, you'll be writing code like this:

(def actions {:add (fn
                     ([recipe ingredient]
                       (= :all ingredient)
                       (doseq [[ingredient amount] (:ingredients recipe)]
                         (add ingredient amount))

                       (contains? (:ingredients recipe) ingredient)
                       (add ingredient (get (:ingredients recipe) ingredient))))
                     ([recipe ingredient amount]
                      (add ingredient amount)))
              :mix (fn [recipe]
              :pour (fn [recipe]
              :bake (fn [recipe minutes]
                      (bake-pan minutes))
              :cool (fn [recipe]

(defn perform [recipe step]
  (let [f (actions (first step))]
    (apply f recipe (rest step))))

(defn bake-recipe [recipe]
  (last (for [step (:steps recipe)]
    (perform recipe step))))

(defn bake [item]
  (bake-recipe ((:recipes baking) item)))

Here's a preview

This is an exerpt from Part 2. It's defining functional programming and showing you a handy function called merge-with.

Subscribe now

LispCast Introduction to Clojure is now a part of Online Mentoring.

All of the material in the program would normally sell for $500 if you bought it separately.

Yearly subscription

For just $200 per year, you can get access to all of the material listed here, all of the other existing material, and all material newly released for one year. This is an incredible savings and I don't know how long I can keep selling it for this price.

Pay via secure online credit card payment or PayPal. Your payment will recur every year. Cancel any time.

Monthly subscription

For $25 per month, you get access to all of the great content listed here, plus all of the other material I didn't list, plus anything new that I create. Considering that it would normally sell for $500 if you bought it separately, this is a great deal.

Pay via secure online credit card payment or PayPal. Your payment will recur every month. Cancel any time.

Filip Zrůst “I went from ‘Yes, I can read Clojure’ to ‘Yes, I can write Clojure programs from scratch without constantly double checking everything and feeling lost anyway’.”

Love it or Leave it Guarantee

If you're unhappy for any reason, I will refund 100% of your money. Just let me know within 30 days of subscribing.

Who makes this?

Hi, my name is Eric Normand. I've been programming in various Lisps since 2001. My current favorite language is Clojure and I'm lucky enough that it's my primary language at work. I've also worked in Haskell, Java, JavaScript and .NET.

I discovered my love for teaching while teaching math in the West African country of Guinea. I write about functional programming at LispCast and I also publish The Clojure Gazette.

I hail from New Orleans, Louisiana, where you can still find me making gumbo.

I live with my wife and daughter.

3 Lessons for Free Enter your email address and I'll send you three free lessons, reference sheets, and more.

I want some free Clojure learning stuff!

No problem! Sign up below and I'll send you three free lessons (about three common functional programming tools), reference sheets, and other valuable information about learning Clojure and ClojureScript, including flashcards for the top 100 most common Clojure expressions.s

Which email address shall I send that to?

Phil Huggins “I'd read some of the core Clojure texts and I could see there was value in the language. However, I struggled to find the time to really get the language under my skin. Now I've made Clojure real for me. The LispCast kickstarted me.”