I haven’t been doing much with Monotone lately, but today I
tried importing the Classpath CVS repository again. It didn’t work,
unfortunately (but expectedly), but it did seem to do better than last
time.

At the moment all that is missing is Attic support (I have a dumb
little patch for this) and support for dead revisions. I looked at
the latter a while back but ended up failing.

This played yesterday at the Conference on World Affairs.
Roger Ebert introduces these showings and always gives a nice talk,
so I try to make it every year. This year I missed most of his talk,
but I stayed for the movie since I heard enough to intrigue me and
since I’d never seen a Renoir film.

This film is widely acclaimed as one of the greats of all time,
perhaps second only to Citizen Kane; in fact it pioneered a technique
or two that showed up later in Kane. I think it takes a certain
skill to watch a movie like this, in that you have to be able to
throw yourself back into the time, to understand the state of the art
of moviemaking as it was then, in order to realize the ground broken
by the film.

I’m not always able to do that, and yesterday I definitely wasn’t,
what with the various distractions of life (i.e., why I was late).
Still, even without the special effort I could see why people praise
this movie. The hunting scene was particularly powerful (I closed my
eyes for parts), and then the way it was echoed later, showing the
various characters to be not only carefree, but careless, was a sort
of grim delight.

Lives out of balance, oblivious to what awaits them in the coming
years.

I really enjoyed this movie. First, a few times during the movie
I forgot that Tom Hanks was playing the main character, which is quite
a feat for a big name actor. Second, I liked his character. I’m a
sucker for a purple phrase, I suppose. I saw the rest of the day
through a more verbose and convoluted lens.

I read this today on the gcc list, courtesy of Mr. Stephan T
Lavavej: “Garbage collection is a morally bankrupt idea”.

I hear this sort of thing from time to time, but rarely so
succinctly. Who knew that programming included moral sub-problems?
And here I thought it was about engineering tradeoffs.

We watched this on DVD this weekend. I found it nearly
unbearable at parts, and about an hour too long. Diane Keaton is
pretty good, I like the way she moves on screen. But otherwise I
found it incomprehensible. First, why would anyone want to date Jack
Nicholson? Second, there were scenes where I literally couldn’t
figure out what the characters were talking about. There’s a scene
where Keaton is trying to get a taxi where the whole conversation
doesn’t make any sense at all.

gcjx can now parse, analyze, and generate code for all of
Classpath. So, huge progress this weekend. I’m not sure what I’m
going to work on next, there are too many choices.

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
:-).

Bad news?

Bad
news for Free Java? It’s hard to say, I suppose it depends on the
details. One key sentence: “This agreement recognizes that cutting
edge R&D and intellectual property protection are the foundation for
the growth and success of our industry.” To me this says that Sun
fears free software more than they fear MS… bad move, Sun. I hope
that this is just some administrative agreement and the actual changes
simply won’t materialize.

Occasionally I think we should just strike off in our own
direction — make a new language and virtual machine for the free
world. This is a lot of work and there are things that make it
unattractive. It isn’t clear we could attain the critical mass
necessary to make it work.

Cooperation

One way to have cooperation between Mono and some Free Java
implementation is, of course, IKVM. Another way would be to take
Mono, parts of IKVM and combine them with the proposed (but still
undocumented, sorry) Pluggable JIT API. Then we could have
gcj-compiled code running inside Mono.

Another idea would be to just write a C#/CIL front end to gcc and
have it target the same runtime that gcj does. Writing a front end
like this really isn’t hard, especially now that tree-ssa is gearing
up to be merged into the gcc main line. This is important because it
means that the tree interface to gcc will finally be documented,
making it much simpler to generate.

Forking

I’ve heard some people, UI hackers mostly, suggest that delegates
are the most important C# feature missing from Java. Personally, like
Sun, I think anonymous classes are just fine for this. But if not,
maybe we in the free world should just extend Java. We could easily
have delegates at the source level map to anonymous classes in the
bytecode.

Likewise I sometimes think about adding something like pinvoke to
gcj. I don’t think it buys you much, either in terms of maintenance
or in performance, but people seem to like it. Sometimes that’s
reason enough to do something.

I guess Sun is right, us crazy free software folks just think
about forking all the time. Shame on me.