Betting the Company on ClojureScript

Joy of Lisp.

Ten years ago myself, Ray McDermott and Kristof Sajdak fell in love with functional programming; we marveled at its ease of expression, simplicity, and immutable data structures.

After reading the now classic Structure and Interpretation of Computer Programs, this only made functional programming more attractive. It seemed to be what we had been missing in the typical enterprise landscape, which at that time, was full of Java and .Net. It was a literal where have you been all my life moment as the beauty of it struck a chord with all of us.

From there, we never looked back – with our eyes now wide open, we had seen the promise of the future, and the current languages just wouldn’t cut it any longer. Outside of our world, other factors that contributed to functional languages’ perfect timing for emergence included:

  • Moore’s Law was topping out
  • Lower cost multi-core CPUs were now mainstream
  • Parallel architectures were appearing, and
  • Jaded developers, were frustrated with their languages

Martin Odersky’s Scala programming language was the subject of significant press attention and turned many people like us onto the possibility of using functional programming for the enterprise, but it wasn’t quite right, it was’t a Lisp.

Hello Clojure.

(ns hello-clojure.core)
(defn -main [& args]
    (println "Hello, Clojure!"=))

Around this same period, Rich Hickey’s Clojure came to our attention, with the simplicity of Lisp, a REPL, immutability and, critically, first-class host language interop. With Interop, we were no longer in a walled garden that restricted so many other, purer implementations. Rich’s pragmatic choices and the resultant capabilities of Clojure ticked all the boxes. It also seemed to do the impossible: re-invigorating and exciting the development teams.

We started using Clojure where we could and where it proved viable. Areas where we identified uses were primarily in applications where there was little or no existing code in place and no overriding requirement to adhere to a corporate standard. No going back now, we were all in.

Enter ClojureScript.


(ns todomvc.views
  (:require [reagent.core :as reagent]
            [re-frame.core :refer [subscribe dispatch]]
            [clojure.string :as str]))

ClojureScript goes everywhere; it can get to places that Clojure can’t go. It does this by piggybacking on the reach claim from JavaScript, and we can keep it functional.

We want our product to be able to reach any possible location, inside a car key fob, IoT devices, smart homes, and cities. ClojureScript is now mature enough to use everywhere, but it wasn’t always this way of course.

Looking back to 2010, I wanted to go way more mobile, and I had a desire to make the companies’ tech more ubiquitous for it to be deployed on iOS/Android/Tractors/Cars and we couldn’t do this in a functional programming way. Ray was using Clojure on Cloud PaaS and Web, continuing to leverage the JVM and Clojure to achieve great things. Kristof and I worked on making connected cars “Restful” and idempotent, and JavaScript & JSON made that happen for us; there just wasn’t a way to do this with functional programming.

As good as Clojure was we couldn’t use it where we wanted and felt like it was a vast chasm to cross for the reach that we desired to become a reality.

What we didn’t know then is that two future members of our team where actively solving this problem.

Mike Fikes built Goby, a hybrid iOS app technology using ClojureScript and Objective-C and released it into the App Store. I understand that Facebook’s Lee Byron saw this, and it probably inspired Facebook towards going in this direction. Coincidently, David Nolen was asked by Facebook to speak at the React.JS conference around the same time. This led to both Mike and David being granted access to the React Native Github repository, which was closed to the public as it was still alpha. Subsequently, Mike became the first person to get ClojureScript working with React Native.

Separately & together Mike and David worked on projects such as:

They blazed a trail that we now take for granted.

We came into Vouch with a long-held belief of consuming technology where no competitive advantage was needed and where differentiation is not a critical factor; this allows us to move quickly without us needing to become experts in commodity technologies.

Therefore we stand on the shoulders of many industry giants. Examples of this would be Figwheel, created by Bruce Hauman, which has revolutionized the way we build UI, and Blockchain, and provided a way to create absolute trust. To make our platform work with these great technologies, we needed flexibility and modularity for our technology.

Our approach has always been to use the right tool for the right job, first and foremost, it just so happens that that has been ClojureScript.

Attracting World-Class Talent.

We started Vouch with a core team, myself, Ray and Kristof, who had worked together for many years before Vouch. We quickly came to a point where we needed to expand the development team with skilled engineers who shared our vision and passion for building the company we wanted to create.

A company’s product vision, culture, and outcomes are not the only considerations for attracting world-class engineers to join a team; technology choices are just as critical, which has been one of my maxims for success over the years:

Great people want to work on great teams using great technologies, to build great products.

While our team shares a common interest in Clojure/ClojureScript, more importantly, we all wanted to work within a great team, using great technologies, to build great products.

The team is growing and attracting seriously world-class talent faster than we can onboard them. It might just be the best problem I have ever had to solve for. Recently Mike commented, “Wouldn’t it be great if we could build a team that could make all the tools we wanted to use to develop our products?”, I could not have agreed more.

Community.

The Vouch team began getting deeper into the Clojure community by first attending and then speaking at conferences. Ray started to host the DEFN podcast, which led to an introduction and later joining of Mike Fikes to the Vouch team. Mike then introduced David Nolen who subsequently joined the team.

ClojureScript is here to stay, loved by the team and obviously, we have David and Mike who are the lead committers of the language and compiler respectively. Ray hosts the DEFN podcast and also started Apropos. Our team speaks publicly and regularly at ClojureScript or related conferences. We invest in this language, we craft solutions using its strengths, we speak publicly about it, we educate people about it and most of all, we care for it.

So are we actually betting the company on ClojureScript?

In just 18 months with a small but highly skilled team, we have been able to conceive of, prototype, design, build and implement a breakthrough product that we believe will fundamentally alter the way that people, devices, software and processes interact digitally based on improving trust between those parties. I can honestly say that ClojureScript has been a substantial contributing factor to making this possible and in many ways, our product has become a poster child for the language.

ClojureScript is one of the most valuable tools available to us, and we use it where it makes sense to do so. I’m not sure if we even consider this as a bet, but if it is, then it’s the safest bet we will ever make.