vincenzo-chianese

Vincenzo Chianese is an Italian Software Developer focused on Web APIs and User Interfaces. He has been working for the last years in API companies such as Apiary, Oracle, LunchBadger, Stoplight. Currently, he is working for Microsoft to help move Microsoft Graph forward and authored some open-source tools in the market (Prism, Express Gateway).

API Architect

Vincenzo Chianese

A high-level overview of Clojure, a functional programming language based on LISP and powered by the JVM.



In a [previous article](https://auth0.com/blog/refactoring-breaking-functions-apart-typescript/), we borrowed some concepts from [Clojure](https://clojure.org) and applied them to other programming languages (TypeScript in our specific example). In this blog post, we’re going to explore some rationales about Clojure itself and why you should give it a shot.

## Clojure History and Rationale
Clojure has been designed and implemented by [Rich Hickey](https://twitter.com/richhickey) as an attempt to solve the pain points he was having when writing [situational programs](https://www.youtube.com/watch?v=2V1FtfBDsLU). In particular, no matter the programming language, he would always end up with software requiring herculean efforts to make relatively minimal changes.

That is not that far from the situations a lot of us are living at our daily job.

On another project, he decided that the imperative approach was a misfit and tried to do things differently. By using immutable data structures and a custom-designed functional library, his team had a much more enjoyable experience, and the project was ultimately successful.

Functional programming was a win, but applying it in a language that’s not functional in the core felt cumbersome.

That sparked the idea of working on a language where functional programming would be at least the default approach and possibly, the only one.

Clojure is the result of all this. It’s a **LISP** **functional** programming language running on the **JVM** designed for **concurrent** programs.

We’re going to take a deeper look into all of these points but, for anybody interested in understanding more about the history and the rationale behind Clojure, the [10 years of Clojure paper](https://download.clojure.org/papers/clojure-hopl-iv-final.pdf) is a great resource to look at.

## How I Ended up Programming in Clojure
My history with Clojure is probably unconventional. 

I have been working in the Web API industry for the last six years. One of the struggles that we have been having since forever has been _caching_. Many APIs that I see on the market usually decide to pass on most of the caching opportunities rather than dealing with them correctly.

One day I found myself discovering [Datomic](https://datomic.com) while watching a talk recording. I was particularly interested in its immutability features that, from a caching standpoint, were very appealing to me.

There was only one (big) problem: Datomic can only be used from Clojure or Java or through a deprecated HTTP API because of its peculiar model.

Java was not an option for me, and whenever I was looking at Clojure code, I would just give up after 10 minutes or so of understanding the syntax.

One day I decided that I had enough, and I had to figure out how to write Clojure. I did some research, and I found a great [introduction video from Rich Hickey himself](https://www.youtube.com/watch?v=P76Vbsk_3J0) that I still consider to be the best resource to start with Clojure.

From there, I was finally able to experiment how caching would look like with Datomic, and consequently, I got more proficient. Ultimately I liked it up to a point where I thought it'd make a lot of sense to use it in my job.

## It’s a LISP
Clojure is a [LISP 1](https://en.wikipedia.org/w/index.php?title=Common_Lisp&oldid=402600249#The_function_namespace) — with some minor modifications.

That is usually enough to scare a lot of people and move on. The [number](https://i.redd.it/9gwghrz9rcs11.jpg) of memes about [LISP](https://onweb3.files.wordpress.com/2017/09/practical-nlp-with-lisp-27-728.jpg) says it all, but keep reading: we can figure it out.

While this is not going to be a Clojure guide, I want to be offering a 10k feet view of the language. I hope the Clojurians will forgive me for some inaccuracies in the terminology, but in the spirit of being pragmatic, I had to take some… poetic licenses.

### Fundamental data structures
Clojure supports all the atomic data types you'd expect from any other language: _integers, doubles, strings, booleans, keywords, symbols, null_ — with the unique additions: _ratios_ without precision loss such as [22/7](https://en.wikipedia.org/wiki/Proof_that_22/7_exceeds_%CF%80).

### Aggregates
Clojure supports lists `(1 2 3 4)`, vectors `[1 2 3 4]`, maps `{:name Clark :surname Kent}`, and sets `#{1 2 3 4}`.

LISP does not require commas to separate values. They are like whitespaces, but you still can use them if they make you feel better. We could rewrite our previous examples to be `(1, 2, 3, 4), [1, 2, 3, 4] {:name Clark, :surname Kent} and #{1, 2, 3, 4}`, yielding the same final result.

### Evaluation rules
That is 90% of the Clojure (and LISP) syntax, and it's all you need to start writing programs.

LISP indeed stands for **LISt Processing**: the basic idea is that the evaluator will receive nothing but data structures, and according to the evaluation rules, it will perform an action.

The golden rule, enabling a good chunk of functionalities in LISP languages, is that when the evaluator encounters a **list**, it will treat the **first** element as a symbol. It will try to resolve and "call" it with the other list elements as arguments.

For instance:

``` clojure  
(println "Hello")
```

This is a list containing the symbol `println` and then the string `"Hello"`.

When the evaluator encounters this, it will try to resolve the symbol in the first element. In this case, it's a function automatically imported from the `clojure.core` namespace. So, the resolution completes successfully, and the system will invoke its content and supply the rest of the list as the arguments to the function.

There are other [special forms](https://clojure.org/reference/special_forms) that the evaluator treats differently with respect to the regular evaluation rules. Still, generally speaking, you can think of the first element in a list as the command for the evaluator.

Let's go through some very common special forms:

``` clojure  
; Binds a value to a symbol and then prints it
(def value 3)
(println value)

; Binds a symbol to a function definition
(defn add [a b] (+ a b))

; Binds a symbol to a result of a function call
(def result (add 2 3))
```

I want to reiterate this one more time: all these are nothing but data structures. It is indeed possible to instruct the evaluator to avoid the default rule and treat the list as… a list by quoting it: `'(hello 1 2 3)`.

On the other hand, it is also possible to ask the evaluator to eval a list using the default rule: `(eval '(println "Hello"))`.

### Code is data, data is code
Most programming languages have their own syntax and grammar. Compilers then have a **lexer** that outputs a series of data structures that will then be used to create the byte code (or the assembly instructions, in the case of native compilers).

In Clojure (and LISP languages), there is no such thing as syntax. We are essentially writing the program directly as a set of data structures: the developer and the compiler speak the same language, with no translation involved. This concept is known as **homoiconicity**, and it is explained in detail in [this great talk by Stuart Sierra](https://www.youtube.com/watch?v=o7zyGMcav3c).

So what does "Code is data, data is code" mean, without being philosophical?

Well, if we really want to be pragmatic:

1.  All the code of a Clojure program is ultimately data structures.

``` clojure  
(defn -main [] (println (rand-int 10)))
```

This small program that outputs a random integer between 1 and 10 is nothing more than a list containing some data. Specifically, we are looking at a list whose elements are:

1.  A symbol: `defn`.
2.  Another symbol: `-main`.
3.  An empty vector.
4.  Another list.

The evaluator, with its rules, will turn that set of data into something executable.

Every list in Clojure can potentially be executed:

``` clojure  
(def code '(defn -main [] (println (rand-int 10))))

((eval code))
```

In this counterexample, we have the symbol containing some data, and we can ask the evaluator to execute it according to its rules.

This is also one of the principles behind [Datalog](http://www.learndatalogtoday.org), the database query language that is powering [Datomic](https://datomic.com).

Many interesting implications come out of this (for example, how easy it is to write [macros](https://clojure.org/reference/macros)), but this goes beyond the article's scope. 

<include src="TweetQuote" quoteText="In Clojure, code is data, data is code."/>

## Leaning to Functional
Clojure is usually categorized as a _functional_ language.

Now, everybody has his own definition of functional, and it's not my intention to debate it, so I'm going to say that Clojure _leans_ to functional programming, and we'll show why in this section.

### Immutable data structures
In Clojure, most of the data structures you work with are immutable and cannot be changed. For example, adding a new key to a map will return a new map.

``` clojure  
(def user {:name "Clark"})

(assoc user :surname "Kent")
```

The `assoc` function returns a new map instead of modifying the old value associated with the `user` symbol. Yet, it’s efficient and meets all the performance expectations of the regular data structures you'd find in other languages because of their clever [implementation](https://clojure.org/reference/data_structures).

The `let` macro can be used to create a new lexical scope with modified data:

``` clojure  
(def user {:name "Clark"})

(let [user-with-surname (assoc user :surname "Kent")] (

  (add-user user-with-surname))
```

### Multithreading

Immutable data flowing is immensely useful when writing multithreaded programs.

We are not going to go that much into detail, but a significant hassle of multithreading programming is due to resource access synchronization, which can lead to deadlock if not handled correctly.

That problem does not exist in Clojure. Because of immutable data structures, you have a guarantee that nobody will change the data while you’re using it. Even when a shared state is required, Clojure provides a [great story](https://clojure.org/reference/refs) to handle it.

Essentially, Clojure separates the  **reference types** (a label for something that can change) and the **values**.

It turns out such an approach is very effective and is the _opposite_ of what usually Object-Oriented programming languages do.

<include src="TweetQuote" quoteText="Clojure leans to functional programming."/>

## No Objects
Clojure rejects [the Object-Oriented model](https://clojure.org/about/rationale#_object_orientation_is_overrated) and considers it overrated and not particularly useful to the kind of applications we write these days ("situational programs").

Rich Hickey elaborates in great detail why objects might not be a good idea in his [*Simple made easy* talk](https://www.youtube.com/watch?v=kGlVcSMgtV4). There's also a [short clip](https://www.youtube.com/watch?v=aSEQfqNYNAc) that summarizes most of his frustration about objects. I do suggest to stop reading the article and watch this clip right now.

In Clojure, you have data and functions, and yes, you can create very sophisticated programs with a set of tools significantly simpler than the one we use today.

## Runs on the JVM and the Browser
Clojure was designed to be a hosted language since its inception. 

While originally conceived to run on both the JVM and the .NET runtime, its primary target is the JVM, but there’s a [.NET core version](https://github.com/clojure/clojure-clr/compare/newframework?expand=1) being worked on and not far from being complete.

This implies that Clojure has a good interop story, and it has access to all the superb number of components and libraries that the host can offer (whether it’s the JVM or the .NET).

Clojure indeed provides some special forms that can be used to deal with Java code:

``` clojure  
; Calling a static method on a namespace
(System/getenv) ; Same as System.getenv() in Java

; Creating a new object
(def n (new Integer 10)) ; same as new Integer(10) in Java

; Accessing an instance method
(. n toString) ; Same as n.toString() in Java
```

The opposite is also true. If your project is using Java, you can call Clojure functions:

``` java  
IFn plus = Clojure.var("clojure.core", "+");
plus.invoke(1, 2);
```

The Clojure website has an [interop reference page](https://clojure.org/reference/java_interop) where everything is explained in detail.

Additionally, Clojure [runs in the browser as well](https://clojurescript.org) via ClojureScript, a compiler that targets JavaScript.

## REPL
Some runtime environments offer a REPL (Read, Evaluate, Print, Loop) as part of the kit you’re downloading.

The basic idea is that — by running the runtime in REPL mode, you can send instructions from an external source — and not necessarily from a file — and get the results printed out on the screen as soon as the results are ready.

Clojure brings this concept to a new level, allowing you to run a remote REPL and expose it over a socket from your running program (even from a production environment) and interact with the system live while it’s up and running.

This comes to be very handy in case of debugging sessions but also during the day to day development. 

You can fix a function while your program is running without having to restart it and lose all the accumulated state.

To be fair, this feature is also available in [other runtime environments](https://nodejs.org/en/knowledge/REPL/how-to-create-a-custom-repl/), but Clojure has been the only language I’ve seen where this approach is the rule. Also, the tooling is crafted to encourage such an approach.

## Ecosystem
Every programming language is only as good as its own ecosystem. Components, libraries, and community are an essential part of a successful project, and Clojure is not behind.

### Community
Clojure programmers (aka Clojurians) hang out in a [slack channel](http://clojurians.slack.com) that is free to join. Some of their maintainers are actively monitoring it.

There is also a dedicated [forum](https://ask.clojure.org) maintained by the Clojure team and a number of [annual events](https://clojure.org/community/events).

I was amused to learn that, by using Clojure, I instantly had almost doubled the number of speaking opportunities I had. The JVM is a big deal.

### Deprecating policy vs. ended project
As a JavaScript developer, I am used to the idea that my projects' dependencies are updated almost on a daily basis, and “update day” is part of my weekly errands.

I was surprised to see that, generally speaking, that is not a thing in Clojure.

Seeing a library that hasn’t been updated for months or so is common, and that is not an index that the project has been abandoned or that its quality is bad.

In Clojure, libraries tend to have a really narrow scope: when the main aim has been reached, the project is _done_, and people move on.

I have never updated a dependency so far in my Clojure projects.

## What Is Not that Cool
Clojure is not all fun and games. In this section, we’re going to take a quick look at some parts that I personally do not like.

### Pleasing the compiler
Clojure’s reader is single pass, making mandatory for all the used symbols to be defined before they can be used

For example, the following code will not work:

``` clojure  
(add-numbers 3 4)

(defn add-numbers [x y] (+ x y)
```

On the other hand, its JavaScript counterpart will run because functions and variables get hoisted:

``` javascript  
addNumbers(2,3);

function addNumbers(x, y) {
  return x + y;
}
```

> **Note:** this is not true for arrow functions, but you get the point.

This little example shows the idea that the user has to please the compiler.  For somebody, that is not a big deal; for somebody, it is.

An example of an actual implication is how you organize your code: this forces you to put the most specific functions on the top of the file.

When reading the source code, it’s usually easier to reason about when the high level exported functions are on the top and then go deeper in implementation details as you scroll the file.

While this might be partially prevented by putting the functions on a different file and then importing them, that is not always a viable solution.

### The external world is still messy
Clojure has a very rich repository of libraries and components called [Clojars](https://clojars.org).

The issues come when you have to exit the Clojure “bubble” and import external code. Side effects, in place mutations, [death by specificity](https://www.youtube.com/watch?v=aSEQfqNYNAc) are back again, making it necessary to write a functional interface/wrapper to make it play nicely with the rest of your Clojure program.

In some cases, somebody has already done the work, such as [HTTP clients](https://github.com/dakrone/clj-http) or [JDBC](https://github.com/seancorfield/next-jdbc), but otherwise, you’re left to have to do the work.

<include src="asides/AboutAuth0" />

## Conclusions
I have been skeptical with Clojure for a while, mostly because I considered that LISP was not a syntax I was willing to learn.

I couldn’t be more wrong. Give Clojure a try. Regardless of whether you’re going to like it or not, it’s going to give you new ideas and make you rethink the way you write software.



Why Developers Should Look into Clojure

idee

Software Engineer building with Kotlin and Flutter.

Software Engineer at Busha

Idorenyin Obong

Learn how to build modern APIs with Kotlin, the flexible programming language that can run on JVMs.

Building GraphQL APIs with Kotlin, Spring Boot, and MongoDB

bruno-krebs

I am passionate about developing highly scalable, resilient applications. I love everything from the database, to microservices (Kubernetes, Docker, etc), to the frontend. I find amazing to think about how all pieces work together to provide a fast and pleasurable experience to end users, mainly because they have no clue how complex that "simple" app is.

R&D Content Architect

Bruno Krebs

Project Amber incubates smaller, productivity-oriented Java language features that have been accepted as candidate JEPs. Take a quick glimpse of the features that will arrive on the platform soon.



Recently, [Java changed its release cycle to a more rapidly cadence](https://www.forbes.com/sites/oracle/2018/03/20/what-java-10-and-javas-new-6-month-release-cadence-mean-for-developers/#7ed00d4a271a), affecting the way the language evolves overtime. With this new cadence, features can now reach the market faster. Besides that, this cadence enables the community to work on (and deliver) smaller features instead of expending all their energy on the big changes (e.g., lambda, generics, and modules).

Throughout the next sections, you will learn about Amber, the project that incubates small, productivity-oriented Java language features.

<include src="TweetQuote" quoteText="Stay on top of Project Amber and learn what productivity-oriented @java language features will arrive soon."/>

## Project Amber

Project Amber, [as explained on its homepage](https://openjdk.java.net/projects/amber/), is an effort focused on "exploring and incubating smaller, productivity-oriented Java language features that have been accepted as candidate JEPs under [the OpenJDK JEP process](https://openjdk.java.net/jeps/1)." At the time of writing, this project has already delivered two enhancements and is planning on delivering five more. Let's learn about these enhancements.

> Not sure what JEP (JDK Enhancement Proposal) means? Check out this article and [learn more about the Java platform and the community process that is responsible for evolving it](https://auth0.com/blog/java-platform-and-java-community-process-overview/).

### Enhancements delivered

The first enhancement already released, called [_Local-Variable Type Inference_](https://openjdk.java.net/jeps/286), was introduced in Java 10 and allows developers to reduce the ceremony associated with writing Java code while maintaining Java's commitment to static type safety. With this enhancement, developers can now declare variables like this:

```java
var list = new ArrayList<String>(); // infers ArrayList<String>
var stream = list.stream(); // infers Stream<String>
```

```java
List<String> list = new ArrayList<String>();
Stream<String> stream = list.stream();
```

The second enhancement, called [_Local-Variable Syntax for Lambda Parameters_](https://openjdk.java.net/jeps/323), was introduced in Java 11 and extends the _Local-Variable Type Inference_ feature by allowing `var` to be used when declaring the formal parameters of implicitly typed lambda expressions. For example, with this enhancement, if you write the following code:

```java
IntStream.of(1, 2, 3, 5, 6, 7)
          .filter((var i) -> i % 3 == 0)
          .forEach(System.out::println);
```

Java will have no problem identifying that the `i` variable is an integer.

### Enhancements being developed

Besides the enhancements already released, Project Amber is planning on delivering _Lambda Leftovers_, _Pattern Matching_, _Switch Expressions_, _Raw String Literals_, and _Concise Method Bodies_.

#### **Lambda Leftovers**

The [_Lambda Leftovers_ enhancement](http://openjdk.java.net/jeps/302) aims at bringing two new features to the Java language. First, this enhancement will allow developers to use an underscore (_) to denote an unnamed lambda parameter. Second, the enhancement will allow lambda parameters to shadow variables already defined in the enclosing context. For example, this last feature will enable developers to write code as follows:

```java
Map<String, Integer> msi = ...

String key = computeSomeKey();
msi.computeIfAbsent(key, key -> key.length());
```

In this case, the inner `key` variable will cause no conflict with the external one (derived from the `computeSomeKey()` call).

#### **Pattern Matching**

The [_Pattern Matching_ enhancement](https://openjdk.java.net/jeps/305) will allow developers to be more concise when dealing with the `instanceof` operator. For example, with this feature, whenever developers want to check if an object is a `String` and use it as such, instead of doing this:

```java
if (obj instanceof String) {
    String s = (String) obj;
    // use s
}
```

They will be able to do this:

```java
if (obj instanceof String s) {
    // can use s here
}
```

By using the new pattern matching feature, developers will reduce the overall number of explicit casts in Java programs considerably. For example, as type test patterns are particularly useful when writing equality methods, instead of having a method like this:

```java
@Override public boolean equals(Object o) { 
    return (o instanceof CaseInsensitiveString) && 
        ((CaseInsensitiveString) o).s.equalsIgnoreCase(s); 
}
```

Developers will be able to simplify the code (and avoid the explicit cast), as shown here:

```java
@Override public boolean equals(Object o) { 
    return (o instanceof CaseInsensitiveString cis) && 
        cis.s.equalsIgnoreCase(s); 
}
```

#### **Switch Expressions**

The [_Switch Expressions_ enhancement](https://openjdk.java.net/jeps/325) will enable developers to use the `switch` feature as either a statement (the _traditional_ way) or as an expression (the _simplified_ version). This change will simplify some code, as you can see on the following code snippets. The first one shows how you would use the traditional `switch` keyword to make a decision:

```java
switch (day) {
    case MONDAY:
    case FRIDAY:
    case SUNDAY:
        System.out.println(6);
        break;
    case TUESDAY:
        System.out.println(7);
        break;
    case THURSDAY:
    case SATURDAY:
        System.out.println(8);
        break;
    case WEDNESDAY:
        System.out.println(9);
        break;
}
```

The second one shows how you would use the simplified version to achieve the same result:

```java
switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> System.out.println(6);
    case TUESDAY                -> System.out.println(7);
    case THURSDAY, SATURDAY     -> System.out.println(8);
    case WEDNESDAY              -> System.out.println(9);
}
```

Pretty nice, huh?

<include src="TweetQuote" quoteText="The new Switch Expressions proposal will allow @java developers to use switch as expressions to write more concise code."/>

#### **Raw String Literals**

The [_Raw String Literals_](https://openjdk.java.net/jeps/326) enhancement will add, as the name states, raw string literals to the Java programming language. This type of string can span multiple lines of source code and does not interpret escape sequences, such as `\n`, or Unicode escapes, of the form `\uXXXX`. Among its goals, the enhancement plans on:

- make it easier for developers to express sequences of characters in a readable form, free of Java indicators;
- supply strings targeted for grammars other than Java;
- and supply strings that span several lines of source without supplying special indicators for new lines.

One good way to see the benefits of this enhancement is to consider what you would need to do to write a long SQL query:

```text
String query = "SELECT `EMP_ID`, `LAST_NAME` FROM `EMPLOYEE_TB` " +
               "WHERE `CITY` = ‘INDIANAPOLIS' " +
               "ORDER BY `EMP_ID`, `LAST_NAME`;";
```

By using _Raw String Literals_ you will be able to rewrite the previous code snippet as follows:

```text
String query = ``SELECT `EMP_ID`, `LAST_NAME` FROM `EMPLOYEE_TB`
                 WHERE `CITY` = ‘INDIANAPOLIS'
                 ORDER BY `EMP_ID`, `LAST_NAME`;
               ``;
```

#### **Concise Method Bodies**

The [_Concise Method Bodies_](https://openjdk.java.net/jeps/8209434) enhancement is all about supporting _more_ concise methods in the Java programming language. The Java 8 version, released back in 2014, introduced what is known as the [_Lambda Expressions_](https://jcp.org/en/jsr/detail?id=335) enhancement. This enhancement, known as Java's first step into functional programming, allowed developers to define methods that do not belong to any class. As such, these methods (which have a very concise syntax) can be passed around as if they were objects and can be executed on demand.

For example, prior to the Lambda Expressions introduction, if you needed to do some calculation and return an integer, you would have to find a class where to define a new method:

```java
public static class Utils {
  public static int calculate(Object someParameter) {
    // ... calculate
    return result;
  }
}
```

After that, you would be able to call this method whenever you wanted, after importing the `Util` class. With the introduction of this new feature, you can now replace all this boilerplate with something much simpler:

```java
ToIntFunction<Object> calculate = (Object o) -> {
  // ... calculate
    return result;
};
```

The code above, instead of belonging to some random class (like `Utils`, on the example), can be written and called right where you need it. This can be considered the first _concise methods_ introduced in the programming language.

Now, back to the _Concise Method Bodies_ enhancement that Project Amber will introduce, when this feature is released, developers will be able to apply this kind of syntax in more places. For example, if you ever did something like creating a method like this:

```java
int length(String s) {
  return s.length();
}
```

In the near future, you will be able to rewrite it like this:

```java
int length(String s) -> s.length();
```

## Conclusion

As you learned in this short blog post, Project Amber is the project that you have to keep an eye on to learn about the productivity-oriented features that will arrive at the Java programming language soon. If you want to stay on top of this, [follow us on Twitter](https://twitter.com/auth0), or subscribe to our newsletter.

<include src="asides/AboutAuth0" />


The Future of Java - Project Amber

332d7898dae6bc56031ac3507a0248ba

I'm a full-stack developer with a passion for technology and code. I love writing tutorials for developers to showcase a particular technology whilst building something useful at the same time. Right now  I can mostly be found developing for the front-end, playing around with Docker, or tinkering with Unreal Engine and electronics!

Developer Experience Engineer

Steve Hobbs

Learn how to build APIs with Scala and the Play Framework, and secure them using access tokens.

Build and Secure APIs with Scala and the Play Framework

avatar

Guest Author

Sathyaish Chakravarthy

Learn how to create a simple application using Kotlin, a statically typed programming language that targets the Java Virtual Machine (JVM)

"jvm"