Re: Strong advantages over Python

Okay, not to feed the flames too much here, but I figured I may as well 
include the entirely personal, qualitative reasons I find Ruby a better 
mental fit than Python:

First, I like Ruby's clear, easily-utilized meta-object protocol. This 
shows up in a number of superficial features like dynamically-extensible 
classes that pass new methods on to existing instances, but also allows 
easy clear metaprogramming at the object, class, or metaclass level. 
Python class definitions always seemed much more to be a sort of 
template for object creation, esp. with the required 'self' parameter 
and lack of runtime association b/t method definitions and object method 
bindings.

Second, while I initially found the "openness" of Python objects 
refreshing (having just run screaming from the Java world), I've come to 
discover that it actually discourages proper encapsulation of objects, 
and makes interfaces more brittle, rather than less. The fact that raw 
attribute access is the norm in Python makes it difficult to debug a 
number of simple errors (i.e., "obj.goo = 2; [...] print obj.foo"), and 
encourages direct manipulation of internal object state by other 
objects, rather than through accessors and mutators.

The syntactic sugar for creating such get/set methods in Ruby makes them 
effectively effortless to include in a class, and insures that future 
changes to the internal implementation of the class won't break code 
that uses it, as the change from an assignable attribute to a pair of 
get/set methods in Python is difficult to make automatic. (And yes, 
before anyone mentions it, I've seen the recently-added functionality in 
Python 2.2 to create that kind of protected attribute. IIRC, however, it 
requires defining a new class that "impersonates" a simple scalar, and 
it will be quite a while before the existing body of Python libraries 
and applications are updated to use it.)

Finally, the flexibility of the syntax allows for some very interesting 
domain-specific language work, like the make replacement and HDL 
mentioned recently on this list. Python can easily be extended with 
classes and functions for specific domains, but the inflexible syntax, 
esp. with its required indentation and parenthesis, basically forces you 
to make your DSL look just like Python, or do a full 
lexing/parsing/evaluating cycle on a new syntax. With Ruby, much like 
with Perl, you have just enough "wiggle room" to create a syntax that 
"just works" for some subset of possible uses.

Sorry for the somewhat rambling reply, but I hope that some of it helps.

Lennon