Posted by on Nov 22, 2011

Like many great conference, the story of the 2011 Conj wasn't limited to the regularly scheduled program. In fact, some of the most meaningful conversations and demos occurred in between talks and after hours. In this post I'll discuss some of the interesting side discussions that I participated in or heard of secondhand.

Day 1


What started as a Google Spreadsheet turned into an after-hours unconference worth the price of admission. What amazed me is that every extra activity was fueled by passionate people willing to sacrifice their time to make something great. I've been to many a technical conference that didn't have half the passion of any given Conj BoF.

cKanren - William Byrd and Daniel Friedman

Would you believe that one of the best talks of the Conj:

  • Was related only tangentially to Clojure
  • Involved a ton of Scheme
  • Was not an officially scheduled talk

The lion-share of excitement at the Conj revolved around David Nolen and Ambrose Bonnaire-Sergeant's super library core.logic that implements a variant of miniKanren with disequality constraints. In fact, it's the very development of this library that prompted David to contact Willam Byrd and Daniel Friedman about his work. Through some mysterious sequence of events both Drs Byrd and Friedman decided to attend the Conj and ultimately give an impromptu demo of their new research in the field of relational logic with constraints called cKanren.

Their demo was quite amazing, especially a logic program that generated the results of a tiny programming language. For example, imagine a tiny programming language named Fojure that consists of numbers and the forms let, +, and fn. A snippet of this language could be fed into the logic system and produce a result:

    (let [x 2 y 3] (+ x y))
    ;=> (6)

While this is interesting by itself, the truly interesting demo was the execution of the tiny language in reverse! For example, given the answer 6, the system was able to generate the programs that satisfied the answer:

    ;=> ((let [x 0] (+ 6 x)), (+ 1 2 3), ((fn [x] x) 6)) ...)

All the programs listed would provide the requested solution 6. It was interesting the see how the system would generate some results (like the last in the list) that were clearly 'cheating', but still satisfied the constraints of the system. The room of ~60 people were aghast at the ridiculous power on display. Stuart Halloway laid down the gauntlet and asked if such a system could be created that found legal quines. The following day William Byrd gave a demo of just such a system to a half-dozen (I was not in attendance unfortunately) lucky souls. Crazy crazy stuff.

One final note about this talk is that the interplay between Byrd and Friedman was as entertaining as the technical content itself. They clearly know each other very well and make a great team. Nothing is more impressive to me than brilliant people with a great sense of humor.

Literate programming

Tim Daly, the maintainer of the Axiom computer algebra system and an open advocate of literate programming held court to a room of about 15 programmers. I too am interested in LP in the abstract and have attempted it in piecemeal. My original intent with Marginalia was to build a full LP system, but stopped at a docco-esque experience once it was adopted by a few dozen projects. Mr. Daly originally scheduled a 15 minute time slot, but talked passionately for at least an hour. I must say that much of what was said is compelling, including:

  • LP as a way to capture the knowledge learned in the process of developing a system
  • LP as a way to ease the transition of new team members
  • LP as essentially the book writing process

I will probably try the full LP experience soon for one of my personal projects. I have many old C projects laying around that I would like to try to resurrect; I suspect LP might be a nice way to do just that.

Clojure web stuff

I was not able to attend Chris Granger's Clojure web talk, but I did peek in for a few moments toward the end. There seemed to be a large crowd listening intently as Granger held court. I feel sad that I was not able to have a chat with Granger, but I did take a moment to express my awe at his incredible output. He needs a catchphrase.

If you attended this session, I would love to hear from you in the comments.

Clojure tooling

Tooling is an utterly thankless job. Great programmers like Phil Hagelberg (Leiningen), Justin Balthrop (Cake), Laurent Petit (Counterclockwise), Chas Emerick (nREPL), George Jahad (CDT), and Meikel Brandmeyer (vimclojure) are devoting much time to a (seemingly) thankless job. Tooling is the next great frontier for Clojure and the efforts of these pioneers will be of the utmost importance.

I was also not able to attend this session but I did learn afterward that the seeds of a Leiningen and Cake merger were sown. This is great news.

If you attended this session then I would love to hear from you in the comments.


ClojureCLR lead developer David Miller has been extremely busy lately. In preparation for the Conj he conducted a survey about Clojure on the .NET platform and discovered that the ClojureCLR interest is less than that of the JVM (as expected), but the interest in the project is significant. There was meant to be a break out session on the state of the project, but I missed it. I do not have a need for ClojureCLR in my own work, but I very much would love to see it gain a foothold in that market. So far the project has been the Herculean effort of one man taking the initial code created by Rich Hickey. For the project to succeed it will need more involvement than that.

If you attended this session then I would love to hear from you in the comments.


There were other sessions that I didn't attend and didn't have a chance to learn more about them, including: Pallet, Dependency Injection, Overtone, and a musical jam session.

If you attended any of these session then I would love to hear from you in the comments.

Day 2

Counterclockwise by Laurent Petit

Counterclockwise is currently the most promising of the "graphical Clojure IDEs." Laurent Petit gave a brief demo after the second day's main talks and the evolution of the project looks very promising. The Eclipse IDE was my first Clojure dev environment before I moved on to Emacs, but I still would love to see the major success of this project. It has passionate and smart people working on it; so that's always a good thing.

The Hallway Track

There were innumerable conversations during the Conj, far too many for me to horn my way into, however a few common themes emerged:

Leveraging the ClojureScript compiler

The analysis pass of the ClojureScript compiler is incredibly compact (~500 lines) and clearly written and many a dev was planning to use it for their own projects. There were ideas from using it to produce ASTs from Clojure targeting various languages, including: Java, Lua, and Clojure. I too have my own plans for the ClojureScript compiler, but I can't wait to see how others abuse... I mean use it.

Using Overtone as a first step toward world domination

Many people were (and continue to be) excited to get their hands on Overtone after Sam Aaron's talk; myself included.


The buzz around core.logic was deafening and I suspect that Amazon's stock of The Reasoned Schemer was seriously depleted during and after the festivities. David Nolen, plans to extend core.logic to include the constraints capability as demoed by Byrd and Friedman.

What were you talking about in the hallway track?

Day 3

Lightning Talks

The Conj also had a lightning talk session on the third day. Below are recaps of the talks.

Monotony by Alex Redington

Alex Redington gave a brief summary of his Clojure scheduling library called Monotony. He started the talk with a series of questions: 1) Who thinks Cron stinks? 2) Who's tried to fix it? The number of hands for #1 was fairly high while the hands for #2 quite small. Monotony is Alex's attempt to provide a more fluent system for time scheduling. The examples on his project's README are compelling.

Immutant by Jim Crossley and Toby Crawley

Simply put, Immutant is a polyglot app server built on JBoss AS7. The goal is to provide the same scalability guarantees with messaging, caching and clustering found in typical enterprise frameworks. Their conceptual model (and one that appeals to me professionally) is to support JRuby as the front end communicating with Clojure on the back-end, although the overarching goal is to support any Java.next language.

UberLisp by Alan Dipert and John Distad

REPL-driven blinkenlights are the killer app for Dipert and Distad's UberLisp; an ultra-tiny Lisp for the Arduino microprocessor.

Korma by Chris Granger

I first heard of Chris Granger from a front-page post on Hacker News a few months ago about his "I will build your prototype" initiative. I thought his approach was brash, reckless, and frankly totally awesome. Since that time he's somehow managed to produce: a server-side web framework Noir, a client-side web framework Pinot, the first ClojureScript browser-connected REPL brepl, and now a SQL generation library Korma. It's currently unclear how our yellow sun interacts with his alien anatomy to produce these superpowers.

In the few minutes that Chris had, he talked about his latest project Korma that provides a way to compose Clojure clauses in a fluent way to represent and generate SQL queries and relations.

Browser-connected REPL by David Nolen

David Nolen took some time after the talks on day 3 to demonstrate the ClojureScript browser-connected REPL (as previously demoed by Brenton Ashworth in the video below). David has been the biggest advocate of the BCREPL, and he was gracious enough to give an off the cuff demo to a large crowd.

ClojureScript browser-connected REPL from Brenton Ashworth on Vimeo.

The reception was fairly positive, but that is a tough time slot to give a talk about an alien technology.

Clojure/dev discussion

The final session of the Conj was a meeting of the Clojure/dev members (effectively, those who've signed a contributor's agreement), although anyone could attend. The mainline talk centered on the need to make Clojure as near to frictionless as possible for contribution. The current Jira-based system, while better than what we've had to work with previously has some shortfalls that make it not optimal for tracking patches. The consensus was to move forward in an attempt to fix that issue and outline a process by which people can go from proposal to patch as quickly as possible. One nice point in the Clojure/dev session was the recognition of Sean Corfield for his efforts in helping clear the dust surrounding the new clojure-contrib libraries changes that happened for the 1.3 release. The transition has been painful, but thanks to great work from Sean and Stuart Sierra, there is much more infrastructure and information in place to help clear the air moving forward.

In all, the extracurricular activities were top quality, and I look forward to seeing what happens next year.


blog comments powered by Disqus