Okay... you asked for my qualifications. So I'll start with that. I've been coding for the past 20 years. I've coded Ruby for 2 years, Python for 3 (and know about it for 5), Perl for 5 years, TCL for a year, C/C++ for 7, shell scripting for much longer, etc. I also know Logo, BASIC, assembler and probably others I've forgotten.
Now, those 3 years of dealing with python were done at ILM (one of the largest python places in the world), so I know very well what python can achieve as well as where it fails miserably.
That being said, I sustain ruby is a better language.
I'll clarify and prove my points, but first...
I recommend you download or read on-line "Programming Ruby". That way, you'll be able to criticize it properly.
Now, since you are likely also using Ubuntu, getting a proper standard ruby distribution is a tad hard, as Debian splits packages in a lot of ways. You need to do:
> apt-get install ruby1.8 libruby1.8 irb1.8 ri1.8
# add ruby1.8-dev and libruby1.8-dev for development, too
Okay... now you have a proper ruby distro to start playing with.
To try some of snippet of ruby code, you may want to try:
> irb
# And now you can type ruby code.
Irb by default is relatively plain.
To customize irb (add colors, completion, help, etc), the easiest way is to install wirble.
I'll do that by installing rubygems first, which is ruby's now more or less standard way of distributing libraries (it is to become part of ruby's core eventually).
You can get rubygems from www.rubyforge.org. That site also contains most of today's ruby libraries (around 2600 -- so much for few ruby libraries).
rubygems is a tad different to install. After unzipping it, you cd to its dir and you'll need to do:
> ruby extconf.rb
> make
> sudo make install
Once rubygems is installed you may want to now install wirble (or any of ruby's libraries):
> gem install wirble
For docs on wirble, you want to look at:
http://www.rubyinside.com/wirble-tab-completion-and-syntax-coloring-for-irb-336.html
Wirble allows irb to show syntax coloring, tab completion, etc (lots of customization).
Now, to answer your comments...
Ruby is closer to OO perl.
Ruby and Python are indeed similar.
However, Ruby's OO is most-definitively not like Perl... AT ALL!
Ruby's OO is single-inheritance with mix-ins.
This makes Ruby's OO very similar to Smalltalk's, with mix-ins being similar to Java's.
Its syntax, however, is much more closer to python than to Java, Perl or Smalltalk.
Ruby is more OO, but goal of python was not be more OO: goal of python was being readable and predictable.
Ruby's goal was to make programming fun. Ruby users often refer to it as following the Principle of Least Surprise (POLS).
As such, Ruby is both readable, predictable and has copied all of the good features of Python, Perl and Smalltalk.
Amazingly, Matz (its creator), succeeded at doing so. It could have easily been a mess.
Regarding Python's syntax, white space, and the like...
Python's syntax is very rigid. For example, you cannot do:
a = 20 if x == 20
which is relatively common construct found in C, Perl, Ruby, etc. You cannot also do things like do/while constructs, instead of while/do constructs. You don't have switch statements. The list goes on.
Ruby is much more flexible in this sense, while at the same time, not as crazy flexible as Perl is.
You obviously missed eval function.
No, I didn't. Have you tried using it much in python? I have, and was extremely dissatisfied with it. Here's a place where tabulation comes to haunt you.
If you just eval a single command, there's nothing wrong with it.
However, if you try to start eval'ing code that is several lines long, with ifs/whiles/etc., it is a nightmare compared to Ruby's eval. You have to make damn sure your code is tabulated properly at all times. This more or less forces you to need to pass a tabulation variable or parameter to every function that creates code on the fly to later be evaled... to make sure the code actually *COMPILES*.
Not surprisingly, eval() is not used much in python code.
Now I consider the ability to eval code on the fly one of the main attractions of dynamic languages, and python just takes that feature and makes it very hard to use.
Now, for good examples of how evaling long code can be useful, I can recommend looking at Getopt/Declare in Perl or my port of it in Ruby.
For other examples, Ruby on Rails and DSLs are a good examples of using other eval constructs.
Doing something like that in python is possible, but it is much, much, much harder,
See module re
Yep, familiar with it and also with its distant cousin the regex module.
Problem is, they are not built-in.
Thus, every regex comparison in python usually is divided into 2 or 3 annoying steps (a 4th if you include the import too): create the regex, use it to compare it and find the match results. A typical regex code in python looks like:
import re
r = re.compile(r"^([a-z])", IGNORE_CASE )
m = r.match( string )
if m:
print m.group(1)
Here's the equivalent Ruby code (Perl's regex is similar):
puts $1 if /^([a-z])/i
Not only is Ruby's approach more readable, but it is also shorter. Before you complain, let me mention that Ruby's regex, unlike Perl's are also objects. So you can also use Regexp objects and MatchData objects with all the standard ruby constructs.
Operator overloading is exactly the feature making small domain specific languages easy in python.
Err... no. Compare Python to Ruby:
Python:
# As numeric
class N(Integer)
def __mul__(x):
return x * self
# As array
class A:
def __getitem__(self, idx ):
pass
def __setitem__(self, idx, val ):
pass
Ruby:
class N < Integer
def *(x)
x * self
end
end
# As array class
class A
include Enumerable # gives you ALL of ruby's array methods ( a mix-in )
end
# more selectively, you can still do...
class B
def [](idx)
end
def []=(idx)
end
end
I think you'll find the Ruby's version simpler. No need to learn what __mul__, and the other 20+ python constructs are. I always screw it up in python ( I use mult instead of mul, for example).
With ruby, I never do. It is the same syntax that I use when using the method :)
I am no way a ruby expert - but from what I've seen, there is no big difference from perl. No magic bullet. Or did I missed something? Enlighten me - links please.
Hell, no. Ruby is WAY above python or Perl in this.
Okay... this one is hard, as DSLs do require a better grasp of the language (took me a year in ruby to "get" it).
But... I'll mention the features that makes DSLs in ruby so nice:
a) Ruby's functions/methods can be invoked without parenthesis.
message("hello, this is an example in python")
message "hello, and this is in ruby"
b) Ruby supports blocks, python doesn't.
This is an actual ruby DSL (it is ruby code) I've developed for managing 3d renders:
render {
scene "hello.ma"
frames 1..9, 30, 20
overrides {
layer "beauty" {
antialias 3
}
}
}
c) Besides "eval", ruby supports instance_eval() and class_eval(). This allows evaling a piece of code within the frame of reference of another class or instance.
d) Ruby's methods (and functions) support special characters in their names, like ?, !, etc.
class A
def has_data?
# do something here
end
end
a = A.new
if a.has_data?
end
e) Ruby makes it easy to open built-in classes and add methods. For example:
class String
def no_spaces
return ! include? ' '
end
end
puts 'This should have no spaces'.no_spaces
Compare that to Python, which still struggles with some of this:
def no_spaces(self):
if (' ' in self):
return False
return True
str.no_spaces = no_spaces
print('This should have no spaces'.no_spaces())
>> TypeError: can't set attributes of built-in/extension type 'str'
When you combine all of these, you can easily build a DSL that feels like a English (or most western languages). For a tutorial, I recommend:
http://www.artima.com/rubycs/articles/ruby_as_dsl.html
Up to page 2 or so, it is stuff you can also easily do with python. Pages 3 and 4, I'm not sure how you do them in python.
Other good examples in ruby include Rake and, to a lesser extent, Ruby on Rails.
Obviously. Python consciously decided to *not* be language for admin's one liners - noone can beat perl in that game, and why in the hell would you want to? Did you ever played perl golf competition? Can you write haiku in ruby? In perl you can. Does it mean perl is better?
Actually, Ruby matches Perl's one-liners, no problem. Most of Ruby's switches match those of Perl. Thus, to put the regex we wrote to good use, you can from a shell do:
> ruby -ne 'puts $1 if $_ =~ /^([a-z])/i' < yourfile.txt
and get the first letter of each line. Any sys-admin that knows ask or perl can easily dive in to write ruby one-liners in just seconds (or easily replace those written in those languages)
And yes, this does mean Perl is better than python for sys-admin tasks. But Ruby is better than both :)
Don't use [python] shell if you don't like it. Personally I consider it one of the *best* features of the python: you can import modules, instantiate objects, look at object methods, follow some tutorial one line at a time, looking at your objects from all sides.
You seem to not realize ruby has all that, too :)
Just better. With IRB, you can also:
- avoid rewriting classes to just add a method.
- see your output in color
- use tab completion
- add more customizations in your .irbrc file.
The equivalent in python is, as you mentioned, IPython, which has over irb only the ability to run the debugger.
The beauty of ruby in this aspect is that since IRB is a standard ruby module, it can easily be used within other contexts (as a shell for ruby in embedded programs, etc). I have not looked at IPython in detail, but I imagine doing so will be difficult in it.
So you concede python is better out-of-the box (for a beginner)
Hell, no! Teach them ruby instead! They'll find it easier and will probably end up writing better code in the long run.
Now, if you are using Ubuntu, as you probably are, python currently does come properly pre-installed. Ruby now also ships with Ubuntu, but mainly for amarok, not as a real language (read above to download all you need to get a proper ruby distro in Ubuntu).
You want to suggest that python lacks object introspection? It's no surprise that you would be wrong again. Or is it something else I am missing?
Python does lack some introspection. I already showed you the problem of not being able to open some of the built-in classes like str (a pretty important class, I might add).
Ridiculous. If you don't need multiple inheritance, dont use it. It does not hurt you until it is needed. *Then* you need it big time.
Actually, multiple inheritance has more or less now be proven not to be needed. That's coming from people who have used multiple inheritance in other languages for years (C++, mainly).
Most of the features of multiple-inheritance can often be solved with mix-ins, and in the very weird case it can't, you can implement multiple inheritance with dispatching.
This makes the code much easier to maintain in the long run, as there's less head-scratching once you invoke a method and it does not do what is expected (and you are trying to figure how the diamond inheritance chain is working).
Other than that, I would be glad to hear of a project that actively uses multiple inheritance and could not be done without it.
Well, i pesonaly find unreadable ruby's statement modifiers, and optional keywords, and inheritence from perl: difference between $ and @ is plain confusing. I know how to handle it (did it in perl) but I ask: why?
Ah... I see. You never actually USED ruby, and you are just basing your criticism on misconceptions and hear-say. Not sure what are ruby's statement modifiers or optional keywords are.
Inheritance has nothing to do with Perl, as I already explained.
$ and @ is VERY straight-forward. $ are global variables, @ are instance variables. Global variables are hardly used except for the main regex variables. @ are used, but only within classes, like you do with self.x in python (same meaning). Local variables don't have any qualifiers.
This has NOTHING to do with Perl, which uses: $, @, %, for scalar, array and hashes and \$, \@, \% for references to such (and classes are also $ and \$), and which are found all over perl's code.
*Much* more libraries. I know about people moving from ruby to python because of lack of the libraries.
I know of *NOONE* doing so, and certainly not because of libraries. In what domain? I'll make a bet and say you are trolling.
For each python library you mention, I'll see if can show you an equivalent (or better) ruby library. My guess is that you'll need to find something pretty obscure, as most standard stuff is there (command-line parsing, vector/matrices, numpy, sdl, opengl, widget toolkits, etc)
As for the opposite, I've already mentioned one library not available in python (Getopt/Declare).
Perl is the only language that can truly boast to have more libraries than others (which is also somewhat of an inconvenience as it becomes hard to choose among them).
You must mistake perl with python. Python was OO from day one, nad had conscious decision to add self as a parameter.
In this, you may be partially right. Python 0.95 did not have OO, but once it got added, it came with self. Why self was chosen, however, remains somewhat a mystery, as other OO languages at the time did without it.
Note, however, that Python's OO did change (super, for example, did not make into python until much later, albeit it was always part of ruby).
Regarding differences between attributes and functions...
This shows our expert misses difference between a function and method. No wonder: it is non-existent in Ruby Python method uses function-like syntax, adds *self* (or *this* or *it* or whatever you prefer) to reference your object. Ruby decided it is worth special keyword. Matter of opinion and taste. We don't burn people at the stake for such things anymore.
Besides your comment being very aggressive, I'll say it nicely, but you are dead wrong here.
Ruby does indeed not distinguish between a function and a method. This is more a matter of naming, as python's functions+methods == ruby's methods.
However, my comment was about attributes (ie. class/instance variables) and functions/methods.
I'll show you some code within an irb vs. python session to prove why ruby's approach is much better, with my comments. This is all done within a single ruby session, btw...
#
# Let's create a class with one attribute (x)
#
class A
def initialize
@x = 10
end
end
a = A.new
a.x
NoMethodError: undefined method `x' for #<A:0x2b9b81551d68 @x=10>
from (irb):20
from :0
# You'll notice that you cannot get to the a.x attribute. This is a GOOD thing.
# Attributes in ruby are PRIVATE by default.
# It keeps the class encapsulation and prevents users from misusing your class.
# For this example, I don't want x to remain private, thou.
class A
attr_accessor :x
end
a.x
10
# attr_accessor is a function that adds a getter and setter within ruby.
# You can think of it as a macro that creates two member functions, one for reading
# the x attribute and one for writing it.
# Now, the class behaves like your average python class and any user can access
# the value of x by calling a.x
#
# In Ruby, if I call an attribute that does not exist...
#
a.xx
NoMethodError: undefined method `xx' for #<A:0x2b83d871da68>
from (irb):7
#
# which is a good thing. No way to screw things in the class or in my code due
# to a typo or misuse.
#
#
# However, let's suppose that in the course of developing my application
# I decide that x should be a calculated value instead of a simple attribute.
# I'll show you the beauty of ruby here...
#
class A
def x
@x * 20
end
end
a.x
200
# Now, in case it is not obvious, I just re-created the x reader member function with
# my own code. However....
# I STILL remain accessing it as a.x, like an attribute. NONE of my other code that
# is using class A needs to be modified!
# What's more... I did it globally to ALL instances of class A.
# Now, doing things globally is a tad dangerous. If this was part of a nuclear
# reactor and class A was a fundamental class in its operation, I could have
# screwed things up. If I wanted to test things locally, I could do something like:
class << a
def new_method
'this exists on a only'
end
end
a.new_method
>> this exists on a only
b = A.new
b.new_method
NoMethodError: undefined method `new_function' for #<A:0x2b9b80bc8d28 @x=10>
from (irb):28
from :0
#
# So you see... my 'a' instance has that method but all other A classes don't.
# Now *THIS* is the power of ruby.
#
For comparison and to show you how poor python is, I'll try to do something similar in it:
class A:
def __init__(self):
self.x = 10
a = A()
a.x
10
#
# Now, here you see how python is already breaking encapsulation and does not
# have any idea of what private is. All your attributes are exposed publicly by default.
# This is DANGEROUS.
#
# Worse, in python you can do:
#
a.xx = 20
#
# And now your instance also has an xx attribute!!!
# So much for proper OO. This breaks COMPLETELY the whole concept of OO, which is
# to keep data private as much as possible within a class.
# A very simple typo in your code in Python can lead a function mis-behave, as you
# just create a new attribute in your instance!!!
#
#
# Okay... now say I've been using the A class for long and realize that instead of x
# I need to change it to return a calculated value.
# I'll try the logical thing first.
#
def x(self):
return self.x * 20
A.x = x
a.x
10
#
# No such luck. Python does not allow me to override the attribute.
# Worse... my x() function is nowhere to be found.
#
a.x()
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: 'int' object is not callable
# Silly python wants to call 10() -- ain't that smart?
# I can work around that by placing it as another function, like:
A.t = x
a.t()
200
# But, you still have the problem that:
a.x
10
# is STILL accessible to outside parties, and all your code would need changing.
# Not good.
#
# The other approach in python is using __getattribute__
# I'll redefine class A to start from scratch now.
#
class A(object):
def __init__(self):
self.x = 10
def __getattribute__(self, attr):
return object.__getattribute__(self, attr ) * 20
a = A()
a.x
200
#
# Now... See all the problems?
# a) Syntax is horrible.
# b) It forces me to make my class inherit from object... what if I had defined it without it?
# c) But worse, the __getattribute__(self, attr) method is a single point of access for
# each and every attribute in the class. Thus, in REAL code, you really need to do:
#
class A(object):
def __init__(self):
self.x = 10
def __getattribute__(self, attr):
if attr == 'x':
return object.__getattribute__(self, attr ) * 20
else:
return object.__getattribute__(self, attr )
#
# You can imagine the nightmare this becomes if you have to re-define many attributes.
# I've seen it and it is not pretty.
#
#
# Thus, in python, this sucks. The only way to work around it in python is to forget
# classes have attributes and always, always access attributes through a method, which,
# btw, cannot be named in the same way as the attribute.
# Thus, your code becomes sprinkled with:
a.x()
a.y()
a.z()
#
# And you attribute names probably become something like self._x instead.
#
#
# Python is not much of an improvement over Java's or C++'s OO, unlike Ruby.
#
Summary (whew it was long): opinions, personal taste, misunderstanding and misinformation. Is ruby community this desperate?
On your side, you mean, right? As Ruby community being desperate, there's no need. We have the best language around and we know it. Other people are just finding out about it, like Linux Journal:
http://www.linuxjournal.com/article/9368
(Scary, as I use about 80% of the applications mentioned there :)
Eventually, something will beat ruby, but it will probably take a while... particularly in the syntax department.
Ruby has good app: rails. Python community did not started smear campaigh agains Rails, but accepted the challenge and created *two* great rails-like frameworks: Django and TurboGears.
Ruby has *MUCH, MUCH* more than rails, as I've shown. Regarding Django and TurboGears, we'll see... After all, I'm still waiting on Zope to become popular :)