I have been consulting, developing, and offering training classes in both Ruby and Python for a number of years now — more than 15 years in Python, and more than 7 years in Ruby. Inevitably, when someone from one of my courses hears that I use more than one language, they ask me, “So, which one do you prefer?”
One way to address this is to speak like a parent (which I am), and to give the analogy that just like I love all three of my children equally but differently, I love these two languages equally, but differently. But the most recent time I was answering this question, I asked myself, how do you like them differently? What is appealing about each of these languages? Why do you enjoy working with (and teaching) both of them?
I began to search for analogies that would describe the relationship between Ruby and Python, and the reason why I enjoy working with them both. I would sometimes extend the children analogy, saying that they’re like siblings. But beyond the fact that I’m not their parent, I decided that there were enough differences to make the sibling analogy not quite appropriate. Perhaps it would be most appropriate to call them cousins, or even second cousins.
But then I hit upon another analogy, one which might indicate my age and television-watching habits as a child, but which I think is somewhat apt: The Odd Couple.
I remember the Odd Couple as an American sitcom from the 1970s, broadcast in endless reruns on certain stations, in which two divorced men become roommates and friends, despite their with wildly different habits and outlooks on life. (I should note that the Neil Simon play and movie, upon which the TV series was based, is far darker, and really surprised me when I saw it after years of watching the TV show.)
The viewers aren’t ever expected to prefer neatnik, uptight Felix or sloppy, happy-go-lucky Oscar, but rather to appreciate the differences between the two, and to see a bit of themselves in each character. In some ways — and perhaps more philosophically than was ever intended — the play, movie, and show are there to tell us that there is no one “right” way to approach life, and that each has its advantages and disadvantages. Balance is the key.
The more I think about it, the more I like this analogy, because it speaks to the differences between the languages, and the reasons why I love to work in each of them. Python, not surprisingly, is Felix: It’s clean, crisp, elegant, and engineered precisely. It’s no surprise that Python has been called “executable pseudo-code,” in that I’ve met a very large number of people (many of whom take my courses) who have been working with Python for months without knowing precisely what they were doing.
Python is conservative by nature, and that has served the language well for more than two decades. Indeed, you could argue that the entire 2-to-3 Python upgrade issue, which has been causing ripples of late, is the result of Python betraying this conservative culture, and making a clean break with past versions for the first time in its history. There are parts of Python that drive me crazy, such as len being a builtin function, list.sort not returning a value, the limits on lambda. the need for both tuples and lists, and the way that super works. But every language has its issues, and a very large number of them were improved or removed altogether in Python 3.
But other parts of the language are beautiful, such as the way in which operator overloading is done. Sure, Ruby lets you rewrite + directly, but I think that there’s something about Python’s __add__ which tells newcomers that they should avoid messing with it until they know what they’re doing. I have also grown to love list comprehensions (as well as dictionary and set comprehensions), even though I readily admit that the syntax is difficult for beginners. Also, the Python standard library is just a joy to work with; you can really depend on things working pretty well. And one of the things that people hate at first about Python, namely the required whitespace, is sheer genius in my book. Decorators are also wonderful; while I don’t use them much, they are an elegant and powerful way to intercept function and class definitions, and do all sorts of wild stuff with them.
Ruby, on the other hand, is Oscar: It’s infinitely flexible, messy, and creative — but it works the way you want it to work. Ruby inherited many of the characteristics of Perl, which Larry Wall deliberately meant to be close to natural human language. Sure, it’s a minor miracle that Ruby’s syntax can be described using computers, given its complexity, but that complexity allows me flexibility, creativity, and intellectual excitement that I can’t get elsewhere. Add blocks to the mixture, and you have a language which gives you raw building blocks that allow you to solve problems quickly, easily, and naturally, with less code than would otherwise be necessary. For example, ActiveRecord might have its problems, but I generally love its API and the magic that it performs on my behalf. The way that validations and associations look like declarations (but are actually class methods) is great, making for readable code.
Of course, Ruby has its problems, as well: The object model is elegant and simple — but nearly impossible for newcomers to the language to grasp. (I should know, I teach quite a lot of them.) The fact that everything ends with “end” drives me a bit crazy. So do the differences between procs, lambdas, and blocks. And the “stubby lambda” syntax. But again, every language has its issues and trade-offs, and the ones that Ruby has made are more than reasonable for my work.
Matz has said that Ruby was optimized for programmer happiness, and Avdi Grimm has used the word “joy” to describe programming in Ruby — and I have to agree with both of them. Programming in Python feels more like solving a puzzle, but programming feels more satisfying; I’m unleashing my creative energies, and using the language to solve problems in the way that I want. Python is crisp and demanding, and Ruby is messy and fun. You know, like Felix and Oscar.
Of course, the style of the languages might be very different — but at the end of the day, there’s a lot of overlap between the two. IPython and Pry, PyPi and RubyGems, dicts and hashes, “def initialize” and “def __init__” — if you know Ruby, then learning Python isn’t very difficult, and vice versa. Both are byte compiled, interpreted, object-oriented, strongly typed, dynamic languages. Both have a GIL, which drives people crazy with threading. Both make reflection and metaprogramming easy and natural. Both languages encourage modularization of code, with short functions. Both encourage you to test your code. Both have active open-source communities. And both can be used to solve lots of problems, easily and quickly.
Indeed, the languages are similar enough that I’ve often “stolen” ideas, examples, and exercises from my Python classes for my Ruby classes, and vice versa. And I’ve often thought, when reading the documentation for a method on a built-in Ruby class, that it’s a shame that there’s no Python equivalent… only to discover that there is.
I love Python’s PEP process, which makes it easy for the community to document and discuss changes to the language. And yet, somehow, Ruby has moved from version 1.9 to 2.0 to 2.1 in the last few years, with great improvement on all fronts, without such a clear-cut process. I’m not quite sure how Ruby manages to do it, but it does, and rather impressively.
So, which do I prefer? For Web development, I use Ruby (and Rails or Sinatra). For small projects and problem solving, and sysadmin types of things, I use Python. If I had to do large-scale calculations, then NumPy would make Python a no-brainer. As a first programming language to teach young people, I think that Python is an almost perfect choice. And for mind-twisting, understand-how-languages-work examples, Ruby beats everyone hands down.
At the end of the day, I’m happy to have a foot in each camp, and to be comfortable with both. Because sometimes you want to be Felix, and sometimes you want to be Oscar, and it’s always nice to have to choose between the two.