[Ironruby-core] The future of Ruby.NET

M. David Peterson m.david at xmlhacker.com
Wed Feb 6 03:49:46 EST 2008

On Mon, 04 Feb 2008 21:21:07 -0700, M. David Peterson  
<xmlhacker at gmail.com> wrote:

> Expect an extended follow-up from me tomorrow.

It can be difficult to make a clean separation between what truly matters  
in life and what does not, a fact that can be easily seen if you were to  
grab an iPhone out of an iPhone owners hands, throw it to the ground, and  
stomp it into itty bitty pieces. I've been writing code since I was 11 and  
over the course of the 25 years that have since followed I have come to  
understand the fact that the software projects we develop can quickly  
become very much like our own children.

That may sound silly, but the truth of the matter is that we, as humans,  
tend to attach our emotions to things that really don't matter all that  
much.  As software developers the code we write can very easily become a  
part of who we are, a fact easily seen at a tech conference while we watch  
the presenters gush over PowerPoint presentations as if they were pictures  
of their own children (We've all done it, so that's not a statement of  
exclusivity.) For Dr. Kelly and Professor Gough to have created such a  
fantastically wonderful project to then make the determination that it was  
time to turn their attention elsewhere says a lot about their character, a  
decision I believe they should be commended for making.

I think it's important to consider the fact that when it comes down to it,  
Dr. Kelly and Professor Gough are both computer scientists *AND* educators  
at heart. As both their jobs require them to keep an open mind and a  
finger on the pulse of the industry.  I have no doubt in my mind that  
their decision to forego continued involvement with the Ruby.NET project  
to instead work with the IronRuby team was both difficult and painful. But  
ultimately they had to do what was right for not only themselves but for  
the students that look to them for guidance and direction as to where they  
should place the focus of their studies.  As Dr. Kelly mentioned, the DLR  
and IronRuby are here and here to stay.  It's important that the CS  
students of the world understand this and the best way to understand these  
two important projects is to roll up their sleeves and get their hands  

That doesn't mean that the Ruby.NET project should just fold up and die.   
It simply means it was the right decision for them to make, a decision  
that, quite obviously, was not an easy decision to make for either of them.

So then, where from here?

I believe that Ruby.NET is an important project for many reasons, first  
and foremost because it works, works well, and works now.  That said,  
IronRuby and in particular the DLR has completely changed the game for  
dynamic languages on the .NET platform.  We all know that, so there's no  
point in pretending this is not the case.  Ignoring this fact will come  
back to haunt any dynamic language project targeted towards the .NET  

Relating this to Ruby.NET, the answer as to whether or not the Ruby.NET  
project should live on, in my own opinion, is to focus on the fact that  
Ruby.NET works right now and can act as the perfect foundation for .NET  
developers interested in getting their feet wet with Ruby and for Ruby  
developers interested in getting their feet wet with the .NET platform to  
do just that.  In this regard I see Ruby.NET as a way to start this  
process sooner rather than later while at the same time helping to expose  
where the pain points are such that IronRuby can be a better overall  
project as a result.

But there's more to it than that.

As Ted Neward specified,

> I still believe that there is room in the world for both a  
> statically-compiled Ruby and a dynamically-interpreted Ruby on the CLR.

One of the most commonly asked questions on the IronPython development  
list -- IronPython as we all know being the basis of what brought about  
the DLR -- is "Can I write my libraries in Python and then call those  
libraries in my C# or VB.NET code?"  While the answer is a bit more  
complicated than this, for the most part the answer is "Probably not."   
This is one area of the DLR that both the IronPython and IronRuby teams  
have specified would be nice to have, but at present time is a non-goal  
for the 1.0 release of the DLR and the projects based on that release.

In this regard there is a clean separation between what Ruby.NET can offer  
the .NET developer *right now* and what IronRuby *will not* offer the .NET  
developer in the near term future. As such this is one area that I believe  
should be the core focus of the Ruby.NET project moving forward.  But not  
 from the standpoint of creating a competitive Ruby language project for  
the .NET platform -- that would be silly and prideful -- and instead from  
the standpoint of merging the focus of the two projects together in such a  
way that interop between the two code bases is seamless.  In other words,  
and in my own opinion, the purpose of the Ruby.NET project moving forward  
*should not be* one of being a separate project with a separate focus and  

1) a stepping stone for the Ruby language on the .NET platform that Ruby  
and .NET developers alike can use to get started with Ruby development for  
the .NET platform *right now*.
2) a way that someone can take the same code base they write for IronRuby  
and compile that code into a static and reusable assembly that is portable  
and reusable inside of any CLI-compliant language.

I don't think it was by any strange coincidence that when Dr. Kelly  
created this project on Google Code he chose rubydotnetcompiler as the  
project name, as ultimately that's what this project is all about.   
Ultimately and eventually it may turn out that the IronRuby and DLR teams  
decide to enable static compilation.  And maybe they won't, deciding  
instead to focus their time on making the dynamic nature of dynamic  
languages that much more dynamic than would otherwise be the case.

In the mean time, however, there's the *Ruby .NET compiler* project, a  
project in which I believe should follow the direct path of the IronRuby  
team, making it possible to take code targeted for IronRuby, statically  
compile that code, and reuse the static assembly within any other .NET  
code project.  To me, anyway, this is an area of great desire with the  
.NET development communities and as such the perfect focus for moving this  
project forward.

Thoughts from the communities at large?


M. David Peterson
Co-Founder & Chief Architect, 3rd&Urban, LLC
Email: m.david at 3rdandUrban.com | m.david at amp.fm
Mobile: (206) 418-9027
http://3rdandUrban.com | http://amp.fm |  

More information about the Ironruby-core mailing list