
Ask HN: Why Python over Ruby? - costan
I would like to understand why Python is so much more popular than Ruby. Much of the software I've seen supports Python for scripting (e.g. Miro, OpenMoko, XBMC/Boxee), and people don't seem to care so much for Ruby. At the same time, people agree that Ruby is great for writing DSLs.<p>I don't want a flame war or religious arguments. I would like to understand what made Python win in this space. Thanks so much for commenting!
======
zach
Ruby has clever syntax. Python has pure syntax.

Ruby has method aliases. Python does not allow a string to capitalize itself.

Ruby uses Ruby methods within Ruby classes to extend Ruby. Python has
decorators so you can write functions that return functions that return
functions to create a new function.

Ruby has strict object-oriented encapsulation. Python is laid-back about
objects, because you probably know what's going on inside them anyway.

Ruby lets you leave off parentheses so you don't miss objects having
attributes too much. Python will let you mix tabs and spaces for indentation,
but passive-aggressively mess up your scoping as punishment.

Ruby has seven kinds of closures. Python has one, in the unlikely case a list
comprehension won't do.

Ruby's C implementation is a mess of support for language-level flexibility.
Python's C implementation is so clean you get the unsettling thought that you
could probably write Python using C macros.

Ruby supports metaprogramming for cases when programmers find it more
descriptive. Python supports metaprogramming for cases when programmers find
it necessary.

Ruby is expressive. Python is direct.

Ruby is English. Python is Esperanto.

Ruby is verse. Python is prose.

Ruby is beautiful. Python is useful.

I like Python, but coming to it after using Ruby for seven years, well, I
think it's like dog people and cat people. You can like having one species
around, but you're always thinking -- why they can't be more like the other?

~~~
jmillikin
_Ruby has method aliases. Python does not allow a string to capitalize
itself._

    
    
        >>> "hello".capitalize()
        "Hello"
    

_Python has decorators so you can write functions that return functions that
return functions to create a new function._

Or functions that return classes, or classes that use other objects, or any
possible other use for the pattern "wrap this with that and save the result"

 _Python will let you mix tabs and spaces for indentation, but passive-
aggressively mess up your scoping as punishment._

    
    
        $ ./mixed.py
          File "mixed.py", line 3
            print "b"
                    ^
        TabError: inconsistent use of tabs and spaces in indentation

~~~
zach
I should point out that capitalize(), of course, returns a new capitalized
string, just as it does in Ruby. But in Ruby you also have String#capitalize!

And as for indentation, I think Guido should have followed through with making
tabs a syntax error, because they are part of the syntax and are fiendish
sources of error. Let's just say you have this code, properly indented with
spaces:

    
    
        class X:
            def visible(self):
                pass
    

And you open it in a non-Python-aware editor, say for Windows, which has a
four-space tab length and does not convert them to spaces. You add:

    
    
            def invisible(self):
                pass
    

at the end of the file using your tab key. Now you have a potentially crazy-
hard-to-figure-out bug.

~~~
jmillikin
_I should point out that capitalize(), of course, returns a new capitalized
string, just as it does in Ruby. But in Ruby you also have String#capitalize!_

So the quote deals with mutability? I suppose that makes more sense, since
Ruby tends to favor mutable objects. Of course, to my Python-based mind
changing the definition of 'a' or 3 seems like a poor idea.

 _And as for indentation, I think Guido should have followed through with
making tabs a syntax error_

Surely you mean "making spaces a syntax error"? That would be much more
sensible, since using spaces for indentation is absurd. Even better would be
simply ignoring spaces, since that allows them to be used for pretty-printing
and alignment without any potential ambiguity.

Also, the bug in your example will not be difficult to figure out, because
Python will/should raise an exception when parsing the malformed file. Not
everybody runs with -tt, but that ought to be the default behavior (and is
anywhere I get to control the installation).

~~~
ketralnis
> Even better would be simply ignoring spaces

Oh god no. Then you could have blocks that line up visually but execute in
different scopes

------
paulgb
Ruby is slightly newer and wasn't particularly popular in the United States
until it was popularized by Rails.

Python became popular with Linux and open source developers before Ruby did,
and has had slightly more time to develop a nice set of libraries to do just
about anything.

~~~
iamelgringo
May I also add that Python works very nicely on a Windows box. Ruby/Rails
works on Windows, but when I used it, it hobbled around on one leg. Going to
PyCon this past year, I was stunned at how many Windows laptops there were.
Python itself and the Python community are really quite OS agnostic.

The online Python documentation tends to be pretty good. When I picked up Ruby
a year and a half ago, and I tried to find the documentation, people generally
pointed to the pickaxe book as the de facto documentation.

~~~
dublinclontarf
Yes, the pickaxe book or the class docs at ruby-doc.org

Although I've been using Ruby on windows the last few weeks with Ruby Shoes
from _why(normally use for unix scripts or web-dev). It's pretty nice
(although a little rough around the edges as it's under heavy developement).

When you install shoes (the latest version anyway) you get the GUI tools, ruby
gems, and sqlite, and a ruby interpreter, all neatly packaged. And there is a
whole load of items I havent looked at yet. It's fun.

------
knowtheory
What's clear to me reading the comments in this thread, is that there are a
lot of people who like Python, and don't understand what people appreciate in
Ruby.

None of these are reasons why people choose Python over Ruby. Or why Python
has become more popular. It is worth noting that Python was also mentioned a
lot as a teaching tool when its popularity began ramping up, and some
universities have replaced Java and Scheme with Python as an introductory
language.

Python really is not appreciably better than Ruby, in my experience. Nor will
i claim that Ruby is appreciably better than Python. I personally use Ruby in
daily life, and used to use Python prior to discovering Ruby. Both languages
support some really weird warts, inconsistencies, and baggage that they retain
for the sake of backwards compatibility.

Instead they really do provide different philosophies on life. To claim that
Ruby is a tangled soup of options and syntactic sugar is to miss the point
really. Nor is Ruby is not trying to be all things to all people. Matz cares
about one thing, and that's the ability to let programmers get work done with
as few cognitive hurdles sourced from the programming language itself. Does
that mean you have options? Yes. Does that mean that it would be better to
only have one way to do everything? Not necessarily.

~~~
tdavis
_To claim that Ruby is a tangled soup of options and syntactic sugar is to
miss the point really._

What _is_ the point? I sincerely wish to learn, for my own intellectual
curiosity. Because I have read Ruby code and I have done Ruby tutorials and
talked to people who use Ruby and for the life of me, no matter how hard I
meditate on the issue, I cannot understand why anyone would use Ruby over
Python.

I don't feel Python is absolutely better than Ruby, anymore than an apple can
be absolutely better than an orange, but I have yet to gain a comprehension of
how Ruby is even _relatively_ better. From a Python -> Ruby perspective I find
it particularly perplexing.

Ruby presented far more cognitive hurdles for me because it allows you to do
things in ways that seem simultaneously mildly more convenient and completely
counter-intuitive to everything I've experienced with similar styles of
languages over the past 10 years.

~~~
greggraham
I currently use Python and Django for the following reasons: 1) Coworker
familiar with Python 2) I had an easier time understanding the mechanics of
Django than I did Rails 3) Some libraries I needed were only in Python

However, from a language point of view, I have a slight preference towards
Ruby. Here are some things I like: 1) More consistent commitment to object
paradigm, e.g. all function calls are actually method calls on an object. In
Python, everything is an object, but sometimes you use methods, and sometimes
you don't, e.g. list.pop() vs. len(list). 2) I think blocks are very handy. 3)
I like the more Perlish regex syntax. 4) There is a cleverness to Ruby that
might not be the best thing for a corporate environment, but it makes it fun.

So, if I was writing code just for myself, I might choose Ruby over Python,
assuming performance and library support were sufficient.

~~~
ubernostrum
Humor me for a moment, because I've been asking this question of many people
for a long time and have never yet gotten a straight answer.

Why is len() always the thing people pick on? Why is it always "Python uses
len(obj) instead of obj.len()", and never "Python uses str(obj) instead of
obj.str()", or any of the various polymorphic built-ins like sum()? I've seen
this so many times now that I'm honestly quite curious about it.

Also:

"More consistent commitment to object paradigm, e.g. all function calls are
actually method calls on an object."

Every function call in Python is always an invocation of a method on an
object, even if it doesn't look like it. len(), of course, delegates to a
method on the object. But even standalone functions are method calls. Try
this:

>>> def add(x, y):

... return x + y

...

>>> add(3, 5)

8

>>> import types

>>> types.FunctionType.__call__(add, 3, 5)

8

The last couple lines there are what's really going on when you call the
function.

(also, just as Ruby's "built-in" functions are really methods on Kernel which
is made available globally, Python's "built-in" functions really exist in a
module that's made available globally (and __builtins__ is its name)

~~~
earthboundkid
Even without going to the trouble of importing types, every Python callable
has an __call__ method. Including the __call__ method:

    
    
        >>> def f():
        ...  print("Helllo __call__")
        ... 
        >>> f.__call__.__call__.__call__.__call__()
        Helllo __call__
    

Don't use this in real life though, there's a performance penalty.

~~~
ubernostrum
Of course, there's also the singleton that always returns itself:

    
    
      >>> recursive = lambda: recursive

------
tdavis
Python is far more mature, isn't a strange ad-hoc combination of other
languages, has a third-party library to do anything and everything (which is
probably also reasonably mature), and doesn't have a community rife with
arrogant children.

I'm generalizing to some extent, of course, but these are the things that I
and other developers I know associate with Ruby (including many who's startups
are built on it). I imagine as the language and community grow and mature they
will shed these associations and hopefully create a language worth taking
seriously. They haven't done that yet (strictly in my opinion).

~~~
delano
_... a community rife with arrogant children_

It's difficult to accept your rational argument when you include stuff like
this.

~~~
tdavis
Why is that? It can easily be proven. I'm not trying to suggest that
_everyone_ who uses Ruby is an arrogant child as I even have friends who
certainly don't fit that bill, but when you have an especially abrasive
attitude like that within a community, it only takes a minority to sour the
majority.

And while it certainly isn't a fault of the _language_ , it definitely
influences it usage for some people.

~~~
peskytruth
Umm....and have you _ever_ spent anytime time in #python? Some are helpful,
but there are a choice few who I would describe as arrogant children.

In any community of size, you get good seeds and bad seeds. Python is not
immune to this.

~~~
pwang
Actually, for a while I was spending quite a bit of time in #python. I didn't
come across "arrogant children".

Looking at some of the drama and prima donna action in the Rails community
(from a distance) just made me sad and grateful that my corner of Python
(scientific computing) doesn't have those sorts of issues.

------
CyberFonic
For me it's very simple !

I can READ other people's Python code with greater ease than Ruby, Java, C#,
C++ or even C. At the end of the day, the quicker I can assimilate library
code the quicker I can use it well and the quicker the module gets completed
and fully tested. Of course, with Google and Eric Raymond raving about it, the
confidence factor increased further.

~~~
gaius
This is a cultural issue. In the Ruby (or Perl) community, if you use obscure
language features to do a common task in a single line of code, you will be
worshipped as a god. In the Python (or Tcl) community, you will be viewed with
suspicion. Not that Python doesn't have one-liners (e.g. comprehensions) -
just that everyone agrees which ones and when and how to use them.

~~~
knowtheory
I've been working in Ruby for 3 years now, and i can promise you that unclear
code is very much not appreciated by not only the people i work with, but all
of the open source projects i'm involved with.

It is true that Ruby gives you a lot of rope. People with good design sense
appreciate that your code should not be too clever.

~~~
swombat
Agreed. The ultimate goal is clarity. Everything else is subservient to it.

------
Bjoern
Why language X is better of Y makes no sense. Every language has its benefits
and downsides. Python has been slighly longer around and has a bigger user
community which resulted in more available library code. Ruby and Python is
pretty much interchangable in the sense of features as they often steal from
each other and vice versa.

Ruby

\- follows TIMTOWTDI

\- Mutable strings etc.

\- has a greater emphasis on code generation ("meta")

\- VM's are much slower than Python (there is no Psycho etc.)

\- emphasizes code clearity and readabiliy (human cycles are more important)

\- Libraries are much less mature

\- ...

The lists of differences could go on forever. A comparsion and "why" is
difficult. I think they are too similar and the people are too polarized.

A language is a tool to solve a particular problem. In the case of Python you
have higher momentum of the community and the switch from C/C++/Java to Python
is often easier than to Ruby. (Wild statement of me with tests from a sample
set of 2 test subjects ;) )

Probably the best characterization I can come up with is. Python is already on
this "Enterprise" trip where companies use it a lot and so forth. Ruby has
some interesting companies pushing it (Twitter etc.) but is not compeletely
there yet, it still has more "hacker" and "monkeypatch" feeling. Oh wait, we
call that "ninjapatching" in Ruby ;)

~~~
knowtheory
Speed comparisons between Ruby and Python are kind of silly. Ruby 1.9 and
JRuby are (if you look at
[http://shootout.alioth.debian.org/u32/benchmark.php?test=all...](http://shootout.alioth.debian.org/u32/benchmark.php?test=all&lang=yarv&lang2=python&box=1)
) comparably fast to Python, and obviously measure up slightly better against
Python3.

Python is not a radically better choice in terms of speed (and hell that's
true even w/ 1.8. Sure Python's faster, but we're not talking orders of
magnitude here).

------
bdr
I prefer the design of Python over Ruby. I'd be hard pressed to explain why --
something vague about Python being straightforward yet graceful -- but that
aesthetic preference is enough to sway me.

~~~
benhoyt
Me too, but I don't think it's _just_ a preference. I come from a C/C++
background (I'd say the majority of people do, or C# or Java), and Python
looks much more familiar and obvious to me than Ruby.

For example, this from Wikipedia:

    
    
      (3..6).each {|num| puts num }
    

Has some funny brackets and pipes. In Python, it's much more familiar to C-ish
folks like me:

    
    
      for i in range(3, 7):
          print i

~~~
nor-and-or-not
Ruby's syntax is flexible:

    
    
      for i in 3..6 do
        puts i
      end

~~~
johnbender
Very flexible. Once you learn what the sytnax means the implementation of
blocks and iterators is one of the best parts of the language.

    
    
        3.upto(6){ |x| puts x }
    

I don't think the uniqueness of a language is any reason not to learn it. To
be honest that sounds lazy.

PS I'm not a Ruby zealot, and Python is a great language

~~~
bretthoerner
So I just saw 3 ways to print from 3 to 6... are those all used in the wild?

Zen of Python: "There should be one-- and preferably only one --obvious way to
do it."

Sure, there are other ways to do it in Python, but it'd be frowned upon to use
something like 3.upto(6) rather than a standard range() that everyone is used
to. Readability matters.

~~~
carbon8
I'd argue 3.upto(6) is much more readable and obvious than range(3, 7). Even
just on a conceptual level, Python requires a degree of translation and its
stop argument is not intuitive whereas even someone who has never programmed
before can understand the Ruby.

~~~
req2
[http://www.cs.utexas.edu/~EWD/transcriptions/EWD08xx/EWD831....](http://www.cs.utexas.edu/~EWD/transcriptions/EWD08xx/EWD831.html)

------
ghshephard
Speaking purely for myself, the only reason I switched from Perl to Python is
I had a great deal of difficulty understanding the perl code (because I'm a
poor perl scripter) I wrote after a day or so. That, and the language
construct HashOfArrays and ArrayOfHashes is exceedingly difficult to do in
perl without referencing a manual. The only (Edit: Alternative scripting)
language really out there with mindshare in 2001 was Python. I was able to
read my python code. I never had to look at a manual to implement complex data
structures. As a bonus, I can type "help(command) or dir(command) within the
python CLI. I've never really had the need to switch to another environment.
Ruby might actually be 10x better and faster for my typical tasks than python
for all I know.

------
GeneralMaximus
From the Python website:

"Python has been an important part of Google since the beginning, and remains
so as the system grows and evolves. Today dozens of Google engineers use
Python, and we're looking for more people with skills in this language."

When I first saw this, I went "Google? Whoa. I gotta check this out" :)

~~~
skawaii
It is impressive, but beware of cargo culting.

<http://en.wikipedia.org/wiki/Cargo_cult_programming>
<http://weblog.jamisbuck.org/2008/1/7/never-ever-cargo-cult>

------
bcl
I haven't really looked at Ruby that hard, but from my perspective as a
reformed Perl user I found Python's syntax to be very clean and well
organized. On the surface ruby looks more Perl-like to me, more clutter, not
as easy to read as Python.

Having found Python, I really don't feel a pressing need to learn another
scripting language. Instead I'm working on Objective C.

~~~
GeneralMaximus
Although I'm a Python programmer, I urge you to take at least a cursory look
at Ruby. It's actually very different from Perl.

Ruby borrows some stuff from Smalltalk. You know what other language borrows
heavily from Smalltalk? Objective-C :)

~~~
davidw
Part of what makes the difference is cultural. It is of course possible to
write very legible Perl code, but that was, at least for a time, far less
visible than the "cool hack in 1 line of extremely dense code" culture, and
all the "more than one way to do it!" stuff. Ruby can be messy, but there is a
tendency to keep a lid on it.

------
xenophanes
Python is older, and gained popularity before ruby. That's why it's more
established outside of the web development frameworks space.

~~~
bravura
How does python compare to ruby in terms of web development?

I get the impression that there are more 3rd-party libraries in Ruby, so it is
easier to get web code up and running with ruby.

~~~
carbon8
I think this impression comes from the culture of experimentation in Ruby and
more widespread willingness to adopt new tools and libs very quickly. Python
definitely has a diverse web development community and more options in some
areas (like templates), but it's more conservative, not necessarily evolving
as rapidly and, like Python overall, resists influence from other languages.

For instance, Haml and Saas are pretty widely accepted by Ruby web developers,
whereas Django templates are very popular with Python web developers precisely
because because they are close to straight HTML. Ruby developers (like Ruby
itself) readily adopt good ideas from other languages, including Python (rack
from wsgi, rip from pip, merb slices and rails engines from django apps),
while anything that resembles anything from ruby or rails, like some Pylons
components, gets criticized by many python developers. It's noticeable with
version control, too, as svn is still very widely used by Python developers
whereas Ruby and Ruby/Py developers moved completely to git and hg over a year
ago.

~~~
pwang
FWIW, there are lots of Python folks moving to git and hg as well. But I don't
understand what VCS choice has to do with language culture. What's next, a
critique of editor choice? :)

Python is such a large tent that it's quite inaccurate to say that "the Python
culture" lacks a sense of experimentation and adoption of new tools. What you
might be getting at is the fact that there are already so many _existing_
libraries in Python for doing most things that there's not a lot of public
reinvention of wheels going on.

~~~
carbon8
_"FWIW, there are lots of Python folks moving to git and hg as well"_

It's not _remotely_ as universal as it was for Ruby developers. When working
with Python you still can't go a day without hitting an svn repo, but with
Ruby you'd easily not touch one for months.

 _"But I don't understand what VCS choice has to do with language culture."_

A lot, and I already described it. Ruby developers and the Ruby language
overall are less conservative and more open to dramatic change than Python
developers or the language. Each model has its benefits.

 _"'Python is such a large tent that it's quite inaccurate to say that "the
Python culture'"_

It's a large tent, but the common thread is Python and Python's principles,
and they define the culture.

 _"there are already so many existing libraries in Python for doing most
things"_

But individual developers don't do most things, each works on certain things.
Python has lots of libraries, but that doesn't mean it's the best choice for
any specific job. As a web developer, there are a huge number of Python
packages that don't matter at all in that domain. If sheer number of libraries
mattered, we'd all be using perl.

------
ntoshev
Personally I like generators, generator expressions and list comprehensions
much more than the Ruby equivalents (chaining each/filter/etc). Python is
cleaner overall, and if you want metaprogramming you can still do a lot of it.
Also Python has better libraries and runs on App Engine.

~~~
deno
I'm too big fan of iterators, they're great!

Although it's worth noting that Ruby too, runs on GAE using JVM based
implementation (JRuby).

------
davidw
Python got popular earlier - it was already gaining significant converts in
the early part of this millennium, and the later years of the last one. Ruby
only really took off when Rails started to get popular. But it has _really_
taken off, in a way that I think sometimes makes the Python guys (who have
been slowly and steadily gaining ground) a bit jealous.

They're both good languages with good communities though. Each has a few
advantages and disadvantages, but they're similar enough that if you know one
you should probably stick with it and be happy, and pick something farther
from the tree as your next language (Erlang or Scala, say).

~~~
mcella
"But it has really taken off, in a way that I think sometimes makes the Python
guys (who have been slowly and steadily gaining ground) a bit jealous."

Reality seems a bit different to me:

[http://www.tiobe.com/index.php/content/paperinfo/tpci/index....](http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html)

[http://bitworking.org/news/413/ruby-books-sales-a-
retrospect...](http://bitworking.org/news/413/ruby-books-sales-a-
retrospective)

------
lisperforlife
I believe it is more of a personal choice than anything else. That said, here
are the reasons I like Python more than Ruby.

* Namespaces - Ruby has namespaces but when you are reading some code it is very hard to figure out what got mixed into what. This may be more predominant in the Rails world than others. You can exactly know where each one of the classes and methods came from unless you are doing a 'from x import _'

_ Clean code - I know that with most editors today, you can have clean code.
But python's insistence on indentation makes the code appear clean and very
readable. This was an excellent design decision.

* Method and class invocations need () - This view is very subjective. While ruby's method invocation style gives rise to a lot of DSLs, python's style of invocation means that there are no silly Proc objects. If you need to pass a function to another function just send its name. I am not saying that one way is better than the other but I like python's explicitness here.

* OpenStruct by default - This is one of the best design decisions ever. Python uses a very fast implementation of dict for its objects. That means you almost get a javascript kind of object without the clunkiness of javascript.

I am biased a little bit towards python as I learnt python first. I do love
Ruby's DSLs but I have a heart for Clojure too, in this regard. And I am
actually quite happy that Jython 2.5 has come out. I am a little disappointed
that Jim jumped over to the IronPython and left Jython hanging. But thanks to
him, Python is there on all the major platforms.

------
yan
For me personally, it boils down to me liking the library more, the syntax
more and the common programming styles. Ruby is very hard to follow me due to
the (imho) overuse of meta-programming and using language constructs that
obscure the actual meaning of the program. Patching objects and being overly
clever with language features makes ruby code harder to read.

It's also, to me personally, a lot faster to whip something up in Python than
in Ruby, even when I knew them at about the same level.

~~~
xenophanes
I find ruby more intuitive. I learned python first but switched over (not due
to rails, just enjoyed ruby more). It sounds like you are complaining about
the meta programming in the Rails code more than any intrinsic feature of ruby
the language.

------
blasdel
I wish Ruby were good, but it's so fucked:

    
    
      Matz's decision-making process
        He tries to make Ruby be all things to all people
          Lots of confusing sugar and overloading baked in
        I much prefer Guido's hard pragmatism
    
      The pointless panoply of function types: Methods, Blocks, Procs, Lambdas
        All intertwined and yielding into one another.
        I love that in Python there is only one:
          Objects with a __call__ method, defined metacircularly.
    
      The culture of adding/overloading methods on base classes
        Many gems do this en masse, and there are a lot of low-quality gems
          Seriously, Ruby might have a ton of new gems for everything, but they
          are almost universally awful. A culture of sharing any code that *could*
          be a module, no matter how trivial, leads to immature crap being widely
          used because it was there already, with a mess of forks to clean up
          afterwards. At least most of them are test-infected...
            Python does come with a few stinkers, mostly ancient syscall wrappers.
        Especially disastrous because it's unscoped, and infects the whole process
          For a language with four scoping sigils it sure fucks up scope a lot
        The syntax practically begs you to do it, anything else would look shitty
    
      The Matz Ruby Implementation
        The opposite of turtles-all-the-way-down (Smalltalk crushed beneath Perl)
        It actively punishes you for taking advantage of Ruby's strengths
        The standard library is written almost entirely in C
          It doesn't use Ruby message dispatch to call other C code.
          That means that if you overload a built-in, other built-ins won't use it
        Anything fiddly that's not written in C will be dog slow

~~~
CyberFonic
Great comment ! Reminds me of Lisp, a very simple concept that is powerful and
easy to implement and then CommonLisp comes along trying to include
everybody's favourite feature. As a result many people get put off without
digging for the gold.

------
tel
I like Ruby (culturally) more than Python.

Python has NumPy/SciPy/and friends, so I use Python.

This, I feel, is a strong point for most who are using a scripting language to
do scientific work.

~~~
nailer
How do you find Numpy/Scipy on Python compared to statistical languages like
R?

Also what kind of work are you doing?

~~~
mbreese
I don't know about tel, but I use both pretty frequently (and usually together
with rpy). R is great for some things, but I typically find that I need to use
a general purpose language to acquire the data I'm processing. There are some
processing steps that I easier in R though, so I offload things to that when
it is more efficient. But for simpler things, I find that numpy is more than
adequate for processing data that I've already got in a Python session.

I use them for bioinformatics analysis (large scale genomic comparisons and
microarray data analysis). So the larger problem isn't the calculations, it's
the data management. And for that Python wins over a pure R solution.

~~~
tel
That's pretty much exactly how I feel.

I personally love R. More specifically I love how _everything_ is implemented
(at least sketchily) in it. Most specifically, I love how its plots look. If
it could handle the large data sets I'm working with these days (MRI 3D+time
images, sometimes multiple contrasts at once) I would use it a lot more.

So yeah, RPy is another big win for the Python side of things.

------
eznet
For me, it was the 'magic'. Ruby seemed to have a lot of 'magic' working
behind the scenes - which confused the hell out of me when I tried to figure
out how something worked a particular way. Python on the other hand has far
less magic and more transparency - magic replaced with a transparent box
showcasing the logic... Just made it easier for me to wrap my mind around...

------
dylanz
One is not better than the other, and neither have "won".

------
drawkbox
In Python you dont' have to type 'end', just kidding although for some reason
it reminds me of VB for this reason. I wish it didn't but it does. Why have an
end be anymore than 1 character on a serious note, that is lots of keystrokes
extra not needed.

But more seriously Python is a growth like Javascript. It has grown and
adapted to every change it has been required because it has a very rapid
iteration time and is great for wrappers to core C. It is clean and
maintainable.

For this it has made huge inroads to system administration, game development,
tool plugins, web development, command tasks and everything else. I have yet
to have one instance where there weren't numerous libraries for every task.
Even if you don't want to use a third party library there are many examples of
how to do it.

Python is really at it's core many things. It is a functional language, it is
an OO language and it can be procedural. It can wrap intense lower level
libraries or port in a C extension for speed. The same code you wrote for your
desktop api, can be used in a desktop app, a service, website, a web service,
a tool plugin, at the command line or any way you need it.

It can float like a butterfly and sting like a bee.

Like Javascript, Python is based on a core few types, lists and dictionaries
(objects). All the languages that seem to permeate like viruses have this
basic computer science fundamental. It just is as simple and clean as you can
get. Ruby also has this but it came a bit later.

And finally, it is named after the great Monty Python.

~~~
steveklabnik
Just as a quick note, you can use '{' and '}' instead of 'do' and 'end' if you
want. Standard conventions say that one line blocks get {}, and multi-line
ones get do-end.

~~~
peskytruth
Just for blocks/procs. Method definitions still require def/end.

------
bruceh
I've worked with a lot of languages. Python, C++, Scheme (and CLISP), Java,
C#, Perl, Ruby, etc. Every language I've used besides Ruby, I feel that I have
to fight the language to actually implement my idea. The fact that programmers
want flexibility should be obvious by the contortions present in C++ with
boost, particularly the lambda libraries. People are so desperate for
flexibility that they use template metaprogramming. This general impulse
points to programmers wanting better abstraction capabilities. C# and Python
have higher order functions and many other virtues, too. Ultimately, for me I
could do anything I wanted to in Ruby without fighting the language. I'm sure
there are people that have the same personal connection with Python. When I
want the very flexible abstraction--I use Ruby. There are things that out of
practicality I use Python and other languages for. Awhile ago I was
experimenting with fractal terrain generation. The implementation is
procedural, and all using Ruby does is greatly limit the performance of the
program--so I implemented it in C++. I use Python for Bioinformatics research
because of the excellence of Numpy.

------
plaes
Python has IMHO better support for GUI toolkits - Tk support in main library,
PyGTK+, PyQt. And two more words about library - import antigravity :).

And strong company backing: Google has have hired some of the core Python
developers, and some of its infrastructure is written in it... Flumotion with
its streaming media (although codec stuff is mostly gstreamer, but most of the
networking stuff is in Python)

And the final straw - Python just seems to be a bit more beginner friendly...

~~~
wildjim
People should be careful how much they quote Google as their reason for
preferring Python.

The main reason was when they were standardising on the core-languages they
could support, Python was enormously far ahead cf. the competition, so it was
an obvious choice. And now, with all that code investment, you do NOT want to
start again. And if you have the money, of course you'd be interested in
hiring the best developers for your code-base.

Likewise, I believe Python 3000 is unlikely to used in Google for the
forseeable future, due to that same code investment. I don't think Python 2.6
is fully supported, either...

I don't think "a bit more beginner friendly" is truly accurate. Most beginners
will look for doc's and books, and for a good few years, recently, there was a
dearth of good Python books while there seemed to be a new Ruby or Rails book
every month, including several allowing you to d/l them for free.

I have to admit that I used to recommend Python to beginners for a long time,
as it helped them avoid developing bad habits with the other equally popular
"beginner" PHP and Visual Basic languages. These days, it's a toss-up.

If the person talks about writing web-apps, I'll tend to recommend Ruby and
Rails as it has earlier ROI for a beginner, therefore a lot initially more
satisfying.

~~~
colins_pride
This is somewhat tangential, but I'm pretty sure that Google re-writes the
search code ever few years.

~~~
peskytruth
Yeah? Well, none of that search code is written in Python. It's C/C++.

See: [http://stackoverflow.com/questions/754301/what-
programming-l...](http://stackoverflow.com/questions/754301/what-programming-
language-is-google-written-in)
[http://stackoverflow.com/questions/923225/does-google-use-
py...](http://stackoverflow.com/questions/923225/does-google-use-python-for-
anything-but-internal-utilities-and-administration)

------
woid
I have been using Python for about year for Google App Engine projects. I have
been using Ruby for about two years for various personal open-source projects.
I like both languages, but I prefer Ruby over Python.

I hate Python's neglect (by Zed Shaw):
<http://www.zedshaw.com/blog/2009-05-29.html>

Ruby seems to be so much more "symmetric", Python feels like a hack on top of
dictionary to me.

~~~
gaius
_What I will blame Python for is the lack of even the most basic time
conversion features that even C has. If all they did was give me the exact
same POSIX C API I’d be happy. Instead, I got some half-assed library and some
half-assed rationale about why this is a better way to do it._

Ermm, datetime.strptime and datetime.strftime?

------
Wheat
Any popularity in Python over Ruby stems largely from the fact that Python
came first.

I've heard Python developer's working on a Ruby on Rails application that the
problem with Ruby is that approximately equivalent to Python in terms of
productivity. They wanted to use Python, but pragmatically you can't make the
case to management to switch from one language to the other if the other
language is more or less the same. But most of the time this effect works the
other way around, where Python was established before Ruby.

I was doing Perl in 1999, and looked at switching to Ruby or Python. Python
was still quite small back then, but you had web frameworks (Zope, Twisted),
albeit the incarnations back then are clunky by today's standards, but Python
was establishing itself as a clean, readable, dynamic language. Ruby on the
other hand had no web frameworks, and almost no documentation in English - the
only reason I was considering it was because I was working with a Japanese
localization team and they thought Ruby was quite hot.

The debate over which dynamic or scripting language to use was always between
Perl and Python back then. Perl was the incumbent and Python the challenger,
Ruby rarely factored into the picture. It wasn't until Rails started to become
useable and gain attention in 2004 and 2005 that Ruby interest started to
really blossom. And so Python was well established for many uses: scientific
computing, ad-hoc data processing, network programming. If you're a
development manager of an application that you want to make scriptable, you
would have made the decision to already go with Python, there just isn't any
compelling reason to switch to Ruby beyond the sake of switching.

Another example is IronPython versus IronRuby: work started on IronPython in
2003, work started on IronRuby in 2007. IronPython is at version 2.0, while
IronRuby is at version 0.5, and this is reflected in the polish of these
language implementations. A .Net developer might decide that they prefer the
idiosyncracies of Ruby over Python's idiosyncracies, but if they had to start
a large project in today, they'd most likely choose IronPython since there is
much less risk of the project bumping up against the rough edges of IronPython
versus IronRuby.

------
sethg
Just my personal story, but perhaps extrapolating from it will help answer
your question.

At my job I use Python because, well, at some point before I arrived one of
the senior developers went on a jihad against Perl. :-)

I've read stuff about Ruby and while some things about the language intrigue
me, it seems that any application you can build with Ruby can also be built
with Python. If I'm going to learn another programming language in my Copious
Free Time, I want to learn something _really different_ from what I already
know, not something that has pretty much the same features with different
syntax and libraries. So Python wins by inertia.

------
me_again
Most of the discussion seems to ignore the "in this space" (scripting existing
software packages) part of your question.

I submit that Python is more popular in this space because:

\- many end users will be users of the package first, and programmers very
much second. In this case a very gentle learning curve is more important than
ultimate expressivity for hackers.

\- In the same vein, it superficially looks more like BASIC than Ruby does

\- The C API may be simpler to use than the Ruby interpreter, though never
having used Ruby's C API that's speculation on my part. Never understimate
implementor laziness as a technical driver.

------
mannicken
I chose Ruby mainly because of all the syntactic tricks and weirdness but
despite slowness.

You might choose Python for exactly the same reason; e.g., I wouldn't use Ruby
on teams with >2 developers, especially in Google. Python is more
straightforward but at a (small) price of freedom.

Example: you can rapidly prototype in Ruby using blocks and extend basic
classes (even integer) using monkeypatching. I was fascinated by this, yet I
wouldn't monkeypatch when working with other people so that advantage goes out
of the window.

------
ianb
I think it's mostly about maturity, of the runtime, of the language, and of
the community.

For example, Ruby has backward incompatibility issues in minor releases that
would never be permitted in Python. They had to jump to Python 3 for even
fairly small things that wouldn't be accepted in the 2.x line. Even subtle
incompatibilities between Python versions are taken seriously, and there's a
documented process for deprecation that involves multiple releases and means
when a feature is deprecated it'll probably still be available for years.
There's cruft in the language as a result, but for people using Python
seriously this is more than worth it.

I think the Python-Dev community is also more mature. Changes get serious
review. Though there's not a formal "core", strong objections from certain
people are enough to bring a new feature back to zero and require a restart
(not because those people have special weight, but because they are respected
and everyone kind of understands there's a benefit to listening to crotchedy
naysayers if they are smart crotchedy naysayers).

The community is large enough that there's a lot of domain knowledge. Python
is better at getting a canonical and complete solution to a domain problem
than Ruby. WSGI discussions for instance involved some people with a very
intimate knowledge of HTTP. People work hard to get 95% solutions instead of
80% solutions. In part because Python has been around a long time, and there's
already at least an 80% solution for whatever problem you are looking at, and
if you are going to throw your hat in the ring you ought to be ready to try
harder. I think the more aesthetic tendencies of the Ruby community work
against it here, as people are more likely to rewrite for aesthetic rather
than functional reasons. (OTOH, when Python settled early on some 80%
solutions, it's caused a lot of difficulties because it's been hard to
overcome inertia to introduce a better solution, while it's hard to get really
good adoption of the 80% solution; pydoc would be an example.)

Then there's simple maturity. The VM is more stable; it may not be a great VM,
but it is predictable. There's lots of tools for writing extensions. There's
code for dealing with large data sets, for dealing with images, for accessing
system libraries, etc. For any one problem Ruby might work fine, but for the
problems you don't yet know you'll have to solve it's less likely you'll hit a
blocker with Python.

~~~
pwang
Ian B., aren't you occasionally one of those crochety naysayers? :)

------
mahmud
They're both equally Greenspuned to usefulness.

------
JeremyChase
One major problem with Ruby has been that the performance as been _much_
slower than Python. This is no longer true with Ruby 1.9. I happen to have
done a benchmark using a recursive Fibonacci algorithm yesterday, results:
<http://pastie.org/528717> source: <http://pastie.org/528720>

I wouldn't say Ruby has lost just yet.

~~~
buugs
I don't think performance is holding ruby back I think that libraries
especially mature and massive libraries, or lack thereof, is holding ruby
back. Not to say people aren't working on it give ruby some time it will
probably catch up especially with rails but just not right away.

~~~
JeremyChase
Performance has always been a finger in Ruby's eye, but with 1.9 that doesn't
seem the case.

Regarding libraries; you are right. Ruby has a lot of code out there, but much
of it is in random repositories maintained by random people. Hopefully this
changes.

~~~
ptomato
Though it must be said, rubygems is _miles_ ahead of anything available for
python.

~~~
caffeine
I'm not convinced that's true, as the depth and quality of rubygems are
inferior to the depth and quality of eggs available in python. Find me e.g. a
"gem install scipy" equivalent for Ruby.

 _However_ \- "easy_ _un_ install scipy" REALLY needs to work!

~~~
ptomato
My point precisely. I was referring to the package management system being
better, not necessarily the packages available.

------
mikewoodhouse
When you say "win", are you meaning in the sense of "there can only be one"?

Why limit the discussion to Python and Ruby? Why not include PHP, say? Why
have Python and Ruby "lost" to PHP? What about C++, Java and C#?

Heck, VB is still more "popular" than either:
[http://www.tiobe.com/index.php/content/paperinfo/tpci/index....](http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html)

~~~
costan
I wanted to understand the factors that led to a particular outcome: Python
becoming the de-facto winner for scripting applications.

I compared to Ruby, because that's the language I would choose for scripting,
based on the ability to create nice internal DSLs.

------
nailer
Having used Python a while, unnecessarily marking out statements a second time
for the computer using brackets is a waste of time, and ugly. I use older
faster languages and put up with this, but don't see the point of doing so
with Ruby.

Nearly all of the installers and packaging formats and management tools in
Linux have Python APIs.

Edited as I wasn't clear the first time round: I love Python's wide variety
string methods, and the emphasis people put on these rather than using RegExs
all the time (sorry, I have more Perl and less of a Ruby background). Looking
further it seems there's Ruby equivalents of most of my frequently used
methods.

I love etrees in the standard library. People who use regexs for dealing with
tree structured data are mental. Again, perhaps a Roby fan might enlighten me
if there's a similar data structure in Ruby, I wouldn't be surprised.

~~~
sho
_"I love string methods. Not sure if Ruby also has them"_

What do you mean? Of course Ruby has a String class and plenty of methods on
it, but I'm not sure if that's what you're talking about.

Ruby comes with an XML library standard, sure, but it's pretty bad. In my
experience most people use competing libraries, of which there are several
high quality options. You can get a walkable tree from the core library but
you'd be better off with one of the superior third-party libraries like
hpricot or nokogiri.

(edited badly written original)

~~~
nailer
You're right, that was ambiguous, I've edited my post to clarify.

The behavior I'm referring to is loading XML into a tree shaped data
structure, so you can reference particular branches when seeking or adding
content, and not have to think about about tags (well, once you'veran it
though BeautifulSoup or a similar cleaner).

~~~
sho
That's OK, my reply was also pretty ambiguous :D

I am not really familiar enough with Python to say for sure but from what I
know, XML libraries are probably superior on the Python side - in fact most
"enterprise" interoperability libraries are probably better, or at least more
mature. The situation on the Ruby side is improving rapidly, but given its
history, yeah, many things like that are probably a little behind. Ask again
in a couple of years!

The flipside of this, though, is that everything in Ruby is currently in a
state of flux. The "winner" of the libraries is constantly changing and the
rate of progress is actually quite staggering. There's excitement, momentum
and willingness to embrace new ideas in the Ruby community that seems to
exceed Python's.

So yeah. If you want stable, mature libraries that you can rely on for the
next 5 years, Ruby is probably not the choice for you right now. If you want,
however, to constantly live on "the edge" and see, say, 5 competing interfaces
to the latest DB come out within days of its alpha release then Ruby's the go.

This is all fairly minor though - they're both great languages with great
communities, I don't get all this "A vs. B" nonsense. There are certain
libraries in Python that I wish were available in Ruby. There are certain
libraries I like in Ruby that I know are not available in Python. My advice to
a novice would be to choose the one whose syntax they prefer.

~~~
nailer
Python has similar issues tho - look at unit testing. The standard library has
unittest, everyone prefers nose.

------
al3
Using edge cases in the syntax to construct an API with unusual calling
conventions is not "writing a DSL." Unless you build a compiler/translator for
it, it is not a "DSL," it is plain-old Ruby, happily accepted by any
conforming Ruby implementation--nothing more.

After their pretentiousness, their arrogance, and their vociferous
obnoxiousness, I find their misuse of this once-widely understood term to be
their most annoying attribute. It seems like not a day goes by without some
eager Ruby programmer hacking together yet another block-based API that kind
of, sort of looks like Smalltalk if you squint enough, uploading it to GitHub
or some similar site, and then slapping the "DSL" label on it, because Ruby,
apparently, is just too cool and powerful a language to have mere "libraries"
or "APIs."

~~~
knowtheory
What is this, bring out the Trolls day?

Ruby does in fact both have libraries and APIs (hyperbole aside). But none of
what you've described is a reason why Python has become more prevalent than
Ruby. This is just your personal bone to pick over _nomenclature_ used by the
Ruby community.

Rails is not the only piece of software in the Ruby community, and definitely
not the most well designed (although it too is being improved significantly
both in consistency and cleanliness in the push to 3.0).

------
jlees
Both have their uses. I was a Perl hacker so Python was the obvious choice for
me - but I would use Ruby for specific projects, for example if I desperately
wanted a one-off app that primarily depended on a stable Ruby library where no
Python one existed.

~~~
jamesbritt
"I was a Perl hacker so Python was the obvious choice for me"

Interesting. I was a Perl hacker, and Ruby was the obvious choice for me.

------
cmars232
Ruby feels like all the misery of Perl mashed into Smalltalk. Which is a
shame, because I hear such good things about Smalltalk.

------
Bogdanp
<http://xkcd.com/353/> I need no other reason.

------
brueno2009
python is easy to learn like php and ruby have sometimes strange looking
syntax like perl for newbies. A good programmer doesn't have this problem and
will love the goodies and syntactic sugar from ruby.

~~~
kuzux
php syntax is much more perl-y than ruby

------
chl
NumPy.

------
dolzenko
Google SketchUp is scripted in Ruby

------
ilyak
For embedding and scripting, I'd take python too. It'a s known value here, and
I've heard ruby isn't so much.

When NOT talking about embedding or scripting, I'll probably take ruby.

------
c00p3r
1\. Get latest OpenSolaris. 2\. Install latest SunStudio 3\. download latest
source of Python (3.1) and Ruby (1.9.1). 4\. Try to build them with
CC=/opt/SUNWspro/bin/cc" CFLAGS="-m64" 5\. See the results. Run make test for
ruby.

~~~
nailer
So Ruby compiles cleaner on failed Unix OSs?

~~~
c00p3r
No. Its standard modules were coded more portable way.

btw, Solaris will stay on its niche like FreeBSD.

~~~
nailer
10 years ago Solaris' niche was being the standard OS at financial services
companies. These days, that standard is Linux, generally Red Hat - nobody's
buying SPARC anymore and Solaris on Intel runs very few apps. The largest
hedge fund, the top tier investment banks, and the top retail banks have all
abandoned Solaris. The only new purchases from Sun are support contracts on
ancient kit that's still waiting to be replaced.

