Clojure Start Time in 2019

I started with Java. Remember Java?

public class HelloWorld {
    public static void main(String args[]) {
        System.out.println("Hello, world!");
    }
}

Oh public static void, how I’ve missed you. Once a mere bit of technical jargon, you’ve become an evocative description of the world we live in.

Ahem.

Compiled with javac HelloWorld.java and invoked as java -cp . HelloWorld, this ran in a couple hundred milliseconds.

This is where things start to get interesting. ClojureScript has been capable of self-hosting, i.e., compiling itself, for some time now. With the rapid growth of JavaScript-based tooling, there are now multiple options for running ClojureScript as a standalone process without a JVM.

Here things get even more interesting. These projects are not built on either Clojure or ClojureScript, but aim to be source-compatible with some subset of “Clojure” the language.

Going even further afield, these projects do not necessarily aim for compatibility with “Clojure” but are inspired by it to varying degrees.

But wait, there’s more! With GraalVM it is now possible to compile Clojure(JVM) all the way down to a native binary. Babashka uses this for its own mini-Clojure interpreter, but we can theoretically compile any Clojure program into native machine code.

I made another trivial “Hello world” program and compiled it via the lein-native-image plugin. It took a couple of tries, tinkering with the native-image configuration, and I had to downgrade to Clojure 1.9.0 because of a known compatibility issue with 1.10. But it worked, and the result was comparable to other native-compiled code: under 10 milliseconds.

My final project.clj looked like this:

(defproject example "0.1.0-SNAPSHOT"
  :dependencies [[org.clojure/clojure "1.9.0"]]
  :plugins [[io.taylorwood/lein-native-image "0.3.1"]]
  :native-image {:name "example"
                 :graal-bin "graalvm-ce-java11-19.3.0/Contents/Home/bin"
                 :opts ["--verbose"
                        "--report-unsupported-elements-at-runtime"
                        "--initialize-at-build-time"]}
  :main example.core)

Just for kicks, I decided to compare the native-compiled options (Ferret, GraalVM-compiled Clojure) with actual native code written in C.

I dusted off enough memories to crank out a “Hello world” in C:

#include <stdio.h>

int main() {
  printf("Hello, world!");
}

Compiled via GCC with no special options, it ran in about 4 milliseconds.

Given the imprecision of these benchmarks — I’m just using time in a shell — I’d guess that anything under 10 milliseconds is lost in the noise. That puts Ferret and GraalVM-compiled Clojure in the same category as C, with Babashka only a few milliseconds late to the party.

Think about that for a minute: these are Clojure programs that start as fast as C.

Once again, this is not a realistic benchmark, but here are my results.

For each runtime, I ran it 3 times as a warm-up, followed by 3 measurements. I took the real time measured by Bash time. The 3 measurements were consistent in every case; this table gives the averages:

Java, Ferret, GraalVM-compiled Clojure, and C are compiled ahead-of-time, all others are interpreted or JIT-compiled from Clojure(Script) source.

Obviously, this is not in any way a fair comparison. Please don’t tweet some stupid, clickbait headline like “Joker 30x faster than Clojure.” “Hello world” is a silly benchmark for a programming language in general. But for certain specific use cases, like command-line scripts integrated into a larger process, the total execution time of a tiny program is something you might actually care about.

The point is, there’s a version of Clojure that fits almost any use-case you can think of.

If you want to write command-line utilities in a language that feels like Clojure, Joker and Babashka are both good options.

If you want the full power of ClojureScript but not the start-up cost of the JVM, Planck and Lumo are there for you.

If you need to work with Python but can’t bear life without S-expressions, check out Hy.

And if for some reason you are determined to write Lisp for an embedded microcontroller, Ferret has got you covered.

Finally, while GraalVM is still new and somewhat experimental, it’s going to be a game-changer. My compiled “Hello world” image is only 7.6 MB, and let’s not forget that’s with “real” Clojure and (some of) a real JVM!

I’m even more interested to see what happens when people combine these technologies in novel ways. Imagine a serverless application that starts a GraalVM-compiled binary for quick responses during cold-starts, then switches to a regular JVM for higher throughput once it’s warmed up. Better yet, imagine a deployment platform that could hide that difference from your application code.

Back in 1995, Java was pitched as “write once, run anywhere.” For the past twenty years or so, that mostly meant “write once, run on any machine with a fast CPU and several GB of memory where you don’t care about start-up time.” But that’s changing. We’ll probably never achieve “write once, run anywhere” for any arbitrary program. But these projects prove that we can write some program that runs almost anywhere using the same language we enjoy on the server.