[Mono-list] Who is working on the IL VM?

[Martin Coxall]

> The runtime I discussed in my previous message would
> be capable of running both IL and JVM at the same time.
> Mono's architecture isn't capable of that without a
> massive re-design, which would turn it into a clone of
> Portable.NET.

Oh, I see. I was imagining an IL-runtime, a Java-runtime, and then some 
dotGNU layer acting as some kind of request broker intermediating between 
them. You plan to have a single JIT that executes multiple different types of 
bytecode in a pluggable way, and also provides the ability for each to call 
the class libraries of the other? I.e. Java code using .Net classes and vice 
versa?

It sounds very clever if it can be made to work. This is a very good idea, 
yet none of this is made clear in the dotGNU website, and everybody on 
Mono-list thinks you're off doing a parallel effort to us. Perhaps if the 
dotGNU website had a detailed description of how the runtime would work?


> If you want there to be one runtime engine, I couldn't
> agree more. Your mission, should you choose to
> accept it, is to get Miguel to adopt the better solution.
> Have fun.  :-)

It seems to me that it is a better solution, although this is really the 
first I heard about it. If the system you propose is made suitably 
"pluggable", then an IL JIT and a Java Jit shoud just plug in. Perhaps if you 
were concerned more with the pluggable-architecture, and then the Mono IL 
runtime and Kaffe could be slotted in at some later date?

That would, of course, mean that the Mono runtime would have to expose and 
API developed by dotGNU, Mono and Kaffe all working together. Wouldn't that 
be sweet?

> BTW, the CVS tree on http://savannah.gnu.org/ now has
> support for dumping Java .class files using "ildasm".
> I checked it in today.  Support for .jar files and dumping
> the contents of methods are on the way.

Sweet.

> > Both Mono and P.Net wish to have one of these
> > (or am I mistaken?) and certainly should at least be discussing
> > architecture ideas with each other.
>
> What level of architecture?  Code?  API's?  Agreeing
> what to call a namespace?

Well, all levels where possible. From code conventions, to a high-level 
plugging API for dotGNU runtimes (for Mono IL, Kaffe, the as yet vaporous 
PerlPythonVM beats etc.), and especially on the c# class library, where there 
already has been some unnecessary duplication.

> It's up to Miguel to make the next move.  He knows my
> position on the matter: agree to meet in the middle or
> we can't agree at all.  I broke off relations because I got
> tired of seeing weekly postings from Miguel asking
> people to re-invent code I already had.

Well, in respect of writing as much of the code as possible in c#, I 
understand. But on the issue of the class libraries, as well as your very 
interesting proposals for your pluggable-runtime-engine (which really should 
be explained on the dotGNU web pages), we should and could be talking and 
working together.

> Miguel knows my e-mail address.  If you can convince
> him to make an offer to me, all to the better.  Until then,
> I'll keep plugging along in my own inimitable fashion.

Well, that's up to him, of course. But it is worth mentioning that I believe 
that we really are all on the same team, and indeed, Mono is just part of the 
dotGNU project. And we should be working together rather than against each 
other. Even if Miguel doesn't wish to, I am sure there are many working on 
Mono (including myself) who wish to.

---
Martin
---

"Where laughing and smiling are not allowed"