Ruby Hoedown 2009 Wrap-Up

The third annual Ruby Hoedown took place this past weekend at the Opryland Hotel in Nashville. In what I think is a first for Ruby conferences, the Hoedown was free (as in beer) this year. And thanks to the hard work of conference organizer Jeremy McAnally, and the support of a number of sponsors, the conference was a great success. I haven’t heard any of the numbers yet, so I don’t know how this year’s attendance compared to that for previous hoedowns, but I can tell you that it was a packed house.

What Happened on Friday

Ben Mabey opened the Hoedown Friday morning with his overview of how to use Cucumber (and related tools) in the Behavior-Driven Development (BDD) of software. He made the point that BDD is a mindset and not a toolset. In other words, BDD is not synonomous with Cucumber and RSpec, and it’s less important which tools you’re using than that you’re doing BDD. Ben’s talk moved at a very quick pace and I found it difficult to follow despite my familiarity with the basic concepts. A number of his slides also included dark text on dark backgrounds, which were difficult or impossible to read. Despite these flaws, he did provide some useful information for Rails developers who are looking to take their BDD skills to the next level. Several of the tools and techniques he mentioned (such as using HtmlUnit with JRuby) were new to me and have given me ideas about how to do more effective testing.

Corey Donohoe was up next. The title of Corey’s talk was “How to Be Simply Awesome,” but I’m not exactly sure what the topic was. It was a bit of a ramble, but entertaining nevertheless. The part that most resonated with me had to do with how he and his co-workers at Engine Yard have structured their internal software projects as collections of services instead of monolithic applications. It gave me some ideas about how we could maybe use Sinatra and JRuby to provide a RESTful interface (for third-party clients) to one of our existing Java-based web applications that’s hurting for an API.

After a break for lunch, Leon Gersing gave a presentation on desktop and mobile application development with Appcelerator Titanium. Titanium has been on my radar for awhile now, and so I was especially looking forward to this talk. One of the most interesting takeaways for me, and one that I had not yet picked up on, was that Titanium’s compiler (if that’s the correct term) will convert embedded Ruby or Python code into Javascript, or at least something that can talk to the rest of the runtime via a Javascript bridge. Don’t quote me on that. But it’s something approximately that cool.

Next up was Luke Kanies, talking about how to use Ruby to develop external domain-specific languages (DSLs). I’ve heard Luke speak about Puppet before, and was afraid this was going to be another Puppet-centric talk. (Not that Puppet isn’t cool, but you know, I’ve heard about it before.) But this was really more of a lessons-learned kind of talk, and a good overview of the motivation, tools and general process for developing external DSLs. Although most of the information that Luke presented was familiar to me, it was nevertheless a timely reminder that despite all of the recent attention on building internal DSLs on top of Ruby, there are some very good reasons to opt for an external DSL. For example, one of the dangers of using an internal DSL is that it makes it harder to restrict what the user is able to do.

Following Luke was Luigi Montanez, on “How to be a Civic Hacker.” Now this was an interesting topic, and one that I don’t believe I’ve ever seen addressed at a Ruby conference (or other tech conferences for that matter). Luigi works for Sunlight Labs, part of the Sunlight Foundation, and their mission is using the Internet to promote government transparency. Luigi posited (a little tongue-in-cheek) that the pinnacle of participatory government, much better than merely tweeting about your pet cause or joining a Facebook group to promote your candidate, is to engage in “civic hacking.” He gave a number of examples of how people are taking the raw data published by the government and turning it into useful information via web applications and other services. The only drawback to the presentation came near the end, where Luigi veered off into a quick demonstration of how one could take advantage of Google’s App Engine gem to publish their JRuby applications to the cloud (and get free hosting to boot). It would have been a good topic for a lightning talk, or even a separate full-blown presentation, but it felt sort-of tacked on to the end of an otherwise coherent talk.

Due to a cancellation earlier in the day, a slot had opened up in the schedule by the end of the day, and so were treated to a surprise presentation by Jim Weirich on “Source Control for People Who Don’t Like Source Control.” He opened by promising us that despite the title, “this talk is not about Git.” Jim went on to construct from first principles how his ideal source code control system would work, if he had to design one from scratch. As time went on, it became clear that while he was describing a mythical SCCS called “csc”, he was in fact talking about how Git works under the hood. Like every presentation of Jim’s that I’ve ever seen, it was thoroughly engaging, entertaining and educational.

What Happened on Saturday

Something I ate on Friday really did a number on me, and let’s just leave it at that. The result was that I didn’t get much sleep on Friday night, and I slept in and generally took it easy on Saturday morning, so I missed several presentations. I heard through the grapevine that there was a good presentation on Heroku, and another on how threads work in Ruby 1.9, so I hope to review the slides for those talks at some later date.

The first talk that I heard after my return to the living was David Chelimsky‘s talk on the use of mock objects in testing. It wasn’t really an introduction to the topic, more of a “best practices” type of talk. I was encouraged (sort of) to see that other people are struggling with some of the same problems that I struggle with when using mocks. For example, it can sometimes be tricky to decide whether to use a “stub” or a mock in a particular situation. David’s advice in this situation is to use stubs to enable execution, but to use expectations (via mock objects) to express the intent of the test. For some of the thornier questions about how to deal with mock objects, David recommended the forthcoming Growing Object-Oriented Software, Guided by Tests, by Steve Freeman and Nat Pryce. (A free preview of this book is also available online.) He also managed to get in a plug or two for the RSpec book, which is currently in beta but should be available in print later this year. I’m reading the beta of this right now, and can highly recommend it for anyone who’s interested in learning how to use Cucumber, RSpec and Webrat for test-driven development.

Then came the lightning talks. I didn’t take many notes on these, but this seems like the time to mention that there was a lot of buzz about MongoDB this weekend. Luigi made reference in his presentation to the fact that MongoDB just reached 1.0 status, and at least two different lightning talks were about MongoDB.

The Ruby Hoedown proper closed with Jamis Buck‘s keynote address. I can’t remember for sure, but I think this was the first time I’d ever heard Jamis speak. He’s very good at it. Jamis opened with a discussion of the art of making string figures. He covered the different notations (or languages) that people use to describe string figures, the “libraries” or patterns of standard moves that are combined and incorporated into more complex patterns, and the string figure-making community at large. He made the point that at first, before you’ve taken the time to really understand how string figures are constructed, the process of turning a simple loop of string into a complex figure can be appear to be “magic”. He went on to relate this to our experience as software developers. The difference between good and great programmers, Jamis said, is the level of understanding, and there are four ways to increase your understanding and thus become a better programmer:

  1. Know Thy Tools. Take the time to learn how the tools you use regularly, such as the operating system, text editors, the shell, source code control systems, etc. work.
  2. Know Thy Languages. You’re rarely working with just one language, such as Ruby or Java. If you’re doing any sort of web application development, at a minimum you’re also dealing with HTML, CSS and Javascript. Take the time to understand the finer points of these languages.
  3. Know Thy Libraries. Know why you’re using the particular libraries you’re using, and what distinguishes them from competing libraries. Engage in code spelunking to understand how libraries work under the hood.
  4. Know Thy Communities. Don’t merely be a “consumer” of community resources like mailing lists, forums and IRC channels. Be actively involved, recognizing that for these communities to really work it requires both giving and taking.

And with that, the conference concluded. I know that there were various after-hours parties on Friday and Saturday night, but I didn’t make it to any of those so I’ll leave it to others to say what went on there. It looks like a few photos are starting to appear on Flickr, and I know that people were making pretty liberal use of the #rubyhoedown hashtag on Twitter despite our failure to make the “trending topics” list, so be sure to check out those sources for more insight into the weekend’s festivities!

Update: Tommy Morgan has posted his recap here. If I come across any others I’ll try to remember to link ’em up here.

Posted August 31st, 2009 in Ruby. Tagged: .

One comment:

  1. will:

    yes dark text on a dark background is rather unreadable