Clojure is a functional hosted LISP known for its expressiveness, which has excellent interop with Javascript, Java, and Microsoft's Common Language Runtime (CLR). 

Many developers praise the elegance and productivity Clojure allows, but for many it seems like an esoteric language with an "ugly" syntax that is impossible to get started with. This course will change that view and show you how to be productive with this marvelous language.

In this course, we'll build a web-based graphics editor similar to Canva. We'll explore Clojure from the perspective of a JavaScript developer. Along the way, we'll also explore state management, authentication, API integration with Google Firebase and interop with NPM.

This course takes you from zero to an understanding of Clojure semantics, LISP tools, and building a production-ready React application in just a few hours. 

We'll start with the basics and build up to writing a fullstack app with both frontend and backend in Clojure. 

The frontend, built using ClojureScript (Clojure that runs on JavaScript) will be a single page React application with routing, key-based authentication and API integration, which will save, list, edit and delete graphics.
 

The backend is hosted on Google Firebase. 

Throughout the course, we'll learn about tools like REPL that aid development. Towards the end, we'll learn about advanced concepts like code splitting and end-to-end testing.

Clojure is unlike other languages as it is hosted on, and can leverage, existing VMs. This means that you can learn Clojure once and write it on the backend with JVM or CLR, and the frontend with JavaScript. If a new technology like Rust takes over the world tomorrow, you will probably be able to continue to write Clojure because a Rust port is already in the making.

By the end of this course, you'll have a superpower: the ability to write fullstack Clojure applications.

Build a Fullstack Web Graphics Editor in Clojure and React

This is a course on Clojure for React developers in which we'll build a web-based graphics editor similar to Canva.

Tinycanva: Clojure for React Developers

---
title: Threading Macros in Clojure - Thread-Last vs Thread-First vs As
slug: stdlib-threading-macros
description: Nested calls can become hard to manage. Threading macros help us take control. In this chapter, we'll learn about the concept of threading macros and study three commonly-used versions.
privateVideoUrl: https://fullstack.wistia.com/medias/6cq5lg1rkb
code: https://gitlab.com/fullstackio/books/newline-course-apps/shivek-khurana-tinycanva-clojure-for-react-developers-app/-/tree/main/code/module_03/lesson_03.04/App/source_code/first-project?ref_type=heads
---

# Threading Macros

:::note
The term `thread` has got nothing to do with parallel programming. Thread is an expression for a linear series of operations, like pearls on a thread.
:::

As your functions grow in complexity, the readability of your code is affected. Suppose you have a list of books with various attributes, and you want to find the number of books related to each unrestricted book:

```clojure { actualFilename=./protected/source_code/first-project/src/first_project/threading_macros.cljs endLine=12 startLine=3 statedFilename=first-project/src/first_project/threading_macros.cljs url=https&#x3A;//gitlab.com/fullstackio/books/Build-Canva-with-Clojurescript/module_03/lesson_03.04/protected/source_code/first-project/src/first_project/threading_macros.cljs#L3 }
(def books
  [{:id 1 :restricted? false :publish-year 1800 :related [3 4]}
   {:id 2 :restricted? false :publish-year 2001 :related [5]}
   {:id 3 :restricted? true :publish-year 2019 :related []}
   {:id 4 :restricted? false :publish-year 1893 :related [1 5]}
   {:id 5 :restricted? false :publish-year 1903 :related [2 3]}
   ])

(map #(count (:related %))
     (filter #(not (:restricted? %)) books)) ;; => (2 1 2 2)
```

The complexity of that `map` operation can easily grow beyond control. What happens if we want the publishing year of all related books?:

```clojure { actualFilename=./protected/source_code/first-project/src/first_project/threading_macros.cljs endLine=20 startLine=15 statedFilename=first-project/src/first_project/threading_macros.cljs url=https&#x3A;//gitlab.com/fullstackio/books/Build-Canva-with-Clojurescript/module_03/lesson_03.04/protected/source_code/first-project/src/first_project/threading_macros.cljs#L15 }
(defn publish-year-by-id [books id]
  (:publish-year (first (filter #(= id (:id %)) books))))

(map (fn [unrestricted-book]
       (map #(publish-year-by-id books %) (:related unrestricted-book)))
     (filter #(not (:restricted? %)) books)) ;; => ((2019 1893) (1903) (1800 1903) (2001 2019))
```

We performed the following operations:

-   filtered all books that are restricted
-   called `publish-year-by-id` function on each element of `:related` vector

Threading macros help decomplect nested function calls.

## thread-last macro (`->>`)

The `thread-last` macro makes nested function calls easier to express. A function call:

```clojure
(f (g l (h p q x)))
```

can be expressed as:

```clojure
(->> x
     (h p q)
	 (g l)
	 f)
```

In thread-last macro expansion, the result of a form is passed as the last argument to the next form. Let's rewrite our `publish-year-by-id` with the thread-last macro:

```clojure { actualFilename=./protected/source_code/first-project/src/first_project/threading_macros.cljs endLine=27 startLine=22 statedFilename=first-project/src/first_project/threading_macros.cljs url=https&#x3A;//gitlab.com/fullstackio/books/Build-Canva-with-Clojurescript/module_03/lesson_03.04/protected/source_code/first-project/src/first_project/threading_macros.cljs#L22 }
(defn pub-year-by-id [books id]
  (->> books
       (filter #(= id (:id %)))
       first ;; or (first)
       :publish-year ;; or (:publish-year)
       ))
```

Notice how we are able to use the `first` function and `:publish-year` keyword without parentheses. You can add parentheses if you wish to, but Clojure assumes parentheses in cases where a callable form is passed. Most developers find forms using threading macros more readable.

Nested calls can become hard to manage. Threading macros help us take control. In this chapter, we'll learn about the concept of threading macros and study three commonly-used versions.