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!

This article was sparked by a some conversations and discussions at RubyConf 2005.

Test VS Behavior

It seems fashionable these days to say that Test Driven Development is not about testing at all, but rather about (fill in the blank), where the blank can be filled with “design”, “behavior” or “specification”. At RubyConf this year, one of the “informal” discussion sessions around the pool area drew a large crowd of people to discuss this very topic.

The RSpec ruby library (from Steven Baker, Dave Astels and Aslak Hellesoy) is a replacement for Test::Unit. Its main focus is to change the terminology surrounding the whole TDD approach to software development. I think this is key … it is not changing anything fundamental about the processes, it is focused upon the words we use in describing the process. But don’t be fooled into thinking this is a matter of semantics only, for the very words we use to describe something shapes our thought processes about the thing we are describing.

BDD, or Behavior Driven Development, is an attempt to improve TDD (Test Drive Development) by emphasizing the behavior specification nature of traditional TDD. By freeing TDD from its test bound terminology, we avoid some of the preconceptions (e.g. “Tests? Yuck!”) that developers bring to the table when discussing TDD.

So What’s Different

So, what’s the real different between RSpec and Test::Unit? Compare these two code snippets. First the “test” version:

  class TestEmptyMovieList < Test::Unit::TestCase
    def setup
      @list = MovieList.new
    end
    def test_size_is_zero
      assert_equal 0, @list.size
    end
  end

And now the specification version:

  class EmptyMovieList < Spec::Context
    def setup
      @list = MovieList.new
    end
    def should_have_size_of_0
      @list.size.should_equal 0
    end
  end

Note: This is from RSpec version 0.2.0 available as a gem from RubyForge. The RSpec guys are currently thinking about using domain specific language for specification. So expect RSpec to change in the future.

We can see that the structure between the tests and the specifications is very similar. Actually, more than similar, they are virtually identical. We just use Context instead of TestCase, use methods with any name rather than those that start with test_, and use object based assertions rather than specific assert methods.

The result is something that reads rather naturally in ruby-accented English. But the functionally is essentially that of Test::Unit, just in different clothing.

Just Semantics!

I hear you saying “But it’s just semantics!” Of course it is. But leave out the word “just”. When conveying meaning, semantics is everything. And one of the important features of Agile developement is to convey the meaning of the code, in the code itself.

Semantics are important!

Is it worth it?

Ok, semantics are important. But is it worth converting all our unit tests into specifications?

Maybe.

I do find the terminology attractive. But I have a large investment in Test::Unit style tests at the moment. And RSpec is still a bit rough around the edges (for example, the error reporting is not quite as mature as Test::Unit’s). And RSpec is going through some major changes at the moment (I mentioned the specification DSL they are playing with).

What would I like to see? One area of specification that current TDD practices tend to be weak in is the specification of preconditions. Preconditions define under what circumstances it is valid to call a method. For example, it may be invalid to call a square root function with a negative argument. Looking at a list of tests (umm … specs), I can’t be sure if negative inputs are not allowed, or if the spec writer just forgot the cover that case.

I’m not ready to switch over to RSpec yet, but it certainly is moving in interesting directions.

What I didn’t talk about

Those of you who were present at the poolside conversation at RubyConf may wonder why I didn’t mention mock objects, since mock objects were a major part of that debate. I see the Behavior VS Test debate to be completely orthogonal to the Mock VS not-Mock discussion. I’ll pick up the mock object debate in another posting, so don’t worry.

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

Dick Hardt’s OSCON 2005 keynote talked about how to identify yourself online. Here’s an IRC conversation the ensued after I accidently issued a sudo command on a friend’s system, one that is monitored very closely by the sysadmin.

[22:35] <paulv>    matthew immediately declared that we were already cracked. :)
[22:35] <matthew>  yeah, it's all good.  Although, can you prove you're Jim?
[22:35] <jweirich> yes
[22:35] <jweirich> ask me a Ruby question
[22:35] <paulv>    implement the Y-combinator!
[22:35] <matthew>  heh
[22:35] <paulv>    then I'll believe.
[22:36] <jweirich> p proc { |le|
[22:36] <jweirich>   proc { |f| f.call(f) } \
[22:36] <jweirich>   .call ( proc { |f|
[22:36] <jweirich>            le.call (proc { |x| f.call(f).call(x) }) })
[22:36] <jweirich> }.call(proc { |recurse|
[22:36] <jweirich>   proc { |n|
[22:36] <jweirich>     if n == 0 then
[22:36] <jweirich>       1
[22:36] <jweirich>     else
[22:36] <jweirich>       n * recurse.call (n-1)
[22:36] <jweirich>     end
[22:36] <jweirich>   }
[22:36] <jweirich> }).call(5)  
[22:37] <matthew>  wow.  This is better than gpg keys.
[22:37] <matthew>  I hope you had that laying around 
[22:37] <jweirich> nah, did it from memory ;)
[22:37] <paulv>    this *is* better than GPG keys.

(and for those that missed the winking smiley, no, I did not do this from memory)

Update

I see that Dick Hardt’s OSCON 2005 presentation on Identity 2.0 is available at http://www.identity20.com/media/OSCON2005. This is worth seeing.

• Tagsurf Feedback

I don’t usually talk must about one-liners, but here’s one I used today.

ARGF and inject ... Two Great Tastes that Taste Great Together

Consider the following ruby one-lineer

ruby -e 'p ARGF.inject(0) { |sum, line| line.split[1].to_i + sum }'

Breaking it down, it …

• Iterates over each line of standard input (ARGF.inject(0))
• Splits the line into colums (line.split)
• Selects the second column ([1])
• Converts the second column to an integer (.to_i)
• Adds to to the running subtotal (+ sum)
• And prints the final sum (p)

In short, it sums up the numbers in the second column of a text file.

Cool. Now combine it with another one-liner …

lynx -dump http://gems.rubyforge.org/stats.html \
  | ruby -e 'p ARGF.inject(0) { |s,t| t.split[1].to_i + s }'

And you get the result …

1005821

... which is the number of gems served by RubyForge to date.

Over 1 million gems served :)

• Tagsurf Feedback

Here’s a story of one of those perfect presentation moments ... inspite of the horror of a demo failing minutes before the presentation starts.

David describes a recent presentation at the Salt Lake City No Fluff, Just Stuff symposium where a live rails demo leaves the crowd speechless.

• Tagsurf Feedback

Ruby Everywhere! Scott Baron has a cool idea that puts Ruby in yet other piece of the web framework.

CSS Builder

Scott was thinking about the problem of redundancy in a CSS style sheet (e.g. repeating the colors of a color scheme a zillion times throughout the file).

His solution? A builder-like CSS constructor. Yes! Ruby everywhere! Go read his blog for the details.

• Tagsurf Feedback

Extra-Curicular Activities during OSCON Week.

The Breedlove Guitar Company

During the week of OSCON, I took Monday off to drive down to Tumalo Oregon and take a tour of the Breedlove Guitar factory. I’ve owned a Breedlove guitar for 6 years and really love it. This was a fanstastic chance to see the place where it was made. I’ve posted some pictures from the tour if you would like to see them.

• Tagsurf Feedback

Fowler: After all until we tried it I thought XML would be a good syntax for build files..

Martin Fowler On Rake

Martin Fowler has written a great introduction to using Rake for building systems. The article is gentle and doesn’t assume a deep knowledge of Ruby.

Go read it now. You know you want to.

• Tagsurf Feedback

What a time! Here is a quick summary and overall impressions of the conference.

My Talks

Both of my talks, the Dependency Injection In Dynamic Languages and the 10 Things Every Java Programmer Should Know about Ruby, went well. Evidently, they were turning people away form the door for the “10 Things” talk (the room was small).

Both Howard Lewis Ship (of HiveMind) and Paul Hammant (of PicoContainers) attended the dependency injection talk. Howard pointed out a limitation in constructing object graphs with cycles in the current DIM implementation. Hivemind fixes that by introducing proxy objects. I’m wondering if DIM can do it without proxies. I’ll post later on this.

Ruby at OSCON

Ruby, and in particular Ruby on Rails, was getting a lot of notice at the conference. Here’s some items that come to mind.

• In the keynote talk on O’Reilly’s Radar project where O’Reilly tries to keep a finger on what’s up and comming, Tim and Nat see Ruby on Rails as possibly the “Perl of Web 2.0”.
• Both of Monday’s Tutorials on Ruby and Rails were very well attended. Several of the Ruby sessions on Thursday played to standing room only croweds.
• David Heinemeyer Hannson’s keynote talk on the Secrets of Ruby on Rails did a good job of highlighting the philosophy behind the framework.
• In his keynote talk “On Evil”, Danny O’Brian described the Gandhi method of preventing evil: First they ignore you, then they laugh at you, then they fight you, then you win. Danny noted that most groups haven’t figured out how to move from one state to another, and that the actual sequence is a bit more complicated than the simple progression laid out by the maxim. In particular Ruby seems to have gone directly from the “ignore” state to the “win” state in about 3 weeks.
• Why’s talk, “A Starry Afternoon, a Sinking Symphony, and the Polo Champ Who Gave It All Up for No Reason Whatsoever” would have been sold out, but O’Reilly moved it at the last minute to the main ballroom and ran it during the afternoon break. Although plagued with some technical difficulties (such as the projection screen placed where Why couldn’t see the screen, and missbehaving mplayer sessions), the presentation had the whole room rolling on the floor. Why is going to upload the videos to his Redhanded website in the near future, make sure you check them out. Did anyone record the Thirsty Cups’ rendition of the “Ruby Syntax Song” or “May I Recommend Ruby”?

OSCON in General

I really enjoyed a number of keynote talks. Here’s some of the memorable ones:

• TCP/IP and Shipping containers by Nick Gall. Yes, what do shipping containers and the TCP/IP protocol have in common? Nick compared the two and tried to come up with the characteristics of a technology that has potential for long term viability.

• Computational Origami: From Flapping Birds to Space Telescopes by Robert Lang. Who would have thought that Origami was so fascinating. Evidently, recent advances in using computers to compute the crease patterns of Origami patterns has yielded designs that were thought impossible just a few years ago. Check out Robert’s site.

• Open Source Biology by Drew Endy. Drew highlighted how many of the basic building blocks in DNA research are being patented and impending inovation in that field.

• Identity 2.0 by Dick Hardt. Dick gets extra points for not only a interesting talk, but getting his point across in a fast paced, well written monologue that didn’t let your eyes wander from the screen for fear of missing something.

• HowToons by Saul Griffith. Check this stuff out. It’s great!

I’m not going to write up all the sessions I sat in on, but here are a couple of things that I found interesting.

• I sat in a on Advanced Groovy talk by Rod Cope. I’ve not been following Groovy recently. I see the syntax has been refined a bit since the last time I looked at it. Rod claims that performance is now 20% to 90% of Java, quite a bit faster than the last time I looked. Ruby’s Builder::XmlMarkup (which is available as part of Rails) was stolen directly from ideas in the Groovy community, so keeping an eye on Groovy is definitly worthwhile.

• If you ever get a chance to see Mark-Jason Dominus give a talk, take advantage of the opportunity. I’ve been a long time fan of his Presentation Judo talk. OSCON was the first chance I had to hear him in person. I caught part of his Making Programs Faster and his Friday session on You Can’t Get There from Here.

Non-OSCON Stuff

Portland is great. The public transportation here is outstanding and the city is wonderful. While I have been attending OSCON, my wife has been exploring the city and its many gardens and museums. After OSCON closed, Helen and I went had a late lunch in the Chinese quarter and then hopped on over to Powell’s city of books. Powell’s is a bookstore covering an entire city block. Heh, they give you a map when you enter the store. I could have spend hours there ... well, hey, I guess I did.

On Monday, Helen and I took a tour of the Breedlove Guitar Company, a small guitar company near Bend, Oregon. (Did I mention I own a Breedlove guitar? ... wonderful instrument). It was a four hour drive from Portland, but it was well worth it. I took plenty of pictures there and will probably write up the Breedlove tour in more detail later.

Today, Helen and I will be puttering around Portland a bit more, then start back to Cincinnati on Sunday.

• Tagsurf Feedback