I have to tell you, while working on FanConcert with Ruby on Rails I've found Ruby to be a complete pleasure to work with. Only after using it for a few months do I understand all of the advantages of languages like Ruby that James Robertson has been blogging about. He uses Smalltalk but it seems very similar to Ruby (maybe I can find a comparison to link to). Honestly the best way is to get knee-deep into it, then you'll get it too.

First of all, when you're using a dynamically typed language I recommend you unit test. There's no compile-time type checking but your tests can do something even better: make sure all of the objects are behaving the way you expect them to. Then type-checking becomes unnecessary.

Ruby calls this "duck typing": if the object quacks like a duck, it must be one. If the object responds to a method call, it's quacking. Unit testing ensures your objects quack how you intend. The approach makes it easier to refactor Ruby code than Java, even when Java gets help from an IDE like Eclipse (refactoring Java code can be a search-and-replace nightmare without help from an IDE). You don't need to change declared types or method signatures with Ruby code, you just make the object quack differently and it will.

But let's get to something I really like about Ruby: the keyword unless, a negated if. Boy, does it make code more readable. Sure it's syntactic sugar but it improves the readability of if statements, which makes the code easier to understand, which makes the code easier to change, which makes the project more agile, which I really like!

The thing I like the most about unless is that it's bigger than that skinny exclamation point, which is used to negate boolean expressions. This alone makes code more readable to me. Here's a simple example that strips whitespace from a String object:

thing.strip! if !thing.nil?
thing.strip! unless thing.nil?

You can't call a method on a nil (null) object, so this is a common bit of code. The exclamation point on the end of strip! is part of the method name (meaning it is "destructive") so you can ignore it. Just look at how much more readable that second line is.

Another example is compound boolean statements, which are easy to mess up when you're trying to negate them. Remember:

not (A and B and C) == not A or not B or not C
not (A or B or C) == not A and not B and not C

That's just pseudocode and it's giving me a headache. All software and hardware people know that rule -- originally by De Morgan -- but it's easy to mess up in an if statement.

if !array.nil? and array.size > 0
if !(array.nil? or array.size == 0)
unless array.nil? or array.size == 0

I like the unless one for readability again. The syntax allows you to give the statements a different perspective when you're trying to figure out what they do: an if gives the conditions for entering the block while an unless gives the conditions for skipping the block.