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.
Introduction to Clojure v2
A fun and gentle introduction to the Clojure language, functional programming, and data-drive programming, through the eyes of baking robot X5.
Get started with functional programming in Clojure.
3 Functional Tools
Learn these three tools -- map, filter, and reduce-- and you'll be well on your way to developing a functional mindset.
If you come from a non-JVM language, you should brush up on the Java Virtual Machine.
JVM Fundamentals for Clojure
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.
In Clojure, collections are used extensively. This will go over some of the patterns Clojure programmers use with collections.
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.
Scope refers to the rules which tell you which parts of your code can access which variables.
When you are looking at a variable, how do you know what it refers to? The rules that determine what variable names refer to are collectively called the scoping rules. Learning the three kinds of scope and when to use each will help you make your code more maintainable.
Recursion is the main way we build data structures iteratively.
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.
Clojure organizes code into namespaces, which are simply files with certain names. This course goes over how to declare a namespace and how to navigate namespaces at the REPL.
Namespace declarations can be complicated. They manage all of the dependencies of one namespace on another. There are a lot of options. In this course, we go over how to make best use of them.
Leiningen is the powerful project tool that is used by most Clojure programs. It keeps track of dependencies, has a powerful plugin system, and will run your projects.
Leiningen is the de facto standard project tool in Clojure. This course gives an overview of
lein commands, projects, templates, and dependencies.
Web development in Clojure is based around the Ring system. This course explains all of the concepts you’ll need.
Web Development in Clojure
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.
Learn the built-in testing library called clojure.test so you can do unit testing in Clojure.
Intro to clojure.test
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 is known for its powerful concurrency primitives. This course is a compendium of them. Dip in and out as you need something.
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.
Learn some of the basic syntax of Clojure. This course includes function syntax and for-comprehension syntax.
Learn the tricky corners of Clojure syntax, like for comprehensions and function definitions.
Clojure’s sequences are lazy, meaning they don’t execute the elements until they are needed. This has important consequences, and you should learn those in this course.
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.
A few projects done in an hour or less.
Clojure in One Hour
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.
Learn to read and write different data formats.
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.
This course shows how we can use Data to model interesting properties of our systems.
Data Modeling in Clojure
In Clojure, the common advice is "just use a map". There's some truth to that, but it's obviously more complicated. Clojure gives you lots of ways to model a problem. In this course, I give you a peek behind the curtain. I work step-by-step through different iterations of a domain model, discussing what I'm thinking, why I'm trying something else. We model the game of solitaire, a card game we're all familiar with.