All Courses

See just the courses with free lessons.

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

Total time: 13h26m

Beginner

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!

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.

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.

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.

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.

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.

Intermediate

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.

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.

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.

Advanced

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.