Glad You're Ready. Let's Get Started!

Let us know how we can contact you.

Thank you!

We'll respond shortly.

  • Blog Navigation
Back in the land of the living (or: How RubyMine makes me happy)

How my outlook on coding in Rails has changed over the past few months!

When I made the switch from Java to Rails a few years back, I, like many of my fellow Pivots making that same well-chronicled transition, delighted in the ease with which we could suddenly knock out a web app. How we cheered when our object-relational mapping took zero lines of code! How we applauded when we declared our model object validations in near-English! How we roared with laughter when convention viciously slapped the face of configuration! And how we shook our heads in dismay when we realized that our new development environment appeared to be from the mid-, if not early, nineties.

For, while we had arrived in a brave new world of minimalist declarative meta-programming, rapid prototyping, and an new-found sense of productivity that made even the most nimble forms of Java development look like wading through a morass of slimy boilerplate code and endless XML, we soon realized that the IDE situation was less than awesome. Our productivity was overall much improved, but we had taken a huge step backwards when it came to the act of writing – and especially changing – code and tests. Overnight, we went from living it up in a paradise of automated refactorings, seamlessly inbuilt test runners and powerful debuggers to roughing it with a text editor that, to our spoilt eyes, appeared to offer barely more than code highlighting and support for homemade macros.

Not only didn’t our favorite Java IDE, IntelliJ, not function well with Ruby, but nor did Eclipse, and nor did NetBeans. Early on, each had some nominal support for Ruby, it’s true, but it was mostly just code highlighting and some basic navigation. If we wanted to run a test, we had to (horror of horrors) leave our IDE, go to a shell and run a command (mapping a key to an “external tool” was cold comfort, it seemed to me). If we wanted to rename a variable, we had to do it manually. And if we wanted to debug something, well, the only option was to use a tool that appeared so prehistoric that we simply didn’t do it.

In fact, things were so bad that if we were honest with ourselves, TextMate sometimes looked like a better option that the IDE we knew and loved. We pleaded with Pivots who didn’t come from the world of Java to use IntelliJ, if only (for them) for its awesome global search, and if only (for us) to make ourselves feel comfortable in the new world of Rails. But IntelliJ had been rendered so impotent by its Ruby Kryptonite that it felt at times as if we were simply dragging around a comfort pillow that had lost its stuffing. All the progress that had been made in the world of Java IDEs for so many years seemed to have been lost. Woe was certainly us.

But then came some signs of life. NetBeans and Eclipse (in its various forms) were making progress in Ruby-land: they had test runner integration and debuggers that worked. Big steps forward indeed. While I suspected that I would probably miss IntelliJ, I nevertheless gallantly tried to commit to one of them: if they were going to offer me something even close to the power I used to have in my Java IDE, I was willing to put up with a lot. But despite my best attempts to be patient, I was disappointed time and time again. Eclipse still felt clunky compared to IntelliJ. NetBeans still suffered from a problematic global search and less-than-perfect VCS integration. They are gallant attempts, and they deserve credit. They’re both great products and they both serve communities that no doubt find them invaluable. But in that very unquantifiable, personal, emotional way, they weren’t what I really wanted. I wanted that IntelliJ feel.

So where was JetBrains on this? There was the Ruby plugin for IntelliJ, which was making some great strides forward, but that always felt like a bolt-on solution at best. What was more, it often didn’t work with new IntelliJ updates.

Imagine my surprise and delight, then, when Christmas came several months early this year. Suddenly, in late 2008, we are quietly presented with RubyMine. IntelliJ for Ruby? Surely not! I dared not hope for too much when with some trepidation I downloaded an early pre-EAP candidate a few months ago. But, joy of joys, it turned out that it was, or rather, is gradually becoming, (almost) all I was hoping for. Built-in test runner, debugger, pretty good refactorings – all things that other IDEs provide, but in that special JetBrains way that is so much more intuitive. Great success!

Now, I realize that all this probably sounds like a gush of praise that is not yet due, and perhaps that’s true. It’s certainly true that there’s a long way to go: RubyMine is lacking in many ways. But the signs are there that things are moving hastily in the right direction. Recently, each build that has come out has been noticeably better to me than the last (additional useful features, stability, performance). But more importantly, I feel like JetBrains is on the right trajectory with RubyMine. We now have a path towards a great IDE for Rails. I think we’re back in the land of the living, and I’m hopeful that between Rails and RubyMine our productivity will soon jump higher than we could have imagined just a few years ago.

OK, start the “All you need is Emacs”, “VIM is the best thing ever”, and “TextMate rocks, what’s this IDE nonsense?” comments below :)

  • While I’m one of “those Pivots” who never got the evite to the IDE party, I’ve been trying to maintain a level of editor statesmanship. I’m lousy at it, but at the end of the day, when people can make me say “whoa” when I watch them in their editor of choice, there’s really not much of an argument against that. It’s why I’m playing with Emacs now.

  • I don’t want to be the spoiler but all apps that run in the JVM have massive memory leaks. It’s always something like 200mb/800mb ram in 2GB.

    If those great ides you talk about weren’t build on java maybe they could make the world a better place. But when they keep taking as much memory as the computer as to offer they will end up always being slow and restrictive of a good work flow.

    I like to have a nice console and a simple text editor. I do like the amount of control that exists in knowing exactly what I am doing. I do like textmate for that effect and it’s quite the perfect tool for people that like it this way.

    But I would give a try to a IDE.
    But then do it right. And right means fast, low memory consumption with the same features.

  • Nuno, I hate to break it to you, but my Eclipse 3.4 instance (open for about a week now) is using the same amount of memory (around 500MB, real) as my Safari instance (open for about a day). The JVM is stable and performant on just about any modern machine. You may want to play around with some Java apps besides Azureus. ;)

    And as far as being a memory hog — try searching or editing large files or file with long lines in TextMate. That’s not a leak, it’s an explosion.

    I like TextMate for text editing, but nothing beats an editor which understands the semantics of the language you’re programming in. And right now for Ruby that means NetBeans or RubyMine.

  • You write a blog post without a single link ??? :-)

    I am guessing you are referring to RubyMine by at



  • All you need is emacs

  • Did you give a try to Aptana? To me, it feels comfortable and works pretty well.

  • Edward Hieatt

    @Stephen Wehner Yes, that’s the link.

    @Pat Maddox Nicely done, sir, although to be honest I was expecting that from you within an hour of the post. You’re slipping :)

    @Patrick Lafleur By “Eclipse (in its various forms)” I was including Aptana. I like Eclipse – before I came across IntelliJ I used it (and before that its predecessor VisualAge) for years. I still have a soft spot for it. It’s just that it doesn’t have that slick IntelliJ feel. We should give it credit for being free, of course :)

Share This