I’ve heard complaints a few times this week about the difficulties
of having multiple different branches and projects. E.g., it is hard
to get into AWT hacking since most development happens on a branch in
the gcc repository, and gcc is large, hard to build, and has a high
barrier to entry (“high” being relative; gcc is certainly more
pedantic than many projects).

Another difficulty is that commits to Classpath aren’t readily
testable. Classpath is sort of a clearinghouse, where various
projects share code — but, importantly, most projects that use
Classpath don’t use it out of the box but instead have their local
changes.

Mark suggests to fix the latter problem by adding an interpreter
to Classpath. You can’t really do this, though. You also need
reflection, class loading, object layout, etc. In the end you wind up
with a virtual machine.

I really think this isn’t a bad way to go. Actually I think it is
inevitable in a sense, since there really isn’t much difference
between virtual machines outside their execution engines and garbage
collectors. (There is also locking stuff, but everybody does thin
locks these days.)

So, what if we had a single virtual machine and left GC and JIT
decisions to the individual projects? That’s the way I’d like to see
things proceed, it is basically an extension of what we talked about
at FOSDEM.

Once I have a bit more time, and once Andrew’s binary
compatibility changes go in, I plan to look more seriously at the
possibility of using an unmodified Classpath with gcj. Which reminds
me — I really want to get Andrew’s patches in as soon as possible,
even if they don’t work, so that we can all look at them and perhaps
help out with testing or whatever. This is pretty important
really.

The Mysterious Bryce

It turns out that Bryce McKinlay is in Colorado this week. With
luck I’ll finally meet him this weekend.

gcjx stuff

gcjx is proceeding well. I find I work on it nearly every day,
after my normal work is finished. I talked to Anthony a bit about it.
He pointed out that one nice approach for getting it in to gcc is to
simply put it on a branch and let everybody see the daily commits to
it. Eventually it would be cemented in everybody’s mind as inevitable
:-).