We use a lot of variables in code and a lot of names. We need rules for how they work—especially when they conflict. We want those rules to make our lives easier. We don't want to accidentally refer to the wrong variable or to unexpectedly have it change the meaning.

That's what the scoping rules are all about. They tell us what each variable in our code refers to, even when there are duplicate names. If we master these rules, we can be confident that our code will do what we mean. And we can make the choices that are right for our new code.

Namespace declarations can be complicated. They manage all of the dependencies of one namespace on another. There are a lot of options. Would you like to know:

Namespaces are required knowledge for working in Clojure and ClojureScript. They can be hard to learn to manage, but once you do, they are rarely a problem.

Clojure is based on collections, but how are they used? What are the patterns for making the most of them? This section introduces you to the workhorses of the Clojure programming language, the immutable collections. We go over every built-in collection, how they are used, and when you should use them.

Clojure sequences are lazy by default. They're a common source of errors in Clojure software. What's worse, the error messages do not give much clues that the error has to do with laziness. They can be frustrating, but they're worth learning for the power they give you. Here's what you need to learn:

This section is designed to get you over the major hurdles of lazy sequences so you can start enjoying the separation of concerns that Clojure's lazy sequences grant you.

Ever wonder how to read those destructuring forms? Destructuring can be very confusing because it is so terse. When it's unfamiliar, it can be totally opaque. Once you learn it, though, you'll be using it all of the places.

This section introduces the idea of destructuring and goes through all of the possible ways to do destructuring in Clojure and when the forms should be used. You'll make your code clearer and shorter.

You've heard that Clojure is great for concurrency. But what tools does Clojure give you? And how should you use those tools? There are a lot of tools available, and each has its strengths and weaknesses. It can be difficult to learn how to choose between them. But once you do, you'll be firing up threads left and right to get work done in parallel.

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.

There's a big problem in software. You've got all these different types, and all of these different roles they play in your software. But sometimes you can't modify the code for the type. Maybe it's in a Java class in a library. Clojure's protocols let you solve this. You can extend existing classes or build protocols into new types.

When you have different types filling the same roles, we call that polymorphism. Clojure uses protocols for polymorphism. They are totally extensible on "both ends". You can extend existing types with new roles. And you can fill existing roles with new types. They let you create very flexible software with little effort.

In this course, you will learn: