If you wish to report errors or suggest improvements for this FAQ, please go to our GitHub repository and open an issue or pull request.
How does Ruby stack up against…?
How does Ruby compare with Python?
Python and Ruby are both object oriented languages that provide a smooth transition from procedural to OO programming styles. Smalltalk, by contrast, is object only—you can’t do anything until you understand objects, inheritance and the sizable Smalltalk class hierarchy. By providing procedural training wheels, Python and Ruby “fix” one of the features that may have kept Smalltalk out of the mainstream. The two languages differ by approaching this solution from opposite directions.
Python is a hybrid language. It has functions for procedural programming and
objects for OO programming. Python bridges the two worlds by allowing
functions and methods to interconvert using the explicit self parameter
of every method def. When a function is inserted into an object, the first
argument automagically becomes a reference to the receiver.
Ruby is a pure OO language that can masquerade as a procedural one. It has no
functions, only method calls. In a Ruby method the receiver, also called
self, is a hidden argument like this in C++. A def statement outside of
a class definition, which is a function in Python, is actually a method call
in Ruby. These ersatz functions become private methods of class Object, the
root of the Ruby class hierarchy. Procedural programming is neatly solved from
the other direction—everything is an object. If the user doesn’t grok
objects yet, they can just pretend that def is a function definition and
still get useful work done.
Ruby’s OO purity provides a number of features that Python lacks or is still
working toward: a unified type/class hierarchy, metaclasses, the ability to
subclass everything, and uniform method invocation (none of this len() is a
function but items() is a method rubbish). Ruby, like Smalltalk, only
supports single inheritance, but it does have a very powerful mixin concept:
a class definition may include a module, which inserts that module’s methods,
constants, etc. into the class.
Ruby, again like Smalltalk, provides closures and code blocks and uses them to the same good effect. The Ruby collection classes and iterators are outstanding, much more powerful and elegant than the ad hoc solutions that Python is sprouting (lambdas and list comprehensions).
Ruby’s syntax and design philosophy are heavily influenced by Perl. It has a
lot of syntactic variability. Statement modifiers (if, unless, while,
until, etc.) may appear at the end of any statement. Some key words are
optional (the then in an if statement for example). Parentheses may
sometimes be elided in method calls. The receiver of a method may usually be
elided.
Many, many things are lifted directly from Perl.
Built in regular expressions, $_ and friends, here documents, the
single-quoted / double-quoted string distinction, $ and @ prefixes to
distinguish different kinds of names and so forth.
If you like Perl, you will like Ruby and be right at home with its syntax. If you like Smalltalk, you will like Ruby and be right at home with its semantics. If you like Python, you may or may not be put off by the huge difference in design philosophy between Python and Ruby/Perl.
Ruby is much more complex than Python but its features, for the most part, hang together well. Ruby is well designed and full of neat ideas that might be mined for P3K. I’m not sure how many Python programmers will be attracted to it though—it hasn’t won me over (yet). But it is worthy of serious study and could be a real threat to Perl.
Posted by John Dell’Aquila in comp.lang.python, 11/17/2000. Reproduced with permission.