By the way fellow Clojure enthusiast: Clojure/West is coming up March 16-17th in San Jose, CA including keynotes by Rich Hickey and Stuart Halloway! Regular registration rates end Feb 17th.

Here’s the raw data:

The first 4 columns above are the actual votes. Votes was the number of votes cast (I added a couple after the start). Score is my own concoction: +2 points for emphatic yes, +1 point yes, -1 point for no, and -2 points for opposite. That yields a score, which I scaled by the number of votes in the last column. I then sorted by the last column. All data here.

So, glean from this what you will. Some other suggestions that did not make it into the poll:

• Pure functions over procedures
• Declarative over steps [me: imperative?]
• Semantic clarity over syntactic clarity
• Simplicity over complexity
• Open over closed
• Malleability over rigidity
• Transparency over secrecy
• Contribution over consumption

Arch Grants is a new program to give $50k grants to create startups in St. Louis! Cool program. Here’s a story about it.

Startup Weekend is coming to St. Louis this weekend (Jan 27-29th) – it’s a great opportunity to find others interested in creating companies.

And finally, the new Startup Missouri program is launching on Jan 31st.

Strange Loop 2009

I started Strange Loop in 2009 with the thought that I could put together a local conference and surely I could find (heck probably knew myself) a couple hundred people in St. Louis that would go to a one day developer conference. I planned it in one of my favorite movie theaters in one of my favorite areas of St. Louis – the Loop. We ended up expanding by a half day and selling out with 300 attendees. The whole experience was terrifying from beginning to end. The event itself was an a/v nightmare although I muddled through and people still seemed to like it. The 2009 event had a few edgy topics but also tread some of the same ground as other conferences.

Strange Loop 2010

In 2010 I significantly expanded, planning for 500 people. With the increased size, there were few real choices in the Loop and I ended up at the Pageant (which I love) with extra meeting rooms at the Moonrise Hotel and the Regional Arts Commission across the street. Guy Steele did a keynote. NoSQL was a big focus of the conference. We recorded many of the talks and released them on InfoQ. We sold out again at 600 people. It was not quite as terrifying but I was stretched to the breaking point in the months leading up to the conference.

Strange Loop 2011

A year ago I knew what I wanted to do with the conference but I knew I couldn’t do it alone. I recruited and found a great group of people – Mario Aquino, Ryan Senior, Scott Delap, and Nick Cowan came into the fold. I signed much larger contracts for scary amounts of money (all before a single speaker had been contacted).

We planned for 700 with a max of 800 attendees. We moved out of the loop into the Hilton downtown. I don’t know what the magic number is, but I crossed some threshold between 600 and 800 people. Things were different – sponsors came out of nowhere, some economies of scale kicked in, and Strange Loop all of a sudden seemed like a business, not a conference. Things were not terrifying, merely very very busy.

We sold out all 800 tickets two months before the conference. I worked feverishly with the hotel to find some way to let more people attend and we were eventually able to bump the total up to 900 (and sold out again).

I had many many great experiences this year – I don’t get to see many of the talks during the conference but I thoroughly enjoyed all of the keynotes and several other sessions I got to see. Probably my personal highlight was just getting to know Gerry and Julie Sussman – they were both phenomenal before, during, and after the conference. Gerry didn’t just do his keynote, he went to the Haskell workshop, they both attended sessions and the trivia event, they gave out pocket protectors. Total inspiration. Rich Hickey brought down the house at the end with a great talk that has already gotten more than 50,000 views on InfoQ. I got to talk type systems with Daniel Spiewak well after midnight and have great conversations with more people than I can remember. The speaker dinner was a blast – it felt like my wedding reception to drift through the tables and see so many people I knew and got to meet.

At the same time, I was not happy being at a hotel. The conference felt more like other big conferences – loss of intimate spaces, the typical blah vibe you get from any hotel conference space, generally crappy views for screens in the big room (inevitable given the shape of big hotel conference spaces), etc etc.

Strange Loop is too awesome to be constrained in such a space.

Strange Loop 2012

This year I was determined to find a venue that would be awesome to see talks yet still accommodate enough people. Strange Loop will probably grow a little this year, but I think it’s basically at it’s limit for retaining the feel I want. We had looked at the new Peabody Opera House last year but they were targeting an August open date at the time and I just didn’t trust that to be solid enough for 2011, but now they’re open so we’re doing it!

The main hall is sweet – it is a similar feel to the Fox Theater (if you’re from St. Louis), but a bit smaller and more intimate. I have asked the A/V guys to find the biggest damn screen they can get and they have a multi-million dollar sound system. Seeing talks in the main theater is going to be remarkable. In addition, the four side theaters are also perfectly sized for sessions. They have high ceilings and 3 of them have built-in stages – these let us put screens and speakers up higher and have a great viewing experience. Every one of these rooms is just simply better than what you can find in a hotel.

There is a truly phenomenal set of speakers I talked to last year that just couldn’t make it. I can’t wait to get started putting together this year’s program. There will still be an open call but I expect competition to be fierce. I’m convinced that we’re going to have a conference line-up like nothing you’ve seen anywhere.

That’s just the start – we’re working to make the optional pre-conference day better (I’m really glad the Emerging Languages Camp will be part of Strange Loop!), great night-time events, free-flow beverages throughout the day, better snack options, simplified parking, etc. Everything is going to be just better.

When I started Strange Loop my goal was to have a low-cost conference, in comparison to conferences that cost $1000+, don’t pay speakers, and sell keynote slots to people you don’t care about. My views on this have changed over the years – I would now say that I want Strange Loop to be a *great value* and I think we’ve hit that goal for sure. Some of the improvements above cost money. As such, Strange Loop will cost more in 2012 ($400+) but I still think this is very competitively priced and offers tremendous value.

Some of these changes are also going to consume more time. I spent a lot of time this year thinking about how to keep doing Strange Loop in a way that makes me happy. I have a full-time job at Revelytix and have been running Strange Loop by spending every evening and a lot of weekends for half the year working on it. Adding the additional guys to the team in 2011 made it possible – they were a huge help. But really it merely kept my work level flat.

With this year’s success, it’s clear that it’s possible to make some money doing Strange Loop, maybe even enough (with a couple additional other conferences) for me to do it full time. I’m not ready to make that leap yet but in 2012 I have worked out an agreement with Revelytix to reduce my hours so that I can spend 20% of my time on conference work. My hope is that this will allow me to both do better work on Strange Loop (and the new Clojure/West) and also reclaim some of my life back so I can spend it with my kids and wife (who has been very supportive throughout). Many companies would not be so flexible and I really owe a huge debt to the owner of Revelytix, Michael Lang, and my boss, Bob Scanlon, for giving me this leeway.

2012 is going to be great! I hope you can make it to Strange Loop. Join the mailing list or track it on Lanyrd.

First, I think there is a great temptation to point at this particular note and use it as evidence that “Scala is bad” or whatever. While I know and respect Stephen Colebourne a tremendous amount, I have not particularly enjoyed the tone of his recent Scala criticism (which is not to say that I don’t think he makes valid points in some cases). I winced to see him waving the flag in this way.

I would say instead that this is an incredibly valuable evaluation of a young and promising language and I hope and believe that it will be taken that way by Odersky, etc. It is easy to find drive-by criticism of a language but much rarer to find someone that has lived in it for a long time and is able to deliver precise, detailed feedback of where the pain was greater than the value. I found Coda’s criticism to be exactly that and also written in a highly respectful tone.

I am unabashedly a fan of Clojure (if you follow this blog, my tweets, my conference talks, my nascent Clojure/West conference, this is no surprise). I believe some people might perceive Scala and Clojure as enemies and thus suspect that the Clojure community likes seeing Scala bashing.

Much the opposite. We all want the same thing – a way to write programs that allows us to be more productive, make fast flexible systems, and write cool stuff. I find much to respect and envy in Scala and its ecosystem. I see some of the smartest programmers I know loving Scala and finding it productive. I believe that Clojure and Scala (and all the other languages I’m not talking about) want a better way to do programming. In that, I see allies, not enemies.

Going back to Coda’s gist, he is honestly evaluating his choices and deciding where his team can do their best work *right now*. In the end, you’re balancing forces of time-to-market, performance, quality, future maintenance debt, on-ramping new people, etc. I don’t hear Coda saying “Scala is bad”; I hear him saying “Scala is not the best balance of our needs at this time”. Other people will make a different choice. They will make different choices at other times. That’s just being smart at running your business. Being able to coherently say “…because X, Y, Z” is very helpful so the language can evolve.

I saw some questions floating around about whether people using Clojure have hit this part of the hype cycle. Since we’ve been doing Clojure full-time at Revelytix for a couple years now and have hired people, done maintenance, etc, I think we’re as qualified as anyone to judge that. In general, I’d say that we certainly have encountered painful aspects of the language or the tools – when you are using tools in anger, you find things that suck. We have hit serious pain around AOT (ahead-of-time) compilation. We’ve seen some nasty classloader problems (linked to AOT). We’re having a more painful time than I expected moving from Clojure 1.2 to 1.3. Debugging sometimes sucks due to laziness, large stack traces, confusing error messages, etc. I yearn for refactoring tools as good as what I had in Eclipse with Java. Sometimes I want a static type. :)

On balance, we are not clamoring to change back to Java (or anything else) though. All of the painful things above are things we have worked through. By choosing a young language, you are implicitly accepting consequences like immature tooling or buggy libraries. I think we’ve tried to hit a good balance of powering through issues and giving back fixes or filing bugs where appropriate. Clojure is such a dynamic language that there is almost always a way to address a problem (even in the core libraries or the language) from your own code. Encapsulation (of data or code) is not held in particularly high regard in Clojure. The upside is that the engine is laid bare if you need to swap out a piston or something. In general, we have found our resulting code to be vastly preferable to what we could do in Java. Clojure gives you a set of composable tools that allow you to build systems to talk at the level of your problem and that is what I want in any language. For us, right now, Clojure is still a big win in that set of forces.

During the end of my Cracking Clojure talk I showed a screencast I did where I progressively build up a solution to Conway’s Life in Clojure.

The end solution is completely stolen from Christophe Grand‘s elegant solution – I just filled in the work leading up to it (and refactored slightly). My end result from the ‘cast:

(defn neighbors [[x y]]
  (for [dx [-1 0 1]
        dy (if (zero? dx)
             [-1 1]
             [-1 0 1])]
    [(+ dx x) (+ dy y)]))

(defn live [n alive?]
  (or (= n 3)
      (and (= n 2) alive?)))

(defn step [world]
  (set
   (for [[cell n] (frequencies (mapcat neighbors world))
         :when (live n (world cell))]
     cell)))

(defn life [initial-world]
  (iterate step initial-world))

Note that the final function life will return you an infinite sequence of steps in the game of life starting from an initial world (a set of cells).

When I went to Vaclav Pech’s talk on GPars on Tuesday he did a Groovy life implementation in GPars with dataflow which was pretty slick and had a real gui. So, in the keynote before my talk I whipped up a ui of my own using Processing and the clj-processing wrappers. My code is gross, especially in comparison to the life impl but it wraps a ref around the infinite sequence, then peels off the next item (in do-step) each time draw is called (on draw) by Processing and writes it to the screen.

To add clj-processing to you project.clj, use:

 [org.clojars.automata/rosado.processing "1.1.0"]

It appears to only play nice with Clojure 1.2.x right now due to a dynamic var in the applet.

(ns demo.lifeui
  (:use [demo.life]
        [rosado.processing]
        [rosado.processing.applet]))

(def glider #{[0 1] [1 2] [2 0] [2 1] [2 2]})
(def blinker #{[3 3] [3 4] [3 5]})
(def worlds (ref (life glider)))

(defn setup []
  (background-int 0)
  (stroke-int 255)
  (framerate 4))

(defn do-step []
  (dosync
   (let [next-world (first @worlds)]
     (alter worlds #(drop 1 %))
     next-world)))

(defn grid [rows cols cells]
  (let [cellw (/ (width) cols)
        cellh (/ (height) cols)]
    (doseq [x (range rows)
            y (range cols)]
      (if (contains? cells [x y])
        (fill-float 250 50 50)
        (fill-float 0))
      (rect (* x cellw) (* y cellh) cellw cellh))))

(defn draw []
  (background 0)
  (grid 32 32 (do-step)))

(defapplet lifeui
  :title "Life"
  :setup setup
  :draw draw
  :size [800 600])

(run lifeui)

One key problem with this whole impl is that it ignores boundary wrapping so please feel free to fix that as an exercise for the reader.