freshmeat.net: Editorials - Why You Might Want to Try Ruby

Tue, May 13th

18:10 PDT

[Article]

add comment

[Article]

Why You Might Want to Try Ruby
by Phil Tomson, in Editorials - Sat, Jan 5th 2002 00:00 PDT

Ruby. Perhaps you've heard of it? "Oh, yeah, I think it's one of those new object oriented scripting languages", you say. I know a lot of you might be thinking "Not another new language! I'm perfectly happy with [COBOL|C|cshell|awk|Perl|...]; why does the world need another programming language?!", while a few others are thinking "Cool, a new language to explore".

Copyright notice: All reader-contributed material on freshmeat.net is the property and responsibility of its author; for reprint rights, please contact the author directly.

Those of you in the former camp should ask yourselves this question: What if all programmers back in the days when COBOL ruled the mainframe had the same attitude? Fortran would still be an academic curiosity, and we might all be programming in COBOL at work, while C might not even exist yet. Not a pretty picture. That's why we need some folks around who are in the latter, early adopter camp. The purpose of this article is to persuade some early adopters to give Ruby a try (no hidden agendas here :).

Why should you try Ruby? Remember Maslow's hierarchy of human needs from that Psych 101 class you took way-back-when? At the bottom of the pyramid, there are things like food, water, and shelter. It progresses up to things like security, and finally, at the top, there's a category called "self-actualization", which basically means (my paraphrase) "fun stuff". No, you don't learn Ruby to secure food, shelter, and security (at least not yet); that's why you learn languages like C/C++, Java, and Perl. (Though after you learn Ruby, you'll certainly hope that you can start using it soon at work.) You learn Ruby, at this point, primarily because it's fun.

Ok, so what kind of language is Ruby, anyway?

Ruby is a "dynamically strongly typed", single-inheritance object oriented programming language. It's dynamically typed in that types are checked at runtime, and types of variables don't need to be declared. It's strongly typed in that if you try to use an object of a certain type in a way that the type doesn't understand, an exception (or error) will be raised. The term "object oriented" is applied to a lot of things these days. There's object oriented Perl, for example, but though you can do OO in Perl, it's not a pretty sight. In the early 90s, the creator of Ruby, Yukihiro Matsumoto (AKA "Matz") was looking for an object oriented scripting language which had the text processing capabilities of Perl. He looked at Python, but even it was not OO enough for his tastes, so he ended up creating Ruby. If SmallTalk dwells in the most OO region of ProgrammingLanguageLand (as many believe), then Ruby lives right next door.

Numbers, string literals, regular expressions... these are all objects in Ruby. Here are a few examples of this in Ruby code ("==>" means "results in"):

3.times { print " hey " } ==> " hey hey hey "

" this is a string ".length ==> 21

/^IF .. ^END/.type ==> Regexp

Ruby has a large number of built-in types, including Array, Hash, String, File, Thread, and Time. Each of these types or classes has a very complete set of methods which act on objects of that type. This lets you get more done with less code. For example, let's say you have a string with leading and trailing whitespace, and you want to get rid of them:

string = " this is a string "

You can apply the strip! method to it, like this:

string.strip! ==> "this is a string"

Methods which have a "!" at the end are destructive; they change the object they are applied to.

Now, let's capitalize our string:

string.capitalize! ==> "This is a string"

If you want to change "string" to "phrase", do this:

string.gsub!(/string/,"phrase")

And there are a lot more actions that can be performed on strings...

Even though Ruby's built-in classes have very complete sets of methods to act upon them, you're bound to find a need for some action that may not be built-in to a type, so Ruby allows you to extend its built-in types. For example, I wanted to rotate the contents of an Array. Ruby's Array class doesn't have a built-in rotate method, so I made my own and added it to the Array class:


class Array
  def rotate!
     self.unshift( self.pop)
     return self[0]
  end
end

After that declaration, all objects of type Array in my program will respond to the rotate! method. This implies that classes in Ruby are not closed; you can always extend either built-in classes or classes you define. In fact, you can even do this at runtime, which makes Ruby a very dynamic language indeed.

As mentioned earlier, Ruby is a single inheritance OO language. Some might see the single inheritance part as a liability, but, in fact, Ruby allows for something called mixins. A mixin is a set of behaviors or functions defined within a module which can be included (mixed in) to a class. In practice, mixins tend to make up for the lack of multiple inheritance.

Perhaps the coolest feature of the Ruby language is the iterator. Iterators are methods that can invoke blocks of code. For example, all of the collection classes in Ruby implement the each method, which is an iterator that accepts a code block.


hobbits = ['frodo','sam', 'pippin']
hobbits.each { |name|
   puts "my name is: #{name}"
}

prints:

my name is frodo
my name is sam
my name is pippin

You can create your own iterators by using the yield statement:


def iterate(max)
   i = 0
   while i < max
      yield i
      i += 1
   end
end
iterate(10){|val| puts " val is: #{val}" }

prints:

val is: 0
...
val is: 10

Hopefully, these examples have illustrated Ruby's clean, consistent syntax. One of Matz's goals in designing Ruby is that it should follow the "principle of least surprise", and in my experience, it does tend to follow that maxim. There are many other cool features of Ruby (like GUI toolkits, Ruby's easy-to-use distributed object system (dRuby), Threads, etc.); I've just scratched the surface here to whet your appetite. You can find more information on Ruby at:

The newsgroup comp.lang.ruby is also quite informative and newbie friendly. Ruby is quite popular in Japan, the land of its beginnings, and it is growing in popularity in the West as well (I notice that there are 40 projects on freshmeat which are Ruby-related). There are currently two English language Ruby books, Programming Ruby: The Pragmatic Programmer's Guide by Dave Thomas and Andrew Hunt (you can find the full text of the book online at http://www.rubycentral.com/book/) and Ruby in a Nutshell by Matz himself. Three other Ruby books are planned for release early next year.

Go explore; have fun!

Author's bio:

Phil Tomson has been a software engineer for the last 8 years. He is currently in the midst of a sabbatical during which he is writing Open Source Ruby modules and an article or two.

T-Shirts and Fame!

We're eager to find people interested in writing articles on software-related topics. We're flexible on length, style, and topic, so long as you know what you're talking about and back up your opinions with facts. Anyone who writes an article gets a t-shirt from ThinkGeek in addition to 15 minutes of fame. If you think you'd like to try your hand at it, let jeff.covey@freshmeat.net know what you'd like to write about.

[Comments are disabled]

Referenced categories

Programming Language :: Ruby

Referenced projects

Ruby - An object-oriented language for quick and easy programming

Comments

[»] What does "more OO" mean?
by Phillip J. Eby - Jan 11th 2002 11:10:19

I've noticed that few promoters of Ruby have much to say about why Ruby is better than Python, except that it's "more OO". But I haven't seen what these "more OO" features are, that aren't available in Python 2.2.

For example, iterators and generators. Your example:

def iterate(max)
   i = 0
   while i < max
      yield i
      i += 1
   end
end

iterate(10){|val| puts " val is: #{val}" }

reads like this in Python 2.2:

from __future__ import generators

def iterate(max):
   i = 0
   while i < max:
      yield i
      i += 1

for val in iterate(10):
   print "val is:", val

Same feature, but a bit more readable. And a whole lot more things built in. Also, as of 2.2 you can subclass Python built-ins like integers, strings, etc., if you need or want to, as well as any extension type you define in C.

I really am curious to know what these other "OO" features are.