The Clojure learning curve

I love Clojure.

Once you have tried it and enjoyed its advantages, you just don’t want to go back. But those same qualities that make you love it can make it easy to forget that, for someone who’s first encountering it, Clojure can be a threatening, scary area far outside their comfort zone.

A few weeks ago I gave a talk at the Bucharest Functional Programming Meet Up. The title was Clojure All The Way Down, since my initial plan was to focus on how to program web applications completely in Clojure (both the browser client and back end), and what it brings to the table.

Two things happened as I prepared the talk.

First, I found out most of those who had signed up to attend only had a passing familiarity with the language. Second, I had an exchange with a friend of mine who’s just going through the initial learning curve himself. It made me realize that there can be aspects of the learning process that can trip even dedicated developers.

Mainly: it’s easy to disregard that you’re not just learning a new language, you’re learning new semantics.

I then retooled the talk to acknowledge that yes, Clojure can be scary, and that you shouldn’t just approach the learning process as if you were going from one object-oriented programing to another. The bulk of my time went to highlighting a learning path, as opposed to a methodology, and warn people in advance about the bumps they can expect along the road - all while keeping in mind the payoff.

You’ll find the talk recording below.

There’s also the slides on SpeakerDeck, which you can use to follow along - they’re meant to complement the talk, not substitute it:

As an addendum, the original subtitle of the talk was Finally an useful LISP, since a sub-theme of the talk was why I had finally found a LISP that I could use on a daily basis, instead of remaining an appealing but impractical language. While I ended up removing that subtitle it still made it to the meet up page, which sparked a bit of a row online.

That subtitle was not just meant to be incendiary. Let’s not forget that, as technologists, we can be attracted to a language or platform from an intellectual standpoint, but that doesn’t mean we are going to have regular, practical uses for it. It was instead meant to convey that I had finally found one that was personally useful.

In slightly under two years, I have used it for sensor data processing, extending pre-existing systems, creating Chrome extensions, doing shell scripting, and building web applications. Clojure fit every one of these domains perfectly well, while also removing a whole class of errors and making parallelism trivial. Combined with React, it has even managed to make enjoyable the process of writing front end applications, something I had always disliked and avoided.

Nevermind other members of the LISP family, whose platform insularity meant I’d only been able to put them to work them in very specific contexts - that makes it more useful than any other language I had used before.


Ricardo J. Méndez