Skip to content

Clojure Conj highlights

I have a bunch of notes jotted down from Clojure Conj, the conference I went to this week despite having never written a Thing in Clojure (but I did learn Common Lisp this year, so I could read pretty much everything).

It’s interesting to go to a conference as a “new” person, and Clojure Conj felt particularly okay with having lots of hobbyists and curious folk in the crowd – for example, I don’t imagine asking someone “So, do you use JavaScript at work?” at a JavaScript conference, but the same question was common at the Conj.

(defn conf-highlights []


Conj? Did they keyboard-mash the “f” in “conf”? No … it’s a Clojure joke, conj is a function in Clojure, used to add data to a list or vector. Puns, right?

Popular topics

If I had to take away a few things, things that I heard multiple times, it’d be:

“Graphs are life” (probably a reference to Dune). In a few talks, graphs as a data structure (particularly over trees) were hailed as the savior for performance and simplicity.

“Data First” Not surprising, given Clojure as a functional language, but still, data as the first-class citizen is a common topic.

“Hot loading is awesome” Where “hot loading” is known in some circles as livereload, or the like. Interesting, because this technique is generally around, but generally a demo was followed by applause. Takeaway: This is important and/or cool, and we (the industry) should be doing it as a norm, most likely.

“We heart Elm” The language Elm was mentioned a few times, for their app architecture, their fantastic errors, their great docs … Clojure-ville has a crush on Elm.

Various gathered takeaways

The section in which I mostly transcribe my notes. Notes significantly degraded over time, as my brain got more and more tired.

Old things are always new! The first two talks were on finite state machines (termed automata in this context), macros, parsing expression grammars (PEGs), and errors. I found it interesting, because these are general computing topics but in Clojure-ville! Helpful for me, being not-fluent in Clojure.

In the talk on automata, aka our old friend the finite state machine, there were a few puzzles on constraints-based programming, and that by using propogators in particular, impossible values can be removed (given some constraints), and using automata can make the process really fast.

The second talk was on better errors, but really covered macros, PEGs, and parsing. One of the issues with errors is that they often occur within the macros, and the errors come from the macro and not from the application code that caused the problem (red herrings!). The speaker recommended the Illuminated Macros talk (video), the paper Fortifying Macros, and a post from the Elm language on better compiler errors. Errors are a popular problem in Clojure, and this talk made the point that things could get a lot better.

Now for the rest of my notes, in order, but skipping a lot of talks.

I really enjoyed the “Clojure Script for Skeptics” talk, particularly how the speaker showed some JavaScript developers valid ES6, claiming it was ClojureScript, and only a couple people called him on it. This is something I find interesting on the “target” JS languages (where they compile to browser-friendly JS) – with ES6/7 requiring a transpiler, languages like ClojureScript have a much better chance of gaining ground. He made a lot of good points and did a lot of myth-busting. Also I have “cross module code motion” in my notes but f#$ all if I know what that means right now.

Debugging with the Scientific Method was great! Includes such gems as “Debugging is more like science than science.” I appreciated it as a well-said articulation of what some engineers do. I also know this is generally how I almost always approach production debugging, but I might be guilty of not using this method as often when working on “regular” bugs. The speaker recommended this (free!) course on Udacity on debugging, on which much of the talk was based.

Links from talks not aforementioned:

Learn Onyx (blog of a talk not discussed, but mentioned in the videos I recommend)

Om Next

Recommended videos

The conference got videos from the conference up heroically fast. Like, later that day fast. Wowza! So here are some video links for those I’d recommend.

ClojureScript for Skeptics – video

Bottom Up vs Top Down Design in Clojure – video, good for beginners interested in a functional programming approach

Debugging with the Scientific Method – video

Lightning Talks – video (especially if you have a short attention span. First and third were especially good, on NLP and “cloud orchestration” respectively)

From REST to CQRS – video, I liked this talk, but I couldn’t tell you what exactly I learned. From this morning (like I said, posted heroically fast), so I may still be processing. Let me know what you think of it!

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.