All Courses

See just the courses with free lessons.

You may also like to see the reverse-chronological list.

Total time: 40h59m

Beginner

Building Re-frame Components

Time: 02h44m

How do I build reusable components? How do I choose component-local state vs application state?

Category Theory from the Universe Up

Time: 01h54m

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? These lessons will show you:

  • How a pile of rocks is a Monoid.
  • How a list of notecards is a Functor.
  • How a bag of candy is a Monad.
  • And more.

Does the JVM make Clojure intimidating?

Time: 05h07m

This course teaches you the hands-on, nitty gritty details of the JVM and Clojure/Java interop that you would pick up after many years of programming Java. It combines videos with reference sheets to give you easy access to the accumulated skills of years of experience. With this course, you won't have to worry about stack traces, JVM options, or the standard library again.

Clojure Scope

Time: 40m58s

Introducing Clojure to the Enterprise

Time: 48m43s

If you already work at a large company, you may want to find ways to introduce Clojure to your work. This guide presents 5 steps for bringing Clojure into your job.

Introduction to Clojure

Time: 01h35m

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!

3 Functional Tools

Time: 39m46s

Learn these three tools -- map, filter, and reduce-- and you'll be well on your way to developing a functional mindset.

Manipulating time with clj-time

Time: 52m20s

Manipulating time is a difficult thing. Time was made for people. The rules are complicated and depend on where you are on Earth. Time units have varying lengths (how long is "one month"?; how long is a day when you change daylight savings?), daylight savings depends on the country you're in, and formatting dates depends on the language. It's complicated. Luckily, Joda Time does an excellent job. Joda Time is a date-time library that represents everything immutably. It's what people use when they want robust date-time calculations. clj-time wraps up the types from Joda Time and makes it easy to use from Clojure.

Clojure in One Hour

Time: 03h16m

You want to learn Clojure but it seems so daunting. Who has the time to read and read and then start yet another half-finished project? Clojure in One Hour is a series of short projects that you can do in one hour. No theory, just hands-on projects to get something done.

Leiningen

Time: 46m17s

Leiningen is the de facto standard project tool in Clojure. This course gives an overview of lein commands, projects, templates, and dependencies.

Reduce Mini-Course

Time: 29m49s

Why is everyone always talking about reduce? Reduce is actually really cool. It's the bee's knees, you might say. And it's also a universal recursion. With it you can implement lots of other recursive functions. This mini-course also goes over some of the more practical stuff you can do with reduce.

HTTP Client: clj-http

Time: 46m43s

Chances are you will need to access an API on the web without a custom API client. You'll have to make the web requests yourself. You want something reliable, fast, and with all the features. In Clojure, that is clj-http.

Recursion 101

Time: 45m06s

What is recursion? How do you write recursive functions? Does it work with laziness? How is it different from a for loop? All of these questions are answered, and more, using simple, clear examples. You'll never have fear of recursion again.

Complete Web App from Scratch

Time: 05h11m

What does it take to build an entire web app from scratch? This course is a longer one. It starts from a barebones project and gradually develops into a complete web app with REST API.

Intro to clojure.test

Time: 35m39s

Are you wondering how to test your code? Would you like to use the most popular testing framework for Clojure? Do you want to know the correct conventions so that your tests work well in IDEs and continuous integration services? This course teaches all of that in a fun, interactive style.

Clojure Collections

Time: 31m00s

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.

Clojure Syntax

Time: 27m25s

Namespaces

Time: 19m09s

What's with all the namespace directives? How do I refer to Java classes? Can you not include stuff from clojure.core? Clojure namespaces are powerful but complex. This course is all about how to use them effectively.

Answers to Questions

Time: 04m57s

I get a lot of questions from people trying to learn Clojure. Sometimes, the best way to answer them is with a video. This course is for all of those questions that don't really fit anywhere else.

Data Formats

Time: 01h03m

With so many data formats out there, it's good to see some example code for reading and writing different formats. I'm talking JSON, CSV, EDN, and more. This course explores how to read and write data formats using Clojure.

Lazy Sequences

Time: 34m14s

Clojure sequences are lazy by default. That gives you big benefits like separation of concerns, but it also brings with it some gotchas. This course is mostly about exploring those gotchas--problems that can bite you if you're not ready for them--and techniques to work with each one. Being prepared is the best antidote to a bad bite. After dealing with the downsides, we explore the big benefits.

Data Modeling in Clojure

Time: 01h50m

People talk a lot about using data to model things in Clojure. But how do you do that? This 9-part series explores many different ways to model systems in Clojure, including with various literal data structures, closures, and records. This is a serious exploration with tradeoffs discussed. Your math teacher would be proud: all work is shown so you see how everything is related.

Concurrency

Time: 19m29s

You've heard that Clojure is great for concurrency. But what tools does Clojure give you? And how should you use those tools? These lessons are meant to each answer a specific question and help you build the skills you need to address a wide variety of concurrency problems.

Intermediate

Protocols

Time: 01h13m

Protocols are a very cool and very important feature in Clojure. They are a great way to build polymorphism into your software, including extending existing Java classes without modifying them.

Emacs

Time: 38m33s

Emacs is definitely the most popular Clojure editor. But it's kind of hard to know where to get started with it. This course aims to introduce you to Emacs as a general editor and for use with Clojure.

Beginning with Clojure Macros

Time: 01h38m

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.

Destructuring

Time: 42m24s

Ever wonder how to read those destructuring forms? Do you want to know how to make your code clearer and shorter? Where can destructuring be used? And how do you construct each one? This course starts from the basics and works through all of the destructuring forms, ending with some examples and advice for using them.

Clojure Combinators

Time: 45m08s

Combinators are an important part of functional programming. They are functions -- usually small -- that combine their arguments into new functions. They're great fun and have a lot to teach about functional programming and the lambda calculus. They are an important part of any Clojure programmer's toolkit.

Web Development in Clojure

Time: 01h04m

Web development in Clojure is just like everything else: you build up complex behavior from simple parts. This course builds a TODO list app from scratch, explaining the important concepts, and deploying it to a cloud service.

Clojure core.async

Time: 01h25m

You've probably mastered the basic concurrency primitives in Clojure. You know just when you need an Atom, how to do transactional updates with Refs, and can do some interesting tricks with Agents. Are you ready to go to the next level? core.async is that.

Advanced

Optimization

Time: 15m06s

How do we optimize our Clojure code?

Single Page Applications with ClojureScript and Om

Time: 01h00m

In this course, we develop the frontend of an app to help a scientist record her experiment notes. It's a lab notebook. The app is completely client-side. It uses ClojureScript and Om.

core.async Patterns

Time: 50m02s

Clojure core.async provides basic building blocks for communication and coordination. This course explores ten patterns you can easily implement using those building blocks.