I spent today reading a few threads on JavaLobby. What a sad waste of
time that was! We’ve finally found a place where the typical comment
level is even lower than on SlashDot.

As DV
points out, it sucks that some
folks don’t get it. Even, it turns out, folks who are ostensibly
in our own community.

One question that comes up from time to time is “what good is an
open Java?”. The answer to that is so obvious that we generally just
skip over it, assuming everybody has been following along the last
ten years. Apparently, they haven’t.

So, the story is, any single entity that controls access to the
source will be driven by the incentives that affect them. For
instance in the software market you often see companies moving more
toward enterprise customers, leaving the lower end to be filled by
others. The general idea here, btw, is true regardless of whether we
are talking about open or closed source — for open source the
incentives differ (and of course the consequences differ too, as we’ll
see).

What this implies is that, if you aren’t along the “incentive
path” of the gatekeeping organization, you are in trouble. This is
one reason that open source is useful — it is a way for users to
reduce their risk when adopting technologies, since they have some
ability to solve the problems they face in their “less interesting”
environment.

Another way to be screwed by non-free software is to be working on
an area that is “anti-strategic”. In this scenario, the gatekeeper
decides that supporting your situation is actively against their
interests. Then you are just completely out of luck.

Now, for Java and Linux the way this plays out is that Linux’s
higher rate of change occasionally undermines JVMs. Linux vendors
typically have a hard time shipping a solid JVM on all their supported
platforms in a timely way, especially if there have been changes in
the kernel or libc — floating stacks, SELinux, NPTL, or even more
mundane things.

Considerations like this are what drove us to actually implement
gcj-eclipse (as opposed to just dreaming about it and hacking on it in
my spare time). There simply wasn’t a way to get a working JVM on all
our target platforms on our schedule.

Contrast this with, say, any other piece of the entire operating
system. With free software, you run your own life. If you want to
build an operating system that works on S/390, or PPC64, or whatever,
you can port anything you think is important to it. It might not be
easy, etc, but at least you have the option. Case in point: for the
JVM we had to punt, but for Eclipse we put in the work to make a
64-bit port. So, there’s your value right there.

So far we haven’t really run into the “anti-strategic” scenario in
the Java-on-Linux thing, though I’ve seen various folks predict its
arrival on the assumption that Sun will turn to the IP protection
racket as their technology business slides. If that happens it will
be a nice bit of punctuation to the whole free software saga — sort
of the moral at the end explaining why tying your fate to an
organization whose needs, eventually, diverge from your own.

Dalibor
has some nice things to say on the doomsday scenario of Sun moving
into the protection racket, and some of the goofier aspects of the
SCSL and TCK licenses.

Specific Response

I read through Fleury’s comments again. I’ve debunked most of
this stuff already, I won’t bother doing it again.

gcjx

gcjx development
has been going a bit slow lately. I’m working on fixing anonymous
classes and the capture of final local variables, it is sort of slow
going.

Eclipse 3

I’ve been looking at Eclipse 3.0M8 lately. It seems pretty good
— faster, more eye candy (actually a minus for me, a plus for some I
guess), some handy new compiler knobs. Also it has a built-in code
formatting feature, which can mostly handle GNU Classpath’s style.
I’ll probably check in the style file at some point, meanwhile email
me if you want a copy.