One hour from now...

So, I'm a long-time Java guy, wading into Ruby/Rails and really liking it so far. I know most of you who have made the transition are already aware of how much nicer many things in RoR-land are, but I thought I'd start just collecting a series of posts on my own personal findings. Just 'cause.

Case in point, this morning I was writing a unit test in Java, and needed to use two dates in my test code, one that was further in the future than the other. In Java, this looks something like this:

Date now = new Date();
Calendar calendar = new GregorianCalendar();
calendar.setTime(now);
calendar.add(Calendar.HOUR, 1);
Date oneHourFromNow = calendar.getTime();

I know I don't need to explicitly set the calendar to 'now', however, I use the 'now' reference in the tests, so it seemed to be slightly more correct and explicit to do so. Further, the only reason for this setup code is to use the now and oneHourFromNow references in my tests.

In Rails, I would simply reference:

Time.now

when I wanted to get the current time, and then use the nice time-related functions that Rails adds:

Time.now + 1.hour

when I needed a time that was in the future. If I wanted the exact same semantics as the Java code, I suppose I could do this:

now = Time.now
one_hour_from_now = Time.now + 1.hour

but that doesn't seem to add much in the way of comprehensibility, so I'd likely skip that altogether.

So, in reality, what would take me five lines of code in Java, essentially takes zero in Rails, which, as I calculate things, is infinitely better.

From the "things I wish Java had" file...

Often you'll find yourself writing code similar to the following:

String childName = root.getChild().getName();

Now, if root.getChild() returns null, you'll get a dreaded NullPointerException. There are a couple ways to guard against this of course, but they're fairly verbose. You could check each traversal point for null...

String childName = null;
Node child = root.getChild();
if (child != null) {
  childName = child.getName();
}

That works, but it gets messy quickly if you have another traversal or two (and yes, I know, excessive depth is a bad code smell).

Alternatively, you could do something like this:

String childName = null;
try {
  childName = root.getChild().getName();
} catch(NullPointerException ignored) {
}

But you could really end up littering your code with ignored catch blocks.

Ideally, I would love to have a method of saying "traverse as far as you can, but return null if you encounter null along the way". Perhaps a special operator?

String childName = root,getChild(),getName();

Anyway, I'm sure there are languages out there that support this notion. It's high on my list of desired features for an alternative to Java!