Confused about the platform runtime discussion going on in the blogs

[aigiskos <aigiskos yahoo com>]

Hi,

Not being a blogger (yet) myself and reading the very
interesting discussions going on between hp, miguel,
lupus, and others regarding managed code, I'm a bit
confused.  Hopefully, someone will be kind enough to
lend me a clue about what's going on (and thanks in
advance!).

It is my understanding that GNOME basically has the
following structure:

----------
|Platform |
----------     -------------------
     | ------- |Language Bindings|
     |         -------------------
     |            |
     \/           \/
----------------------
|Desktop Applications|
----------------------

(Pardon my ASCii art.)  So, as I understand it, the
platform is written in C, which all the languages can
access or "consume," and then application developers
may write the applications in whatever language they
desire.  If I understand the framework correctly, then
we have a unified platform in C and then a diversity
of languages in the applications.  The major
difficulty is that the "consumption" only goes one
way: a nice class written in Python cannot be put into
the platform core, for example.  I believe Bonobo was
meant to solve this problem, but it never really took
off.

So, (and pardon my long-winded introduction) is the
Java vs. Mono debate regarding development of the
platform core or of the application layer?  If it's
the application layer, I'm not sure I see the issue. 
If there is an issue, please let me know. :-)

If it's the core, isn't there a danger of bloat?  I
imagine that the Mono core classes and the Classpath
classes duplicate the functionality of Glib, if
nothing else.  Do we want such duplication in our core
platform?  If we add either Java or Mono into the
platform, will the runtime (virtual machines or cli)
have to be loaded as well?  

hp has mentioned UNO as a nice component solution. 
Perhaps what we really need is a language-neutral
component system to succeed where Bonobo failed.  If
we have lots of components, which can interact no
matter which language they're written in, maybe we
don't have to worry about adding managed code into the
core (and we can swap out components more easily later
on down the line)?

These discussions are interesting and very
thoughtfully presented!  Thanks in advance for helping
me sort out my confusion.

Sincerely,

Andrew




=====
~~~~~~~~~
dissertus scribendo latine videri volo.

__________________________________
Do you Yahoo!?
Yahoo! Finance Tax Center - File online. File on time.
http://taxes.yahoo.com/filing.html