Re: [SharpOS Developers] MOSA / AOT

[Bruce M. <ill...@gm...>]

The SharpOS AOT is a fantastic machine. And if Chriss is still out there
listening - you have our deepest thanks for jump-starting the project with
it.

However, I am in also in agreement with Phil and Mike, in that, right now,
there is no maintenance on it - I believe that unsaid sentiment is that it
simply isn't maintainable. Everyone here wants to write kernel code. Or user
level code. The AOT is the means to an end - and several people now (through
grover's MOSA efforts, Ensemble, and Cosmos), have proven the basic ability
to compile IL to x86 is not particularly difficult. (Time consuming to
implement, sure. But there is more than enough documentation out there, and
previous works, to make a basic functionality work.)

The problem is, no one can take it that step forward. We need reflection, we
need dynamic runtime bindings, and we need it to be self-hosting. Whether or
not an AOT is re-written, or the current one is re-purposed - we still face
the issue of *how* to bind the kernel code to the AOT.

All of our efforts as a whole, need to address this issue first and
foremost. The good news is, if we can agree - it doesn't matter whose AOT to
work we decide to extend in that direction. Any single one could be the
solution to getting us to the next step. Just like there are standards for
how C compilers and C# compilers and such work - if we can define a standard
on how we want the AOT to handle a kernel - and then all agree to step
forward with that - we can benefit as a group.

And *then*, we can start talking about driver architectures and code
sharing. *shudder*. (I think a "common kernel" is out of the question,
because of licensing decisions as well as varying schools of thought around
here. But at least a common API means we don't have to share core
implementation code.)

Furthermore, I would like to assert that we not overlook JNode. MOSA right
now may just have a couple C# OS projects in it - but JNode has us beat on
the proof-of-concept managed operating system goal. With the proper
allocation of design efforts, we can create a set of standards that does not
preclude using IKVM, in combination with whatever AOT a C# OS project is
using, in order to run JNode driver binaries. It bypasses alot of design and
implementation work in order to get us all into common ground. Without
common ground, we cannot refer to ourselves as seperate projects divergent
from some mystical original ideal. C# is not an ideal. Its a tool. And the
managed bit, well, its already been done. If we are looking to innovate, we
need a jump-start. And then we can talk about re-writes and branches and
optimizations down the road.

I don't think there has been any official talks between SharpOS and JNode.
SharpOS + Ensemble + Cosmos relations are slippery at best. The C# crowd -
all of us - need to get our acts and heads together, under MOSA, (not sure
if Cosmos is still viable, much less, interested in MOSA, but still). With
that done, collectively, we need to rise up to meet JNode, and extend a hand
of friendship.

So, if someone could re-post the information on MOSA (wasn't there a
discussion group or something somewhere?), I would be grateful. We need
start some topics of conversation at a centralized, non-biased location. See
if we can crack our skulls together to get an idea of where to proceed.

But I agree. We will either work together or die together. There are too few
interested and available developers right now for it to be any other way.
And if we allow ourselves to fizzle, we will pollute the water for future
generations that get curious regarding this idea...