Over the past few days I've been working on implementing my own (yet
another) Ruby interpreter. At first the simple things are easy to
match. With relative ease I was able to throw together modules,
classes, objects, and threads. However, moving further down this path
I am finding that ruby has an very complex trail of details in source
that have very slight but important effects.

If I am to match ruby as close as possible with this project I will
have to have a very deep understanding of the ruby code base.
Unfortunately, I am not able to read Japanese at a productive speed so
the black book is out of the question for a large part of this. The
other option I have is to pool the knowledge of the community to
successfully write a compatible interpreter.

Doing all of this alone would seem like a waste as there are many more
projects that set out to do many of the same things and many more that
would benefit from this information. What I am proposing is a
repository of sorts (a wiki perhaps) where we can maintain a
specification that is separate from implementation. It seems the days
of a single implementation are soon ending. I think this is a good
thing but without proper information we may run into portability
problems.

What do you guys think? Should we embrace a spec driven system or just
continue to use ruby as the reference implementation? Should we
continue our current ways but have a spec as further documentation?

Brian.