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

The techniques for splitting a task and running the subtasks simultaneously 

The techniques for organizing the internal architecture of our software

The techniques for splitting tasks into subprocesses and canceling when necessary

The techniques for organizing software architecture among different repositories

What are concurrent and parallel programming?

What are concurrent and parallel programming?

Subprograms that can execute their own set of instructions

What Clojure macro is used to define a task and place it on another thread without requiring the result immediately and without having to set the thread up?

What Clojure macro is used to define a task and place it on another thread without requiring the result immediately and without having to set the thread up?

Many functions that work with parallelism and mutable states have the ability to dereference themselves, which means that you're able to access them. What is this function in Clojure?

Many functions that work with parallelism and mutable states have the ability to dereference themselves, which means that you’re able to access them. What is this function in Clojure?

What Clojure macro ensures that some code either never runs (if it's never dereferenced), or runs one time (if it's dereferenced), regardless of how many times it's called?


What Clojure macro ensures that some code either never runs (if it’s never dereferenced), or runs one time (if it’s dereferenced), regardless of how many times it’s called?

```
(def my-promise (promise (+ 1 2)))
(doto (Thread. (fn []
    (deref my-promise)))
  .start)


```
(def my-promise (promise (+ 1 2)))
(doto (Thread. (fn []
    (deliver my-promise)))
  .start)
(deref my-promise)

```
(def my-promise (promise))
(doto (Thread. (fn []
    (deliver my-promise (+ 1 2))))
  .start)
(deref my-promise)

```
(def my-promise (promise))
(Thread. (fn []
    (deliver my-promise (+ 1 2)))
  .start)
(defer my-promise)

Promises are quite similar to futures but have less potential because they don’t create their own thread. Which declaration of promises with threads is correct?

Promises are quite similar to futures but have less potential because they don’t create their own thread. Which declaration of promises with threads is correct?

Atoms capture the essence of sharing a single piece of information and keeping its state. What's the available function to switch its value?

Atoms capture the essence of sharing a single piece of information and keeping its state. What’s the available function to switch its value?

Let's recap some important information about concurrency and parallelism.

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: Concurrency and Parallelism Support