Back to Classpath hacking

These days I did finally some more Classpath hacking. The last couple of months, the Classpath project was seemingly undead. That left me in some kind of coding depression πŸ˜‰ But I think that Classpath has it’s own right for existence. There are several reasons why I will continue (and re-energize) my support for this project:

  • The process is completely open for anybody. There are almost no constraints, except for contributors to produce quality code and sign the copyright assignment with the FSF. I understand that it’s necessary for OpenJDK to have a lot of constraints, after all, this is the reference and they have a _much_ broader userbase than Classpath. Also, they don’t seem to believe in free, self-regulating processes, but more in governed, regulated-from-the-top processes.
  • Several projects are using GNU Classpath, and probably will do so for a long time. From the top of my head, there’s GCJ, Kaffe, JamVM, JNode, Jalimo. Cacao has some support for OpenJDK, but this seems very early still.
  • I really have no idea what to hack on OpenJDK. Of course, there’s the occasional bug that I care about, sometimes a fix for something that I come over when trying to intergrate with Jamaica, but that’s pretty much it. It is not really possible for me to add cool new features or something similar, that’s completely caught in complicated processes AFAICS (see above).
  • It’s not really possible to fix bugs quickly, because things are hidden away. Nobody knows what’s already done behind Sun’s walls. Every week or two they throw over code that’s finished, but it’s hard to take part in any development.
  • I believe the Classpath code is slimmer than OpenJDK, and (in my experience) the inter-package-dependencies are not so twisted as in OpenJDK. This seems to make it more suitable for small-footprint and embedded scenarios.
  • Hacking Classpath is so much fun. Even if nobody cares about it, it’s still a satisfying feeling to implement some missing classes here, fix a bug there and be useful for the one user that might be left πŸ˜‰ After all, the ‘Free’ in Classpath means really Free, not the semi-Free of OpenJDK (cool: the code is under a Free license, uncool: most things else is still behind closed doors, and some will surely remain so forever, just because it is OpenJDK and Sun).

In this spirit, I started to implement for Classpath. In the next couple of days we try to get back our JAPI pages, that appear to be broken or at least not updated since over a year (ugh). Also, Andrew announced today the creation of another hybrid project called BrandWeg, that combines Classpath with OpenJDK pieces. Kindof like inverse IcedTea. Also, Andrew continued with his JMX implementation which is really cool. Stefan Huehner seems to contribute lots of cleanup patches and Mario works on his sound API. We are not dead yet! Long live Classpath! Yay! πŸ˜‰


3 Responses to Back to Classpath hacking

  1. Mario Torre says:

    Long live! πŸ™‚

  2. Hi Roman,

    Great blog! Pretty much captures why I’m continuing working on GNU Classpath too. I did a recent JAPI run to see how things were going. You can find it here:

    It’d be great to get builder doing these regularly ASAP.

  3. Pingback: Swing buzz: flying above the radar

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

%d bloggers like this: