This is several rants about the Java programming language in one.
Versioning Confusion
My first rant is on the utterly confusing versioning system used by Sun. Java refers to three things all at once: the Java language, the Java class libraries, and the Java Virtual Machine. Which makes an amount of sense, since the three are closely tied: most application written in Java are compiled into bytecode designed to be used with the Java Virutal Machine (JVM). That's fine.
However, the problem came with release 1.1 of Java, where several changes were all merged into one large version. First, the entire Java AWT library was altered to completely change the way user events were handled by the program. (In other words, the way a program is told "the user clicked on you.") This was a good change, since the previous version - eh, sucked. One very large change was made to the language - the addition of "inner classes" - and several improvements where made to the JVM in regards to improving performance. Java 1.0 to 1.1 was a very major change. (Most of the deprecated methods - methods that are left to allow old programs to run but will be removed in the future - left in the Java spec were deprecated in the 1.0 to 1.1 change.)
Then came "Java 2." Java 2 refers to the class library part of Java - there were no changes to the base language specification and few changes to the JVM. (I believe the standard distribution picked up the "Hotspot" Just In Time compiler for the JVM, designed to improve JVM performance.)
There were many additions in Java 2 class libraries. The addition of Java2D, the addition of Swing as a standard, included library. The new collections utilies. Massive changes in the underlying graphics library resulting in a much more powerful Java graphics library which was many times slower than the 1.1 version.
Except that Java 2 was released as "Java 1.2." In order to download the Java 2 platform, a user must go and download Java 1.2. Shouldn't that be Java 2.0? Apparently not. (Java 2 also introduced a new "doclet" engine, a process that allows documentation to be created about the source code that makes up a Java program.)
Java has progressed further. Java 1.3 brought a new compiler interface, improved graphics performance (but not that improved), and many bug fixes. Java 1.4 again dumps a lot of changes onto the class library.
Off the top of my head: XML parsing, logging (which many complain is poor), non-blocking I/O (a feature many have longed for), improved Windows Swing theme (just in time for the switch to Luna - the name for the Windows XP "look and feel"), greatly improved graphic performance (supposedly), many new Java Beans utilities, and more that I've probably missed.
But 1.3 to 1.4 is still a dot release. No Java 2.0 in site. And when Java 2.0 does get released, will they call it "Java 3?" The versioning is just confusing, especially since many people just assume that the differences between dot releases are just bug fixes. Having to explain that vast new capabilities were added between releases is getting old, fast.
Java 3D
I recently started playing around with the Java 3D API, and have found that it is far more complex than needed for what I had hoped to do with it. All I want to do is have a method of displaying textured polys to the screen in a relatively quick fashion. Unfortunately, I have to learn about "behaviors," the difference between "geometry" and an actual instance "shape," and the strange view structure used to define where the camera is in relation to the scene.
And I'm using Java 3D in the assumption that it would be easier than attempting to create a C application using OpenGL.
Fortunately, they have an "immediate mode" of rendering information. Which means that instead of explicitly adding objects to the scene, you instead have to tell the renderer to render them one at a time. You still don't get to just say "these are the polys, these are the textures, render them."
I'm thinking that it might be easier to just try and use OpenGL in a standard application... except that I'd then have to implement an actual rendering engine. I intend to eventually anyway for use in a very simple game structure, but it would be nice if I didn't have to concern myself with something that appears to be basically a very complicated system for building VR worlds to just display and texture a single model.
But I'll live, I'm sure.
Slashdot's Java Icon
What the hell is that? It looks like a picture of a tea bag in a styrofoam cup containing cocoa. Either that or someone likes very, very little cream in their coffee. And brewing it using those coffee-in-a-tea-bag products. I'd love to know what those marshmallow-looking things are on the far side of the cup. Are they supposed to be bubbles? That doesn't seem right...
Bottom Line
Gotta love Java. I really do. It's a very nice, easy to use, language for creating powerful applications in a fairly easy and platform-independant manor. It has it's flaws, it's not perfect, but it works for what I need it to. Long live Java.