Clojure for Java developers: What you need to know

Clojure is one of the most fascinating branches of the programming family tree. It unites the high-design heritage of Lisp with practical, modern capabilities. For Java developers, Clojure can be an excellent expansion of their worldview. It offers an entirely different way of understanding and solving problems, while still running on the JVM and interoperating with Java.

The four key concepts of Clojure

The following four concepts are vital for understanding Clojure:

Code as data

Functional programming

Immutability

Concurrency

Let’s look at each of these in turn.

Code as data

The most remarkable thing you might notice when coming to Clojure from Java is that it is homoiconic, which means the code is written in the form of the language’s data structures. This practice, also known as code as data, results in very consistent syntax with a limited number of keywords and constructs. It also creates a meta-programming model using “syntax-aware” code templates (called macros).

The idea is that any snippet of Clojure code is also an instance of Clojure data. You will see this most frequently in the list syntax, because most of Clojure is written as lists. Here is a simple “Hello, InfoWorld” function in Clojure:

(defn hello-infoworld []
(println 'Hello, InfoWorld'))

The parentheses indicate a list in Clojure. So, the definition of this function is essentially just the definition of a list with a keyword (defn), a function name (hello-infoworld), an empty argument vector ([]), and the function body. The function body is also a list containing a function call (println) and the argument to that function (“Hello, InfoWorld”).

A list literal (defined with ()) is also how we define functions in Clojure. The [] vector is used specifically for data, rather than code execution, and is similar to the Java ArrayList.

Functional programming

Java has gradually become more versatile as a functional programming language, but Clojure was built from the ground up with functional programming principles in mind. In Java, the core concept is the object, whereas in Clojure it’s the function. In functional programming languages, the function is the most fundamental block of reusable functionality, and functions are first-class citizens that can be referenced with variables, returned as values, and passed as arguments (also known as higher-order functions).

In object-oriented programming, you combine state and behavior into objects. This is a very natural and intuitive model, and easy to understand. But as a software system becomes more complex, it can produce unexpected difficulties. These “programming-in-the-large” drawbacks have made functional programming more popular over time. It can be more challenging, initially, to grasp functional programming concepts, because you don’t have the object model to conceptualize with, but they are well worth learning.

Clojure is a great language for learning functional programming. For example, here is a (contrived) example of a function that takes another function as an argument:

(defn formal-greeting [name]
(str 'Greetings, ' name '.'))

(defn informal-greeting [name]
(str 'Hey, ' name '!'));; A 'higher-order' function:
argument
(defn greet [greeting-fn name]
(greeting-fn name));; --- Using it ---

(greet formal-greeting 'Dr. Smith');=> 'Greetings, Dr. Smith.'

(greet informal-greeting 'Alex');=> 'Hey, Alex!'

In Clojure, anything after a semicolon is not parsed, but used for comments. So, the;=> is just a conventional way of noting the return of the function call. It’s also important to know that at the end of a function, the final expression is evaluated as the return value (so no “return” keyword is used). With these two points in mind, the above code is relatively easy to understand.

Read next: The top 4 JVM languages and why developers love them.

Immutability

The Clojure documents reflect a programming philosophy that has been deeply thought out. Here is what the documents have to say about immutability, or the separation of identity and state:

We need to move away from a notion of state as “the content of this memory block” to one of “the value currently associated with this identity”. Thus an identity can be in different states at different times, but the state itself doesn’t change. That is, an identity is not a state, an identity has a state.

A later statement in the document makes the point more concretely: “In Clojure’s model, value calculation is purely functional. Values never change. New values are functions of old, not mutations.” What this tells you is that functions are designed to accept and return values, not identities. That is different from object-oriented languages like Java, where objects are often passed in by reference, meaning the function can operate on the state of the object, creating side-effects, or effects on something outside of the function’s return value.

In Java, running the same function with the same input (the object reference argument) can produce different results, because the object’s state can be different. In Clojure, we avoid this possibility because functions only take or return values or other functions.

Clojure also uses immutable operations where data structures are commonly recreated to produce changes, instead of inline mutations like Java often uses. (This may sound inefficient, but Clojure is designed to handle this by sharing structures.)

Here is an example of adding to a collection:;; `original-numbers` is an identity with the value `[1 2]`
(def original-numbers [1 2]);; The `conj` function returns a NEW vector.
(def new-numbers (conj original-numbers 3))

original-numbers;=> [1 2] -- Unchanged original collection

new-numbers;=> [1 2 3] -- A new collection with the joined values

The new part here is the conj function, which is Clojure’s universal mechanism for adding elements to a collection. It works for lists, sets, and maps. Here, we’ve just added 3 to the existing [1,2].

Because of Clojure’s immutability principle, this code creates a new Vector. This is because the original-numbers variable is an identity, which does not ever change. You can use the identity to produce new identities with new values based on it, but you can’t change it.

In Clojure, there is no direct reassignment of variables like there are in Java. Variables are created with an initial value, or they are produced by function results.

Concurrency

Concurrency is one of Clojure’s main goals. Immutability helps to make it simpler, but eventually we still need to deal with shared state, where many threads may access the same memory concurrently. Clojure includes several powerful concepts for managing shared state:

Atoms: A simple mechanism for allowing a single value to be accessed safely by multiple threads. The developer just defines a normal function, and Clojure handles all the locking under the hood (though technically, it’s not locking, but “compare-and-swap” or CAS).

Refs: A sophisticated “software transactional memory” system that allows for transactions on shared values, with commit and rollback operations similar to those in databases.

Futures: A simple mechanism for offloading a chunk of work to another thread and retrieving the value at a later time.

Promises: A way to wait for the completion of an asynchronous task executing on another thread.

Clojure is suited for all kinds of concurrent programming, from very simple to highly advanced. Here’s a simple example of how we might use an Atom to handle a multithreaded counter value:;; Create an atom to hold the counter (initially 0)
(def counter (atom 0));; Define a function for one thread's worth of work;; `swap!` atomically applies the `inc` function to the atom's value.
(defn do-work []
(dotimes [_ 1000]
(swap! counter inc)));; Use `future` to run our work on two separate threads
(def thread-1 (future (do-work)))
(def thread-2 (future (do-work)));; Dereferencing them with @
@thread-1
@thread-2;; Read the final value of the atom
(println 'Final count:' @counter);=> Final count: 2000

In this snippet, the @ character is syntax for “dereferencing” the threads, which in essence means to block on them, waiting for their completion (the completion of the futures).

The built-in swap! function and atom variable work together to safely allow mutating the state of the counter across threads. swap! and its related reset! function are special (as denoted by the exclamation mark), tasked with handling thread-safe access to the atom container.

The future function lets us run the work on a worker thread. The overall effect is easy to follow, and an effective use of multithreading with a single shared variable.

Conclusion

Clojure is a different way of thinking about programming, but it is a fully realized platform that offers a powerful conceptual and practical approach to modern software. This article touched on only the most fundamental aspects of Clojure. There is much more to discover, including the REPL interactive development command line and excellent, higher-level Clojure libraries used for common needs like web and enterprise development.