During the winter of 2006, I got interested in the implementation of the Smalltalk language. Following discussion with Ryan Davis about Ruby and Smalltalk, I decided to order the Blue Book from Powell’s Books online. The Blue Book is the holy bible of Smalltalk, containing not only a complete introduction to the language, but also a sample implementation of the language itself in the last few chapters. The intention of these chapters was to provide the interested reader some details into how Smalltalk works at the lowest level, so they could use the language well. To my eyes though, it was like opening the face of a watch to see the gears turning. It was amazing, and proved to be the initial spark of life for Rubinius.
Photo by Shane Becker
Over the next few months, I pored over the Blue Book and began writing the foundation of a new way to run ruby code. It was a slow process, as this was the first time I had written almost anything like this. But in time, I had a very basic virtual machine that could execute instructions saved to a file as well as a simple garbage collector to manage objects. At the time, this was all written in Ruby itself, calling out to the OS to do things like allocate and free memory. It was in equal parts incredibly slow and incredibly fun. As the capabilities of the code grew, so did my desire to push it further.
The culmination of the first version happened in November 2006 at RubyConf. I had proposed a talk about Rubinius. Much to my chagrin, it was accepted, meaning that for the first time, people other than myself would see the code and would maybe want to try it. Days before flying from Seattle to Denver, I realized that the only way anyone would want to play with Rubinius was if it was fast enough to perform even the most trivial tasks. This would mean rewriting the lowest bits of code in C. And so as the plane landed in Denver, I hand-ported approximately a third of the basic code from the ruby prototype into C. I worked fast and late the next couple of days and by the time I was giving my first talk on Rubinius, it was nearly ready.
Photo by Shane Becker
Prototype S, as I called it at the time, worked just enough to get a few people excited. As I returned home from RubyConf weary but excited, I found a few emails from people eager to check out the code and see how they could help. This was the first delight of Rubinius. For a long time, I had thought that perhaps my little project was too weird or too silly for anyone else to care about much. Seeing those emails from people asking how they could help showed me for the first time that the project could actually become something real.
Probably the biggest thing to come out of that first presentation was Brian Ford’s creation of RubySpec. We started talking online a few days after RubyConf, and Brian expressed the desire to start writing some kinds of tests or specs that this very early version of Rubinius could use to validate whether or not it was compatible with the existing version of ruby. Under Brian’s direction, this quickly ballooned into a project of its own, providing a solid foundation for Rubinius to move forward.
Photo by Shane Becker
Development of Rubinius then continued in the common manner of open source hobby projects: being worked on part-time by myself and other volunteers whenever we could find time. That all changed at RailsConf 2007 in Portland. My proposal to tell people about Rubinius was again accepted, and much to my continued chagrin, the talk managed to fill a decent-sized room. The next day at the conference, something utterly insane happened. Tom Mornini, the CTO of Engine Yard, approached me to straight up offer me a job: come to work for Engine Yard and we’ll give you time to work on Rubinius. I was effectively between jobs at that time, so I jumped at the opportunity.
Working for Engine Yard on Rubinius has proved to be a dream come true. At first they asked that I help out part-time with sysadmin activities in addition to working on Rubinius, but with the rapidly expanding and changing picture of the company, they quickly recused me of that duty, leaving me to work on Rubinius full-time.
I was in heaven, working from home on a project I loved. Now that I could give it my undivided attention, Rubinius development picked up pretty quickly. Compatibility advanced rapidly, new contributors appeared, and my little project started to really grow into its own.
The next major milestone in the project was Engine Yard’s offer to hire a few more people to help with the project. I leapt at the opportunity even though I didn’t really know much about being a manager. More full-time people would mean we could advance more rapidly on multiple fronts. And so Brian Ford and Wilson Bilkovich were hired and quickly put to work. Brian continued to flesh out RubySpec and Wilson dug into any new code he could get his hands on. Then within the next few months, Eric Hodel and Ryan Davis were hired on as well.
Photo by Aaron Hockley
Photo by Sebastian Delmont
Photo by Ryan Davis
Photo by Sebastian Delmont
With now a five-person team, I started to shift more toward being a manager, trying to figure out how to get the team all on the same page. There were some stumbling blocks, but by and large, things continued to move forward with compatibility. Eero Saynatkari was hired to start work on some Rubinius integration work. We all pushed forward until right before RailsConf 2008, when the project finally managed to run a simple Rails app. Because of the vast amount of compatibility required to do this, it represented a huge milestone, which we were ecstatic to celebrate at RailsConf that year.
The next milestone was a harder decision. Over the previous years, the code base for Rubinius had grown from a simple (rather silly) project into something that was quite a bit larger with a multitude of moving parts. And so, I made the decision to engage in a rewrite of the lowest parts of the project in C++ to clean up and fix a lot of prior bad design decisions. In retrospect, this was definitely a good idea. The C++ code base has proved to be vastly easier to maintain and move forward. But at the time, it was a blow to the team and community, because we were moving backward instead of forward.
Momentum of the project stalled. Then, only a few months later, Engine Yard told me that there simply weren’t the funds to keep a six-person Rubinius team around. So, with a heavy heart, I had to let Wilson, Eric, Ryan, and Eero go. I wrote a blog post to let the community know what happened. This was November 2008.
Photo by Eric Hodel
2009 started as a rather dark period for the project. The team had been reduced significantly, leaving just Brian and myself. Engine Yard still had confidence in us, so all we could do was continue to move forward. The project kept a quiet profile in every way except for the code. Rumblings in the community implied that Rubinius was going nowhere because of lost momentum. In May, I wrote a blog post to answer these claims, reporting that the project was still moving forward toward a fully compatible ruby implementation that was fast.
Things began to brighten again months later, when the Just-In-Time compiler finally started to take shape. This was a very significant move forward, as this piece gave Rubinius something it dearly needed: better performance. Buoyed by this advancement, we rolled into RubyConf 2009 and announced that, finally, Rubinius was nearly ready for a 1.0. Compatibility was there, performance was there, it was time.
I was so pleased by the community reaction. Rubinius, it seemed, had returned from what most people considered certain death and was stronger than ever.
Photo by Shane Becker
The first release candidate was announced on November 25, 2009, a proud day that will be with me forever. When I first tinkering with this project in 2006, I don’t think I had ever dreamed that we’d get to that point, nearly ready to release a 1.0. Over the course of the next few months, we further refined the 1.0 release, fixing bugs and adding missing features.
Finally, on May 14, 2010, 1.0 was released to the world. The response from the community was, for lack of a better word, amazing. I felt like the proudest parent in the world: my little hobby project was growing up, going places I could only dream. Reader, if you take only one impression away from this article, please have it be this: my sincere love for the ruby community. Without their support over the years, there is no way the project would have reached the heights we’re enjoying now.
The post-1.0 world of Rubinius is dazzling. We can take the project to new challenges and new successes. I continue to be the luckiest person in the world.
Photo by Eric Hodel