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.

gcjx update

This weekend saw many minor improvements: a round of “fixme”
removal, some internal cleanups I’d meant to do (e.g., caching the
constant-ness of an expression). I also wrote a couple nice warnings
(unused import and use of a static member in a non-static
context), plus I wrote folding code for constant expressions.

So contrary to my plan I ended up just doing general improvements
instead of working on generics.

Politics

I’ve been following the Richard Clarke story with great interest.
I saw him on Charlie Rose and also I got up Sunday to watch Meet the
Press to see what he had to say. I think he comes off as basically
credible, perhaps at times a bit pompous in delivery. And
occasionally I wish he took a stronger stance, for instance being more
forthright that one reason to write a book is to make money. Why not
admit that? I don’t think it would expose any real conflict of
interest; one can tell the truth and make money. Usually 🙂

Tutu

Last night we saw Desmond Tutu give a speech at the local
basketball stadium. He’s an engaging speaker, quite good at it
really. It was a bit annoying, though, since he talks in terms that I
generally don’t agree with; for instance the idea that some people are
“good” and that we can tell the difference between “good” and “evil”
was a main theme of his talk. Likewise that this is God’s world and
that the evil will “bite the dust ignominiously” — nearly an exact
quote.

The simple dualisms and commandments to be “good” seem simplistic
to me. And after reading The Embodied Mind I constantly come back to
the idea that the core of both materialism and dualism is a kind of
alienation or nihilism. Of course Tutu doesn’t let it go there, but
you can see its thumb print all over contemporary culture.

A statement I’m sure we could also find in Ovid or Catullus, if we
were to look. Sub sole nihil…

Anyway I ended up translating his speech internally into my own
terms, which I suppose is a way of destroying it. But his energy was
very positive — motivational and inspiring. And he did say some
things I agreed with, even philosophically.

Maude

My dog Maude (who is kind of stealthily famous, if that isn’t an
outright contradiction) got in a fight the other day. She got bit and
had to have some surgery. Right now she has some tubes sticking out
of her to let the wounds drain. “Frankendog” is the term that fits
best, she has a pretty disturbing appearance.

GCC 3.4 is coming out soon. I think this will, unfortunately, be
the worst gcj release in quite a while. Basically no one worked on
looking at bugs, and it turns out there are some dumb ones in there —
but now it is too late in the release cycle to fix them.

More generally nobody is working on fixing gcj bugs, and gcj is
really in pretty bad shape. Bugzilla doesn’t tell the whole story
here, since nobody has had the time or the heart to file all the Jacks
failures as bugs.

Today I’m depressed about it, probably leakage from other parts
of my life and the fact that I didn’t really sleep last night. I’m
sure tomorrow it won’t affect me quite as much.

McNealy

McNealy says
that Sun won’t open source their Java implementation. No surprise
there — did anyone really expect them to?

Equally dumb is his comment “We’re trying to understand what
problem does it solve that is not already solved”. How about letting
people fix bugs that affect them? How about letting people port to
new platforms? Both of these have come up for me in the last year.
How about growing a community to drive the technology forward faster?
How about sharing development costs among all Java stakeholders,
instead of footing the whole bill yourself?

These reasons and more are why we work to build free systems.

libgcj future

Various Classpath hackers have been pushing the idea of unifying
Classpath even further, perhaps to the point of doing Classpath
releases and having VMs use it unmodified. This is pretty
interesting, I think.

The logical next step is to just erase the different VMs and
decide on a single one. We could put it directly into Classpath.
The fact is, at least for C-based Unix-y VMs, there really isn’t much
difference outside the execution engines. These we could comfortably
leave separate, perhaps following the pluggable JIT talks at FOSDEM.

As Mark points out, libgcj remains the problem child in these
discussions, stubbornly sticking to, as he puts it,
micro-optimizations we’re proud of. In most cases this isn’t far off
the mark.

Lately I’ve been wondering a bit if we should just treat the
standard library like we plan to treat any other Java application.
That is, make the precompiled runtime the bare minimum to bootstrap,
then load the standard library using our binary-compatible shared
library cache.

This has several advantages. First, we could work with a standard
Classpath, at least if we resolved a few issues (placement of native
methods in some cases). Some classes we still couldn’t, or wouldn’t
want to, merge, but that is no big deal — these would just be loaded
by the bootstrap loader and the Classpath versions would be
ignored.

This would let us debug more easily, since we could just point gij
at Classpath. We could even completely decouple libgcj from gcc,
which I’m sure would make many gcc maintainers happy.

Don’t get your hopes up on this actually happening. I’m just
brainstorming.