Learn a strong functional programming language like Clojure with a deep understanding of concepts, mindset, and code conventions.

Clojure, a robust functional programming language, employs the principle of pure coding to enhance code encapsulation, reusability, test coverage, and system maintenance. Its succinct grammar further enhances its capabilities.

Throughout this course, you will delve into the core tenets of functional programming. This foundation ensures a comprehensive grasp of the rationale behind Clojure's approach. You will also immerse yourself in Clojure coding, exploring captivating and illuminating subjects that define its unique functional nature. Moreover, you’ll gain insights into the formidable tools that Clojure seamlessly integrates, including Java libraries.

Clojure stands as a premier choice among functional programming languages. It leverages the Java Virtual Machine (JVM), enjoys wide adoption in the tech industry, and boasts a straightforward setup. Its accelerated learning curve has propelled its growth in the market, making it an invaluable asset for learners to acquire.

Becoming a Functional Programmer with Clojure

To modify values and transform references into mutable references

To extend the code in a way that allows you to create functionality that can be reused multiple times and integrated as if it were part of the core code of the system

To extend the code by modifying the references of existing core functions

To extend the code by adding arities to existing core functions

What are the Clojure reader features in the following order?
1. The one we use to force the evaluation of a part of a code
2. The one we use to retrieve the pure content of a function, including the namespace that it belongs to

What are the Clojure reader features in the following order?
<ol>
<li>The one we use to force the evaluation of a part of a code</li>
<li>The one we use to retrieve the pure content of a function, including the namespace that it belongs to</li>
</ol>

They improve scalability by converting nested function calls into a linear flow.

They improve testing by converting nested function calls into a linear flow.

They improve performance by converting nested function calls into a linear flow.

They improve readability by converting nested function calls into a linear flow.

What are threading macros used for?

```
(-> my-list
   (filter #(>= 21 (:age %)))
   (map :name)
   first)
```

```
(->> my-list
     (filter #(>= 21 (:age %)))
     (map :name)
     first)

```
(->> my-list
     first
     (map :name)
     (filter #(>= 21 (:age %))))


```
(-> my-list
    first
    (map :name)
    (filter #(>= 21 (:age %))))

Suppose you have this list of maps: 



```
(def my-list [{:name "Julie" :age 12} 
              {:name ... :age ...}    
               ...                    
              {:name ... :age ...}])

```

This is a `vector` with hash maps, and each hash map has a `:name` and an `:age`.

In your code, you want to perform a sequence of functions over this `vector`, which would be like this:

```
(first (map :name (filter #(>= 21 (:age %)) my-list)))
```  

How can you transform it to make it more readable using threading macros?





Suppose you have this list of maps:
<pre><code>(def my-list [{:name &quot;Julie&quot; :age 12} 
   {:name ... :age ...}    
   ...                    
   {:name ... :age ...}])

</code></pre>
This is a <code>vector</code> with hash maps, and each hash map has a <code>:name</code> and an <code>:age</code>.
In your code, you want to perform a sequence of functions over this <code>vector</code>, which would be like this:
<pre><code>(first (map :name (filter #(&gt;= 21 (:age %)) my-list)))
</code></pre>
How can you transform it to make it more readable using threading macros?

You shouldn’t mix thread-first `->` with thread-last `->>`.

You shouldn’t thread arithmetic, such as:
```
(-> 1
    (+ 2)
    (- 13))

You shouldn’t use an anonymous function to invert the order of an argument.

What should you avoid doing when talking about threading?

What should you avoid doing when talking about threading?

Introduction

Functional Programming (FP)

A Short History of Clojure

Data Structures

Functions

Multimethods, Protocols, Records, and Namespaces

Clojure and Its Macros

Concurrency and Parallelism Support

Clojure Unit Testing

Java Interop

Writing a Clean Clojure Code

Bank Account Activities

Conclusion

Quiz: Clojure and Its Macros