From: Son SonOfLilit <sonoflilit@...>
Date: 2006-06-13T16:38:30+09:00
Subject: Ruby as a kernel?

------=_Part_66880_6151230.1150184292817
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: 7bit
Content-Disposition: inline

This forks out of the "Ruby's role in future OSs" thread, since it deals
with something completely different than the discussed there.

When someone suggested a ruby-based kernel, he was responded by "that'd be
taking things too far".

Well, if we consider Moore's law and YAMV, I think it isn't.


I know a ruby kernel would be a desperate effort to continue the M$ policy
of making OSs make up for changes in computer speed and beat Moore, who
works for a competitor ( :P ) but
still, the advantages would be well worth it (depending on ruby being at par
with Java regarding speed):

Development time of apps for an OS who's native API is ruby dinamic objects
would go drastically down. Drastically. It's like developers choosing to use
ruby today even though it's much slower than C, since their time is worth
more than CPU time. Remember how much better ruby itself would be in a
system that would not demand it to interface with un-OOP stuff all the time
(which I feel the most dirty when I do in ruby - it's just not right to
output a file when you have everything as objects).

Such an OS would be naturally reflective, a feature that would make the
world (and especially the business world) a far better and more productive
place.

Everything in such a system would be interdependent is a way that would make
customization a breaze - mixins would provide, for example, natural handling
of "file types" - you just extend the type object to do the services you
want.


Ruby is almost ready: it has natural threading and natural object security.
It only needs /better/ natural object permissions, transparent saving of the
environment on disk and a natural GUI that is done the-Ruby-way (tm)(r)(c).
A way to load C extentions from within ruby in runtime (I mean, write C code
in a ruby text editor, invoke gcc from the editor and dinamically load the
resulting .so) would help, too, and it's almost possible (well, it is, but
not as simple as it should be). From there it would be a matter of months to
create an OS that uses a linux kernel for bootstrap, memory management,
basic disk i/o and networking and ruby for /everything/ else. Such a system
could be programmed easily from within itself using, say VMWare.

Why is it too much?

------=_Part_66880_6151230.1150184292817--