[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
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