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).
(defn conf-highlights  (str "SOME THOUGHTS, YEAH")) (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?
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.
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:
http://fn-code.blogspot.com/ (blog of a talk not discussed, but mentioned in the videos I recommend)
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!