RubyConf at a Glance

It was very clear by Saturday that I wasn’t going to be able to blog each and every talk like I had in the past. There was just too much going on and I had too much on my plate to do it justice. Plus there were a lot of people doing a talk by talk blog on the conference, so my additional comments seemed superfluous.

So rather than do a blow by blow descriptions, I thought I would just touch on a few highlights.

Matz’s Keynote Address

Matz subtitled his talk “Weird and Crazy Ideas” and he talked about some of the “stretch” ideas he has for Ruby 2.0. If you are following the Ruby 2.0 discussions up to this point, there wasn’t anything that was a big surprise. But he did give some more details on what we should be expecting.

Two big topics of conversation came out of this keynote. One was the syntax for anonymous functions. The second was the syntax for keyword arguments. See the ruby-talk mailing list before the conference for a discussion of anonymous functions. See ruby-talk after the conference for keyword arguments discussions. Both topics are generating a lot of traffic on the ruby-talk mailing list, so check the mailing lists for any details.

Selector namespaces were mentioned by Matz, but without any hint of how they would be implemented. After the keynote, Rich Kilmer brainstormed some ideas and Paul Brannon actually did a (simplifed) pilot implementation in pure Ruby to get a feel for how they might work.

The Long Tail

One of my favorite talks was Nathaniel Talbott’s talk on the long tail of software development. He explored the question of what happens to software development as the time and cost to develope software approaches zero. He compares it to intercontinental railroad (rails ... get it?) which lowered the cost of traveling to the interior of the US to a point that almost anyone could travel.

Metaruby and Ruby2C

The Seattle group is doing some really exciting stuff exploring what it would take to get the standard Ruby library (currently written in C) defined in Ruby. Its a two pronged approach. Part 1 is the Metaruby effort to rewrite the standard classes is a (rather static) subset of Ruby. Part 2 is the Ruby2C translator that can take a subset of Ruby and rewrite it as C code. If this project is successful, moving Ruby to a different platform (i.e. the Java JVM or .NET CLR) much easier. Ryan Davis and Eric Hodel were the presenters for these two talks.

JRuby and YARV

I see these two projects are very important to the future adoption of Ruby in two different groups. YARV addresses the “Ruby is too slow” crowd, while JRuby addresses the “but it doesn’t interact well with Java” crowd. While neither group is critical to future adoption, Ruby acceptance would be enhanced by addressing their concerns.

My Talks

I did two talks this year. One was in the standard track and was on the topic of Domain Specific Languages written in Ruby. It was well received and seems to seeded some new ideas in some people.

The second talk was a workshop (with Chad Fowler) on Sunday afternoon where we delved into the details of programming with continuations. The other workshop was on Rails, so I expected a light turnout at ours. Surprisingly we had a very good crowd. Presenting with Chad was a lot of fun (I really liked the conversational approach we used) and people seemed to enjoy it. Plus I worked in playing a video game into the talk.

Other Stuff

I think the best part of RubyConf is not the formal talks, but the chance to meet and talk to people over meals and between sessions. I will post on some of the topics sparked by these conversations in the weeks to come. Unfortunately, I didn’t get to participate in as many code fests as I had hoped (I was too brain dead for serious coding by the end of the day).

I’m already looking forward to next year!

Conference Introduction

David Allen Black welcomed us to the conference and gave us some background on the conference hotel. Evidently the hotel was quite the Hollywood get-away spot for a number of years. A lot of our rooms are named for Hollywood stars (I’m staying in the Joan Crawford room).

Top to Bottom Testing (Francis Hwang)

Some really cool ideas on testing. Francis talked about MockFS and mocking in Lafcadio. He emphasizes the importance of testing and making is easy (so programmers will write them) and fast (so programmers will run them).

The question/answer period brought up the whole mock vs stub nomenclature. There was also a lot of discussion on the use of mock databases.

Francis talked about the ability to redefine the standard File and Dir constants to point to the mock file system versions. During lunch I mentioned the Constant Injection technique I used in my OSCON 2005 dependency injection talk.

open-uri: easy to use and extensible virtual file system (Akira Tanaka)

open-uri replaces the standard open method and will automatically use the HTTP protocol to grab web pages and present them as regular file reads. RubyGems uses open-uri for some of its work.

Tanaka also explored some design principles for building APIs and applied them to the open-uri library. He then briefly talked about how to tie into the open-uri Virtual File System (VFS).

JRuby (Charles Oliver Nutter)

I’m really excited about JRuby on many levels. If nothing else, it lowers the barrier to those exclusive Java oriented development organizations. After a rather long dormant period, JRuby development has really kicked off. Charles walked through some current implementation issues and talked a bit about the future directions.

JRuby’s new “stackless” implementation looks very interesting. I’m wondering if using some of the same techniques in the standard C Ruby implementation would make continuations better/faster.

YARV Progress Report (SASADA Koichi)

Koichi started his presentation with his usual humor using some “insider” Ruby jokes (and some “insider” Japanese humor … RubyMa!)

Most of the presentation dealt with many of the techniques used by YARV to be the fastest Ruby VM possible.

Best quote of the slides:

“Dynamicity is your friend, but my ENEMY”

MetaRuby: Reimplementing Ruby in Ruby (Eric Hodel)

MetaRuby is an interesting implementation of Ruby written entirely in Ruby. Coupling this with the Ruby2C project will (should) give you the ability to write almost the entire Ruby system in ruby and yet get comparable performance to a C based system.

Eric shared some about some of the strange implementation issues they ran into as they implemented the C code as Ruby code.

Supper

Up next after supper … the round table with Matz