Selling your future for fame in the present
The Ruby community is in the middle of a kerfuffle about some growing issues. They boil down to three primary issues:
- The growing issue of multiple disparate VM implementations to replace the creaky and absurdly inefficient current Ruby implementation1
- The announcement that Ruby 2.0 would eliminate continuations
- Another announcement for Ruby 2.0 that abandons green threads)
What this seems to illuminate to me is that Ruby is on the cusp of becoming a victim of its own success. The growing attention that Ruby has been getting, primarily driven by Ruby on Rails has introduced an enormous amount of pressure on Matz and the community in general. This is not necessarily going well.
It is important to understand that the promise of a “new implementation” is quite overdue, and given the current issues, is well deserved in its priority. For some reason, largely a result of the general nature of open-source initiatives, there have been a pleathora of new VM implementations, primarily YARV, JRuby and RubyCLR, all of which are going in slightly different directions. This is not necessarily a bad thing, but I fear that “least common denominator” is becoming the norm.
The first place that this concern comes to the fore is with the announcement by Matz that Ruby 2.0 wouldn’t include continuations. Now, the concept of continuations is somewhat foreign to a lot of people, but the power behind the concept drives some of the most advanced systems in existence, and allows for the creation of entirely new flow-control concepts that are entirely too much like a Rube Goldberg contraption without them. Ruby Goldberg, if you want. I understand that few people use continuations, but the power locked inside them is likely to fuel an enormous number of exploratory ideas that may, in the future, illuminate the way to even more success. Don’t sell your future for a bit today.
Finally, the abandonment of user-mode threading, or “green threads,” presents a different problem. The two issues are, quite honestly, intertwined. Continuations are a way to implement user-level threading, as just another control mechanism. Threading is a complex and there is much disagreement, however, it is my experience that the only form of massive threading that works reliably is non-preemptive threading working at the user-level. Predictability is ensured. Mapping green thread pools to native threads is one way to gain some scaling issue, but threading should be considered because of the usability in implementing a design, not performance.
Overall, I’m not too worried, yet, but I do think that there’s a lot of discontent that may grow if some things are pulled out. A middle road would be to say that the first release of Ruby 2.0 would not contain either feature, and perhaps call it Ruby 1.99, but that it will go back in under some time constraint. Ripping expressive power is not the way to succeed. If you do that, you get Java, and end up having to build a baroque mess.
1 The current implementation is enough to give L. Peter Deutsch cold sweats at night. That doesn’t negate it’s usefulness, but it succeeds in spite of the disappointing implementation because of the elegance of the conceptualization. Maybe someone can figure out how to justify putting it on a real VM.
This entry was posted at 5:29 pm on 26 October 2006 and is filed under Ruby. You can follow any responses to this entry through the post-specific RSS 2.0 feed.
Responses are currently closed, but you can trackback from your own site.
[...] Chris Petrilli, provides a rundown of the current situation. And, while these VM efforts are admirable, Patrick Logan calls it like it is: Seriously, Ruby is in dire need of a decent implementation. The JVM and the CLR are fine for what they are, old legacy. But Ruby needs its own modern implementation. [...]