A couple of themes emerged from the conference. Aspect Oriented Programming may finally be coming of age. I first heard of AOP about 4 years ago. This year, there seemed to be more substance behind the buzz. We shall see.

Another theme was the the strong belief among the speakers that although Groovy is still very much in its infancy, it has a strong possibility become very significant in the next few years. If you haven’t heard of Groovy, it is a dynamic scripting language built on top of the JVM. Unlike other JVM languages such as Jython and JRuby, Groovy is designed to work closely with Java and especially the Java libraries. A brief look at Groovy reveals a lot of similarities with Ruby. I’ll be looking at Groovy in more detail.

I’ve got a couple ideas for blog entries inspired by the conference and I’ll post them here in time.

The program agenda is looking pretty good. I’m talking about RubyGems this year (what else!). I’m especially excited to see that David Heinemeier Hansson will be there and he will be talking about Ruby on Rails which has been getting a lot of air time recently.

The Conference is relatively inexpensive (only $200 for the conference fees) and it’s a great time to meet a lot of Rubyists all at once. The conference is in the Washington DC area (Chantilly, VA), so it is accessible to a large portion of the east coast.

If you are at all interested in Ruby, I urge to to come and meet with us! You can register here.

Update!

It has just been announced that Brad Cox, the inventor of Objective-C will be giving the Keynote speech at the conference.

• Feedback

It turns out that she is featured on the local school district's web site where she is a library aide. The picture was taken during one of the school’s book promotions. (Helen is the one dressed up as the Cat-in-the-Hat.)

Here’s the picture …

I really like the book. I’m a big believer in automating all that I can, that is part of the motivation behind the creation of Rake. Mike provides a lot of great ideas and I can’t wait to try them out. (BTW, Rake gets a footnote mention on page 40, Woo Hoo!).

The book is targeted at the mainstream Java audience, so it talks a lot about ant and Cruise Control. Ruby and non-Java scripting languages are mentioned only in passing, but this is reasonable given the size and scope of the book. Mike says that he wants to encourage non-Java scripting and that the www.pragmaticautomation.com website will feature Ruby whenever he can.

And true to his word, today he posted a stakeout script that runs his unit tests whenever a file changes. Check it out.

Oh, and check out the book too.

• Feedback

Blocks in Ruby may be written with brace delimeters or do/end delimiters. There is a subtle difference in precedence between the two versions, but for most work the two are identical.

So which way do you go?

Some folk use { } for one-liners and do/end for multi-liners. Others stick exclusively to either { } or do/end. I tried all of the above, but was never really satisified with any of the guidelines.

Here is the guideline I use now:

• Use { } for blocks that return values
• Use do / end for blocks that are executed for side effects

This has the advantage of using the choice of block delimiter to convey a little extra information. Here’s some examples.

  # block used only for side effect
  list.each do |item| puts item end

  # Block used to return test value
  list.find { |item| item > 10 }

  # Block value used to build new value
  list.collect { |item| "-r" + item  }

Of course, if precedenence makes a difference, use the type of block that makes sense. This is just a guideline after all.

But I have found the distinction to be useful.

• Feedback

If you are considering releasing your Ruby project as a gem, you might want to see this (or this if you are using Rake).

Anyone want to make a guess when we will hit 100 gems?

• Feedback

The biggest change to RubyGems is the command structure. We now follow a cvs-like command structure where gem is the main command and install, build, etc are subcommands. For example, it install the latest version of rake, use the following command:

  gem install rake

Options are now defind on individual subcommands and the whole structure is much easier to learn and understand. In addition, the help system knows about individual commands and all the options for each command.

As you can guess, I’m quite excited about the latest version. I hope you download it and give it a tryout.

BTW, if you use Rake to build RubyGems, you will want to grab the latest version (rake-0.4.2) that supports rubygems-0.7.0.

• Feedback

The biggest change is that FileList are now "load on demand". When you define a file list, e.g.

   PKGFILES = FileList['**/*.rb', 'test/*']
   PKGFILES.exclude(/^temp/)

The file list just records the include and exclude patterns. Later, when you do …

  PKGFILES.each { |filename| ... }

the file list will actually go out and read the file system to find the matching files. The thought is that searching the file system is a rather expensive operation and if you never actually use the file list, then it is wasted time. By building the file list only when it is needed will make rake startup time a bit faster.

If you are having trouble starting with rake, I wrote up a QuickStartExample showing off some of the features of rake.

What is Rake?

Rake is a make-like utility written entirely in Ruby. It allows to you specify build target and actions, with the action being standard Ruby code.

Download

You can get Rake from rubyforge. If you have rubygems installed, then all you need to do is …

  gem -i rake

If you have a very recent version of rubygems (i.e. from CVS), then the —gen-rdoc option finally produces a decent rendition of the Rake documentation locally.

Way back when, I used to work on a data acquisition system that used an IRIG clock reader to timestamp our data samples. An IRIG clock works by reading a signal that sends the time once every second. Between the second ticks, the clock reader would interpolate the time down to the millisecnod level. This allows you to have several clocks on different systems all synchronized to the same clock signal.

Our system had to take a sample every 20 milliseconds, so every cycle we would calculate the time of the next cycle. When the current data cycle was done, we would just wait until that next scheduled time arrived to start the next cycle.

An IRIG clock reader is an interesting device. Normally it works really well, but occasionally (especially if there is noise on the clock signal line) it will misread the time signal. One particular reader we were using tended to misread a couple of bits in the minutes data with the result that for one second, the clock reader would add 30 minutes to the real time. When the next clock signal arrived a second later, the reader would start reporting the correct time again.

Jumping ahead was no problem. Our software just used the reported time and continued to schedule data cycles. However, when the clock jumped backwards, the next data cycle was suddenly scheduled for 30 minutes in the future. The result was that our system mysteriously stopped dead for 30 minutes and then just as mysteriously restarted as if nothing happened.

Time is a strange concept in computer programs. It is difficult to know what the exact time is while executing. Consider the following lines of code …

   t = Time.now                      # Line 1
   puts "The Current Time is: #{t}"  # Line 2

One would think that line 2 will print the current time. And most of the time we would be correct. But suppose I pressed the suspend button on my laptop between line 1 and line 2. It might be hours (or days) before line 2 prints out its now "out-of-date" time message.

When you are dealing with times in the millisecond range, there are all kinds of things that will pause your program from one line to the next. Interrupts, page faults, and time slicing all interact in interesting ways to make the concept of "time" in a program something of a challenge.

It wasn’t hard to fix our cycle scheduler to be well behaved, even in the face of uncertain time. And I learned a new respect for time in the process.

I’ll reproduce his summary here:

• Everything is an object

    5.times do print "hello world".capitalize end
  

• Elegant blocks gives inline power

    db.select_all(sql).inject([]) do |objects, row|
      objects << instantiate(row)
    end
  

• Exploring with reflection
• Extending at runtime (even standard lib!)
• Extensive standard library
  • XML, Test/Unit, Distributed Ruby, XML-RPC, WEBrick

• Feedback