Late to the Party: Category Java

RadRails dying off?

chris.a.williams@gmail.com (Chris) — Tue, 06 Mar 2007 14:02:00 +0000

Kyle Shank of the RadRails team has mentioned that he and Matt are both working on a web startup. Looks like the priority of RadRails is lower for them - after all, RadRails doesn't make money.

It's a shame that this sort of thing happens, but I can't say I'm all that surprised. I've been working on RDT for nearly 4 years now and I can definitely say that people just don't pay for free things. You can beg for donations, but you shouldn't expect them. Given the amount of time and effort - and the sheer number of downloads - it just doesn't pay the bills to run an open source project that passively solicits donations. I estimate the per-user donations for RDT to be at about 1.4 cents*. And if we take out the one large donor? .00071 cents per user.

That doesn't quite cut it for rent and food, unless of course you get the entire world to use your product.

I wish Kyle and Matt well and hope that others from the community step forward and help lead the project onward.

Update: Looks like RadRails isn't dying off - it's getting new ownership.

* This estimate assumes we count RadRails users as RDT users, because RadRails contains RDT. It also uses just the raw zip downloads from Sourceforge for both projects. There is a large number of users we are not counting here who have downloaded via Eclipse's update site mechanism, and who use RDT from other distributions available.

RDT gets Refactoring support

chris.a.williams@gmail.com (Chris) — Tue, 06 Feb 2007 16:37:00 +0000

Well the cat is out of the bag: Mirko Stocker and his cohorts have committed their refactoring support to RDT's Subversion repository.

This means we'll be able to roll out 0.9.0 with this support. Right now we're working to get it integrated into the build process, so that it will begin showing up in our new builds. I'm pretty excited myself, because I've had little chance to try out their work.

This refactoring support joins other recent work in RDT which allows us to do some occurence marking of variables, code completion and other exciting features (thanks Jason!). There's certainly a long way yet to go to get the tools polished - for instance we still have a hard time doing code completion (or much else) on a file which is being edited while the syntax is temporarily incorrect (the JRuby parser is great, but not so forgiving) - but we're constantly marching forward.

Look for 0.9.0 to come out sometime this month (we're aiming for the 15th)!

JRuby guys hired by Sun, Netbeans Ruby IDE to come?

chris.a.williams@gmail.com (Chris) — Thu, 07 Sep 2006 22:40:00 +0000

Given the news about Sun hiring the JRuby developers, I thought I should chime my two cents in on the ongoing blog discussions.

First, and foremost, congratulations to Thomas and Charles. This is great news for their project and for Ruby in general. It goes a long way to say that the company behind Java is now supporting a project to run Ruby on the JVM. Maybe now I can give presentations on Ruby at my employer and not be chased with pitchforks and tar.

Next, I'd like to address a number of commenters out there. In particular, Cote': Hi there. There's already a project out there to make Eclipse into a Ruby IDE. I's called RDT and I'm one of the lead developers. It's also the set of plugins that those RadRails guys build on top of. Go check it out. Oh, and Tim Bray should too. He makes no mention of it, but maybe that has to do with politics...

Speaking of politics, the underlying tone behind the news is that Sun is looking to create a Ruby IDE in Netbeans. I have to say I'm a bit torn over this. It's great to see a large company want to create a full Ruby IDE and competition leads to better products for the end users, the Ruby community. But can Sun please get over itself and acknowledge Eclipse exists? It seems a bit of a waste of time for them to roll their own IDE rather than support an existing editor like RDT (or FreeRIDE, or whatever). I guess it's a bit too naive of me to think that they'd do something that didn't push their corporate agenda to some extent. Well, I guess I could always ask IBM to throw me some cash...

Tim Bray on Ruby IDEs

chris.a.williams@gmail.com (Chris) — Wed, 06 Sep 2006 13:33:00 +0000

Tim Bray has been posting an ongoing series of articles documenting his experience in creating a Ruby based Atom protocol exerciser. His inisghts are a nice look from a newcomer to the language and he makes a good case for a number of areas where Ruby is behind the times and behind other prevailing languages.

One such case is in IDEs. I've been aware of this since I began looking at Ruby, and obviously with my work on RDT I've been trying to help out in this regard.

I would encourage Tim and other newcomers to the language to give RDT a serious try. While we're light-years away from the level of functionality found in Java support for Eclipse, we've been making some exciting progress on RDT lately.

In fact, for those who don't mind the bleeding edge, you can download our nightly builds via Eclipse's update mechanism at http://updatesite.rubypeople.org/nightly.

The latest builds now include the work that was completed by Jason in his Google Summer of Code project. So the astute among you should now notice mark occurences support for variables, and even some code completion. We're working to polish those features up and get code completion working under more conditions. Right now, it'll work easily to complete variable names in scope or methods on a declared type. There are some severe limitations as to when the method completion will work for now: it's the first method in the chain on the object and the type is able to be inferred (i.e. declared in scope). To try out the type inferrencing (and show I'm not lying!), you can use a simple example of invoking code completion on code like "1.".

I know, it's a long way from the JDT, but we're getting there. And with a pending patch to JRuby, we'll also be able to integrate the refactoring/code generation work by Mirko and company.

Google Summer of Code

chris.a.williams@gmail.com (Chris) — Fri, 26 May 2006 13:03:00 +0000

Google has again decided to run it's Summer of Code - funding students to work on open source projects. Unfortunately, last year Ruby wasn't able to get in by the deadline, but this year David Black made sure Ruby Central was a participating organization. We had 14 mentors signup and (last count I saw) 84 student proposals.

The proposal review period is over and project allocations have been announced. Ruby Central received funding for 10 proposals, and the successful projects have been announced.

Among those accepted projects is work by Jason Morrison on RDT! He's a student at RIT (my alma mater) who helped start up our local Ruby/Rails group. I'll be his mentor, and he'll be working on trying to improve RDT to do some code resolution and type inferrence in an effort to improve code completion and other features (such as marking occurences of variables) for our project. Hopefully he'll also be releasing some sort of white paper/documentation to benefit the greater Ruby community beyond RDT/JRuby.

Thansk to Jason for the great proposal, and expect to see some more news about his work here in the future.

Ruby Can Learn From Perl

chris.a.williams@gmail.com (Chris) — Mon, 21 Nov 2005 19:21:05 +0000

I followed an interesting link off of Tim Bray's posting, which explains the differences in Java and Perl regex performance. The original article posted by Tim Bray notes his surprise that Java actually beats Perl in terms of the performance of regexes. However, it seems that Perl is losing the benchmark because they've implemented a better way to decrease some exponential matches to linear time. So the question is, is the tradeoff worth it? And if it is, then Ruby could stand to gain from implementing something similar to Perl.

Here's a simple test case, which shows that Ruby falls in the same camp as Java - they don't handle the edge case in favor of keeping faster general regex. Run the following script and try increasing that 20 by one each run and see how the amount of time to finish increases - it's frightening.

string = ""
20.times { string << "foo "}
string << "fo"
start = Time.now
string.match(/^(\s*foo\s*)*$/)
end_time = Time.now
puts "finished in #{end_time - start} seconds"

Using the Ruby Development Tools plug-in for Eclipse

chris.a.williams@gmail.com (Chris) — Thu, 13 Oct 2005 14:25:40 +0000

I just noticed today that there's a nice new article up on IBM's developerworks entitled Using the Ruby Development Tools plug-in for Eclipse. The article gives a nice little overview of using the Ruby Development Tools Plugins within Eclipse and developing Ruby code with them. The article ends by incorrectly stating that the current release is 0.5.0, we've launched 0.6.0 with a significant number of new features. Hopefully this will help drum up some new users and even developers for the plugins!

From Java to Ruby

chris.a.williams@gmail.com (Chris) — Fri, 07 Oct 2005 15:57:45 +0000

I've written up a nice summary page to help Java programmers transition from Java to Ruby (with love). This is for all those Java programmers interested in taking a peek at Ruby, but don't know where to start. I've gathered up a bunch of useful links and information to help you check out the language.

Close your Streams

cwilliams — Fri, 15 Jul 2005 15:57:00 +0000

All right, so this post isn't for most programmers out there. It is, however, meant for any new Java programmers, or just really aloof ones.

I work at a large Fortune 500 company as a contractor. We're working on a project in Java that is now on about it's 4th or 5th year of life.

One of my co-workers, who's been working on the project for at least 3 years now had the following code in one of her classes:

try {
  Connection conn = getConnection(url);
  Request req = new Request(message);
  Response resp = conn.sendMessage(req);
  if (resp == null || resp.isErrorCode()) {
    sendFailure();
  } else {
    sendSuccess();
  }
  conn.close();		           			
} catch (IOException e) {
  e.printStackTrace();		           		
}

See the problem?

Exactly. She didn't close her socket in a finally clause. That means if we do get an Exception, the socket might never be closed properly.

She should have done something like this:

Connection conn = null;
try {
  conn = getConnection(url);
  Request req = new Request(message);
  Response resp = conn.sendMessage(req);
  if (resp == null || resp.isErrorCode()) {
    sendFailure();
  } else {
    sendSuccess();
  }           			
} catch (IOException e) {
  e.printStackTrace();		           		
} finally {
  try {
    // always properly close the connection
    if(conn != null) conn.close();
  } catch (CommException e) {
    // ignore
  }
}

Just another reason why Ruby is nicer. Using the block form of IO.open ensures that the stream will always get closed, and that we don't have to do all sorts of double-wrapping with try-catch code.