It looks intriguing but I have never tried it. The thing that struck me about the language was that it's a fairly large download and that it's reportedly quite slow.

Ruby is a really fun language, and it's pretty powerful. Ruby takes a lot from Smalltalk (blocks for one) and makes it possible to do things you can't do as easily in other languages. Here's an example of a method that calculates the time required to do a task:

def time_it(█)  t = Time.now  block.call()  Time.now - tend

And now you can do things like:

puts time_it { 2**1024 }puts time_it do  s = "hello world"  s.tr("l", "x")end

And you'll get the time it took to execute the code contained in the block. Pretty cool huh? Another cool thing about Ruby that comes from Smalltalk is that you can add and modify methods to already existing classes at run-time. For example, let's say you want to add a factorial() method to the Fixnum class:

class Fixnum  def factorial    ans = 1    1.upto(self) { |i| ans *= i }    ans  endend

And now you can say:

100.factorial

So you can put methods that you need EXACTLY where they should be. In languages like C# or Java, the way to go about it is to subclass Integer and write the new method, and each time you want to find the factorial of a number, you need to cast it your new Integer class.

Ruby has a book available on the internet (www.rubycentral.com) which is extremely good, a very friendly community and some interesting projects (check out www.basecamphq.com which is written in Ruby)

Quote:
I think you can add new methods to a class in Python, but there the syntax would simply be

def factorial(self):
blah

Fixnum.factorial = factorial

Don't forget setattr and getattr, which allow you to set and get attributes respectively via the attribute's name.

Quote:
Which is much clumsier.

This is one of those things where there really isn't any use for it that couldn't be accomplished cleaner by, say subclassing it. That factorial example GnuVince posted could easily be accomplished by just having a function that accepts an integer and returns the factorial.

Quote:
his seems to be a nice extension of the "custom block approach". Python would be so very much nicer with custom blocks.

IMO python makes up for that with the combination of lambda and nested functions.

Python's lambda totally sucks.

Pxtl: Ruby has an abs() method for Integers. You can override it this way:

class Integer  def abs    puts "ABSOLUT VODKA!"  endend

Not hard, eh?

Quote:
This is one of those things where there really isn't any use for it that couldn't be accomplished cleaner by, say subclassing it. That factorial example GnuVince posted could easily be accomplished by just having a function that accepts an integer and returns the factorial.

I don't think it's really cleaner to do:

class FixnumFactorial < Fixnum  def fact    ans = 1    1.upto(self) { |i| ans *= i }    ans  endendx = FixnumFactorial.new(10)x.fact

factorial is an action that all Integer objects can do, so I don't see why you don't have it where it belongs and not in a stupid seperated class. As for having a function, you could do it in Ruby, because when you write a method definition that's not within a class definition, that method becomes a method of the Object class (so it is in fact added to the Object class at run-time), but some languages can't do it. For example, in Smalltalk, C# or Java, you absolutely need to put method definitions inside class definitions. You also get the added benifit that everything is always the same. Here's something about Python that has always bugged me:

len("hello".upper())

Why isn't len() a method? It seems that it woudl be more natural if it was like upper(). Don't underestimate the usefulness of having consistancy.

len isn't a method because it operates on arbitrary sequence objects. It defers implementation to that object, which often implements it as a __len__ method, but also applies to iterators too I believe.