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.
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.
Clojure has immutable collections, which are used to represent all kinds of things. This course will guide you through how they are used.
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.
At this point you may want to start a small project of your own. In this course, you develop a simple TODO list web application. All code is provided.
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.
The three functional tools are map, filter, and reduce. These functions are used extensively in Clojure programs.
3 Functional Tools
Learn these three tools -- map, filter, and reduce-- and you'll be well on your way to developing a functional mindset.
It’s good to understand how variables work in Clojure. Scope refers to what 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.
Clojure is designed to be developed using Repl-Driven Development. This is a workflow that interacts and modifies a live, running system.
Repl-Driven Development in Clojure
This course teaches the mindset, practices, and tools of Repl-Driven Development as practiced in Clojure.
Testing is an important concept when developing production applications. This course shows how to use Clojure’s built-in testing library, clojure.test.
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 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 most popular project tool in Clojure. It is what fetches dependencies and runs your program. This course goes through all of the features of Leiningen that you need to know for daily use.
Leiningen is the de facto standard project tool in Clojure. This course gives an overview of
lein commands, projects, templates, and dependencies.
This course has some simple projects that we build in one 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.
Clojure’s sequences are lazy, meaning the elements in the sequences are not calculate unless they are needed. This has some consequences you should be aware of.
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.
Recursion is the main way Clojure does looping.
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.
As a Clojure programmer, you will probably need to coordinate several threads accessing the same resources, such as mutable state. Clojure’s concurrency primitives will let you do that. This course is a compendium. You should dip into whichever one you believe you need at the moment.
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.
This course contains more details of Clojure’s syntax, including all of the syntax for defining functions and the for sequence comprehension.
Learn the tricky corners of Clojure syntax, like for comprehensions and function definitions.
If you want to know about the Java Virtual Machine, which is the platform Clojure runs on, this course is for you.
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.