Java2 SDK v. 1.4 Released

pangloss writes: "Yay: XML, built-in Perl-ish regex, jdbc 3.0, asserts, IPv6, lots of other goodies. Release notes and incompatibilities. And I think this means I can use my wheel-mouse in NetBeans without that extra module ;) Download it here." WilsonSD adds: "There are many cool new features including a New I/O package, an Assert Facility and enhanced performance." Some other random Java notes: O'Reilly has an essay about why you won't see any open source J2EE implementations, and Kodak has filed a patent-infringement claim against Sun regarding Java.

Comments

It's a big step up, but there is still distance

[btempleton]

I've been working on a server that takes a lot of connections in Java, and you can finally do it with the support of "select" in Java 1.4. But no support for SSL. I undertand why it happens, but this "we'll get around to doing the security later" is why we don't have a lot of security.

Java will always present a dilemma. With the push for portability, you often have to wait for the platform itself to support things like this (select) or kludge it in very non portable ways. But that portability leaves the system behind which hurts it in competition with other systems more tolerant of innovation and the fracturing it brings.

A good philosophy would be to rule that every time a system library or feature needs to do something that an ordinary user can't do, they don't just build it in, they make a way that an ordinary user could write it. That paves the way for more innovation.

Re:It's a big step up, but there is still distance

[Wraithlyn]

"I've been working on a server that takes a lot of connections in Java, and you can finally do it with the support of "select" in Java 1.4."

I've been using NBIO (Non-Blocking IO) for quite some time, getting very good results. Been waiting for Java 1.4 to go final so I can start working with java.nio

Re:It's a big step up, but there is still distance

[blamanj]

It's worth noting that the Berkeley NBIO package was part of the research that led to the 1.4 java.nio package.

Also, using their package, and a very interesting partitioned, event-based coding style, they wrote, in Java, a web server that out performs Apache (written in C).

Re:Yah, will this be stable on Linux?

[RMSIsAnIdiot]

Of course it will be stable. Everything is stable under L---

kernel: VFS: Disk change detected on device fd(2,0)
kernel: end_request: I/O error, dev 02:00 (floppy), sector 0
kernel: VFS: Disk change detected on device fd(2,0)
kernel: end_request: I/O error, dev 02:00 (floppy), sector 0
kernel: Incorrect segment count at 0xc01781d6nr_segments is 15
kernel: counted segments is 17
kernel: Flags 0 0
kernel: Segment 0xc37ace40, blocks 4, addr 0x4bd1fff
kernel: Segment 0xc37acea0, blocks 4, addr 0x4bd27ff
kernel: Segment 0xc37ac780, blocks 4, addr 0x38abfff
kernel: Segment 0xc37acde0, blocks 4, addr 0x38ac7ff
kernel: Segment 0xc3809120, blocks 4, addr 0x1e77fff
kernel: Segment 0xc0e0fda0, blocks 4, addr 0x199c7ff
kernel: Segment 0xc3871ec0, blocks 4, addr 0x6fe2fff
kernel: Segment 0xc3871f20, blocks 4, addr 0x6fe37ff
kernel: Segment 0xc3871e00, blocks 4, addr 0x498afff
kernel: Segment 0xc0e0fec0, blocks 4, addr 0x18aefff
kernel: Segment 0xc3871c80, blocks 4, addr 0x41b6fff
kernel: Segment 0xc3871ce0, blocks 4, addr 0x41b77ff
kernel: Segment 0xc3871b60, blocks 4, addr 0x1d06fff
kernel: Segment 0xc0e0fe60, blocks 4, addr 0x18af7ff
kernel: Segment 0xc38719e0, blocks 4, addr 0x4c3ffff
kernel: Segment 0xc3871aa0, blocks 4, addr 0x4c407ff
kernel: Segment 0xc0e0ff20, blocks 4, addr 0x18ae7ff
kernel: Segment 0xc3871800, blocks 4, addr 0x4cb0fff
kernel: Segment 0xc3871860, blocks 4, addr 0x4cb17ff
kernel: Segment 0xc3871140, blocks 4, addr 0x4b8ffff
kernel: Segment 0xc38717a0, blocks 4, addr 0x4b907ff
kernel: Segment 0xc0e150c0, blocks 4, addr 0x196d7ff
kernel: Kernel panic: Ththththaats all folks. Too dangerous to continue.
kernel:
kernel: rq->cmd=1, rq->sector=73208, rq->nr_sectors=8
kernel: kernel BUG at pktcdvd.c:1046!
kernel: invalid operand: 0000
kernel: CPU: 0
kernel: EIP: 0010:[serial:__insmod_serial_S.bss_L3392+238989/37 155027]
kernel: EFLAGS: 00010086
kernel: eax: 0000001e ebx: c1273840 ecx: c4676000 edx: c020f384
kernel: esi: c208f09c edi: c208f074 ebp: c7f9d760 esp: c6fc3f88
kernel: ds: 0018 es: 0018 ss: 0018
kernel: Process pktcdvd0 (pid: 1303, stackpage=c6fc3000)
kernel: Stack: c8861c10 c8861d2f 00000416 c6fc2000 c208f09c c208f074 c208f000 c7f9d86c
kernel: c8860076 c208f074 00000f00 c762df1c c208f000 00000b00 c6fc3fe0 c208f008
kernel: c208f10c c7f9d778 00000000 c6fc2000 00000000 00000000 00000000 c6fc2000
kernel: Call Trace: [serial:__insmod_serial_S.bss_L3392+245712/3714830 4] [serial:__insmod_serial_S.bss_L3392+245999/3714801 7] [serial:__insmod_serial_S.bss_L3392+238646/3715537 0] [kernel_thread+40/56]
kernel:
kernel: Code: 0f 0b 83 c4 0c b8 06 00 00 00 0f ab 45 48 19 c0 85 c0 75 24

Summary of new features

[LarsWestergren]

A summary of all the new features is available here:
http://java.sun.com/j2se/1.4/docs/relnotes/feature s.html

Articles about the news APIs and how to use them available here:
http://java.sun.com/j2se/1.4/articles.html

Coincidence?

[Yakman]

I find it funny that the post mentions a lawsuit from Kodak and the O'Reilly essay about Java says:

[...] At the same time, Sun loves to have Kodak moments with some parts of the open source community -- most notably, Apache -- who increasingly feel used and abused [...]

(Emphasis mine) Heh.

Asserts

[Malc]

This makes me so happy. Coming from C++, I really really missed assertions. They give me much more confidence in my code. Some people seem to have trouble using them, but after a while they can become second nature. In fact, one can come to rely very heavily on them.

Re:Asserts

[Anonymous Coward]

Yes. Asserts are easy to use and have a huge payoff. They are especially good at catching nasty subtle bugs.

They are easy; they catch bugs that might not otherwise ever be noticed (or noticed only as some pervasive flakiness); they save you a lot of time that would otherwise be spent debuging; they are good documentation; they don't cost anything in non-debug builds; they save you from a lot of pain. Despite all this, I haven't yet successfully convinced a single person who is unfamiliar with them of their value. Christ I get dismayed sometimes.

This interview with FreeBSD kernel hacker Matt Dillon has some interesting things to say about assertions ("it greatly contributed to our famed stability in 4.0 and later releases [of the FreeBSD kernel]").

Java finally has them? Cool. What year is it again? 2002? Jeez ...

Genericity?

[hephro]

And still no generic data structures (a.k.a. templates in the C++ world)... all those explicit downcasts from Object hurt and need to be optimized away by the JIT...

-Hein

Re:Genericity?

[srichman]

1.5

Re:Genericity?

[Twylite]

Java will support parametised types, not templates. C++'s solution is a hack, and most people know that. True language (and VM) support for parametised types will not involve any binary bloat. In a way you can think of it as having a "object type" attribute and doing an "instanceof" to check that the type is right.

Re:Genericity?

[khuber]

1.5 [javaworld.com]

The 1.5 Java generics are merely syntactic sugar. Since the casts still occur, there is no performance benefit, only cleaner source code. There is no way to parameterize primitive types like int.

I do not consider the proposed generics to be adequate. You are still better off, performance wise, generating your own custom collections for specific types. This is what GNU trove does.

-Kevin

Re:Genericity?

[Elbows]

On large projects it can be a big issue. Someone
puts an instance of class X in a vector that's
really meant to be holding class Y. No exception
is thrown until you access the bad data and try
to cast it to a Y, at which point there's no good
way to find out where the error occurred.

Now you have to dig through 100k lines of code
to find the mistake. With generics it's caught at
compile-time.

That said, generics should be implemented so as
to give you performance, too. If you know
everything in a collection is an X, there's no
reason to do any casting at all.

64 bit - wow!

[Florian Weimer]

The 4 GB address space limit has become a severe limit on Java bloat. It's good to see that Sun finally addresses this problem.

J2SDK on Win98 and Linux

[Larkfellow]

I have a dual boot machine at home, one partition Windows 98, the other Slackware 8.0. Today I downloaded and installed the new Java SDK 1.4.0-rc on both systems. And while I think that some iscolated windows difficulties causes my oppinion to be rather biased, I found the install much easier going on Linux.

However I will note that, while the Java Web Start was installed on Windows, I didn't find any version of it for linux. And the downside to the Web Start I found is that it constantly wanted to download and install a new version of Java Runtime Environment 1.3.x everytime I lauched an application. And then after the download, and installed, I'm prompted to reboot the computer. After rebooting and trying to launch again, it again starts to download JRE 1.3.x and through the whole cycle all over again.

As well, with my windows install I found I was constantly having difficulties getting it to use the default classpath (ie, no environment variable set for CLASSPATH). I ended up having to resort to specifying the classpath at the command line. And no matter how much I tried, I could no manage to get Swing to work properly.

However on the other hand, the Linux install was rather straight forward, with a few simple steps: Change download to executable; Run it; move the extracted directory to a shared path (as su); add the java/bin directory to the search path; and finally add the java/man directory to the search paths for man.

The windows installer was straight forward, though the above problems still hampered me.

Re:J2SDK on Win98 and Linux

[Westley]

No, all is unlikely to be hunky-dory if you set the classpath environment variable. This seems to cause more problems than anything else to newcomers. It's much easier to avoid using a classpath environment variable in the first place - the default is fine for most things, and the extensions mechanism really helps. I've got short essays about both on the Java bit of my site.

Jon

Re:Java2 ?

[LarsWestergren]

Hmm, if SDK v1.2 became "Java2", shouldn't v1.4 be called "Java4"? Oh I see, "Java2" was a "marketing trick" used in the tough year 1997 and the name has stuck.

Perhaps,but remember that the change from 1.1 to 1.2 contained some major rehaul of APIs.

In this 1.4 release Sun kept a carefully budgeted set of new features and emphasized quality and performance, like they said they would. You can expect more changes in 1.5 (codename Tiger) which is planned to come some time around the middle of 2003. If that will be Java3, who knows, they have just started working on it.

I've been using this for a while

[autopr0n]

Autopr0n.com actualy runs using the first beta of JDK1.4. I needed the new ImageIO libraries for the, um, 'site previewer :P' (and the regexs made some of the parsing I'm doing a lot easier :). I tried 1.4b3 but it was far more unstable, and my regexs broke.

Definetly cool that the stable version is out, I'll have to upgrade at some point, when I have time.

Hopefully they'll implement this at Topcoder.com too, so I don't have to keep using the old docs in the compos :P

Re:I've been using this for a while

[flacco]

Autopr0n.com actualy runs using the first beta of JDK1.4. I needed the new ImageIO libraries for the, um, 'site previewer :P' (and the regexs made some of the parsing I'm doing a lot easier :). I tried 1.4b3 but it was far more unstable, and my regexs broke.

It must be hell on productivity working on Autopr0n, what with the spank sessions every thirty minutes or so.

At least Sun is brutally honest.

[Marsh Jedi]

Jesus, Sun's PR corps must have flipped their collective shit when they read Karen Tegan's remark. While in general I find that kind of bluntness refreshing, a director of Platform Compatibility spouting off and essentially saying, "Well, that sucks for you, but we make money off of compatibility testing. We give everything else away for free, so cut us a break." is really a testament to the Sun Micro (brutally) plain-talking attitude.

Deeper, though, I think, is the need to rein in Java a bit....It has achieved ubiquitousness, and I think Sun knows it. Watch. If .NET takes off, they will loosen up to benefit from a little more old-fashioned agrarian innovation and buzz.

To lazy to write it yourself?

[autopr0n]

I guess it would be nice to have SSL built into java, but you could write it yourself, it's not like it's a fundementl language flaw. The specs are out there, and the java Crypto API would probably help you out quite a bit.

AUTOEXEC.BAT

[autopr0n]

Throw the classpath in your AUTOEXEC.BAT file on the C: drive on your win98 machine. Should work.

My take on JDK 1.4

[burtonator]

OK.. I am a Java fan... (recently this has been changing though.)

I have mixed feelings with JDK 1.4.

The JPDA (debugging) support in 1.4 is vastly improved. You can now redefine classes in a running virtual machine. This is really cool and I have written an Ant 'Redefine task to take advantage of this.

The assert facility is OK.... i don't like the fact that they added an Assert keyword but I don't get to make the decisions.

There is also some controversy.

The JSPA agreement that one has to sign to participate in the JCP is WAY too restrictive for Open Source developers. The Apache Software Foundation has a good document where they drawn the line in the sand on their participation.

The Log4J people are upset because there is now a 'stanard' Java package for logging. IMO the 'standard' package is inferior to Log4J in many situations.

The regexp package is not all it is cracked up to be either. I would recommend Jakarta ORO or Jakarta Regexp.

As far as that... it runs GREAT on Linux. Probably the most SOLID VM I have ever run.

They did break some stuff with legacy code. If you ever named a class 'URI' your code will now fail to compile because they put this class in the java.net package which everyone imports anyway.

As far as C# vs .Java. I am really impressed with the CLR/CLI stuff. Right now, as it stands, Java is a proprietary language. Unless we see SUN Open Source Java (or push it through a standards committee), we *may* see a JDK 1.5... but no one will use it.

Also.. check out my Reptile project. It is Java based, only requires JDK 1.2 and incorporates some really cool Java/XML stuff. :)

Re:My take on JDK 1.4

[mccalli]

They did break some stuff with legacy code. If you ever named a class 'URI' your code will now fail to compile because they put this class in the java.net package which everyone imports anyway.

Not really a 'breakage'. If you imported only what you needed (java.net.URL, java.net.Socket etc.) your code will continue to work. Only if you used the statement "import java.net.*" will it now fail, and that's down to the individual coder, not the JDK.

Cheers,
Ian

Re:My take on JDK 1.4

[briansmith]

As far as C# vs .Java. I am really impressed with the CLR/CLI stuff. Right now, as it stands, Java is a proprietary language. Unless we see SUN Open Source Java (or push it through a standards committee), we *may* see a JDK 1.5... but no one will use it.

I agreed with your whole post except for this statement. It is just FUD (perhaps unintentional). The fact is that CLR/CLI isn't going to kill off Java in the next 16 months, which is when I expect to see JDK 1.5 delivered. Also, there is nothing stopping open-source clean-room implementations of anything in J2SE, AFAICT. You just can't call your product "Java" and you won't be able to get your runtime certified by Sun. Similarly, I doubt that Microsoft will let somewhat create a clean-room CLR/CLI and call it "The .NET Framework", and they don't even have a process in place for certifying compatible implementations.

Re:My take on JDK 1.4

[Speare]

They did break some stuff with legacy code. If you ever named a class 'URI' your code will now fail to compile because they put this class in the java.net package which everyone imports anyway.

If you have a foo.bar.URI class, and the core has a java.net.URI class, you can still use yours.

You can:

1. specifically name the package at the usage (messy),
2. specifically include only the java.net classes you want, one by one, rather than including java.net.* (inconvenient),
3. or just clarify which URI class should be used in the imports specifically:
   • import foo.bar.*;
     import java.net.*;
     import foo.bar.URI; /* hides java.net.URI */

Existing code does not need to be recompiled, since bytecode always explicitly names classes always, but existing code does potentially need to be fixed if recompiled, as the default results of the imports will change. This is a pretty small and common occurrence with a new API set.

Re:My take on JDK 1.4

[Richard_Davies]

Regarding the logging and regex packages: Just because a package is less functional does not mean that it is intrinsically bad. If the package is suitable for the majority of uses by the majority of developers, then it's probably OK - after all, it's easier for someone to learn a small package rather than a large one. If you require something more specific, then you are still free to use the packages you metnioned. The JDK logging and regex packages ADD choice - surely this is a "good thing"?

Please take a close look at both the openess of .NET and the multilanguage capabilities. Neither are everything they are cracked up to be. Only the CLR and a "core" set of C# classes are open - everything else (i.e. the really useful bits that everyone needs) are not. My question - do you trust Microsoft to open these up?

You mention (must have seen this somewhere before on Slashdot :-) that Java should be Open Source / Standardised. I, like many Java developers have no instrinsic problem with this. However, there is the issue of cross-platform portability:

Many people complained when Sun would release a JDK for Windows and Solaris that it didn't have one of Linux. Then they complained when a Linux JDK was created that it didn't come out at the same time. Now with Sun releasing all 3 JDK simeltaneously (and the likes of Apple and IBM not usually far behind), consider this:

How likely do you think this situation would be if the JCP (or something like it) was not in place? Do you really think you would be saying "As far as that... it runs GREAT on Linux. Probably the most SOLID VM I have ever run." if Java was Open Source?

Maybe it would be:
"Well the Linux version is pretty good - can't use the xyz library because that's Windows only and it will probably be out of beta only 6 months after the Windows version but hey - it's Open Source! That make me FEEL GOOD!"

What I would LOVE is to see Java open sources while ensuring that it remains cross-platform. While some would claim that open source would guantee that, it is not provable. Sun believes that there is too much risk. While you may not, agree with that you have Java that is:

a) free (as in beer)
b) you can read the source code the the whole API
c) you can change (but not distribute) the source
d) works on all major plaforms (including FreeBSD now BTW)

For me, and many other Java developers, these still place it far ahead of anything Microsoft is doing - and while Mono iterests me, its going to be a LONG time before it can match Java's (or even .Net's) current functionality.

Re:My take on JDK 1.4

[The Mayor]

They are upset because they offered log4j to Sun as part of the JCP to include in JDK1.4....and Sun rejected it, pushing their own implementation instead. The idea of the JCP being run by the community is a crock of shite. Sun has pushed a number of inferior standards through it, most of which are used more frequently than the superior product because many programmers are simply too lazy to use the superior product.

Stuff like logging APIs have enormous added value if everyone uses the same logging mechanism. Applications using multiple libraries that use disparate logging mechanisms are a mess. The result is people create kludges to integrate all of the various logging techniques so that they output to a single place. Sun's rejection of log4j will result in this happening.

Log4j is really better than Sun's. Oh well.

And nobody is upset that Sun didn't clone log4j. Everyone is upset because Sun didn't *take* log4j lock-stock-and-barrell. Apache/IBM offered it for the taking. The result is Not Good.

Re:My take on JDK 1.4

[Glock27]

OK.. I am a Java fan... (recently this has been changing though.)

Sorry to hear that, I hope I can persuade you a bit back towards the good side of the force... ;-)

I have mixed feelings with JDK 1.4.

I'm mostly ecstatic about it. =)

The assert facility is OK.... i don't like the fact that they added an Assert keyword but I don't get to make the decisions.

I wish they had done a better job of support DBC, but it should still be useful. I'm not too sure what it bought over just using existing "assert" hacks, which can also be compiled completely out.

There is also some controversy.

Perhaps in the minds of some...

The Log4J people are upset because there is now a 'stanard' Java package for logging. IMO the 'standard' package is inferior to Log4J in many situations.

I'm not sure what the complaint is here. If Log4J is superior (I've not looked at the logging API yet), it should still attract lots of users. Regardless, there is no way for Sun to extend the core JDK without potentially stepping on the toes of some developers. I don't see an easy way around that problem.

The regexp package is not all it is cracked up to be either. I would recommend Jakarta ORO or Jakarta Regexp.

Again, I can't comment on the technical merits of one versus the other. However, again I'm not sure what your problem is. There are alternative packages, which are better. Great, then use them! The core packages are essentially developed by committee, and are only one approach to the given problem domain. There are many tradeoffs in library design...

As far as that... it runs GREAT on Linux. Probably the most SOLID VM I have ever run.

That sounds great! I'm just about to install it.

They did break some stuff with legacy code. If you ever named a class 'URI' your code will now fail to compile because they put this class in the java.net package which everyone imports anyway.

That is not "breaking something". That is the reason Java has namespaces. Not a big deal at all.

As far as C# vs .Java. I am really impressed with the CLR/CLI stuff.

I'm not sure why...care to clarify? Have you read the comments about CLR based languages all being different skins of C#?

I'm also not sure why people seem to feel it's impossible to interface Java to legacy languages. People do it all the time using JNI.

Right now, as it stands, Java is a proprietary language. Unless we see SUN Open Source Java (or push it through a standards committee), we *may* see a JDK 1.5... but no one will use it.

Sun has made noises about open sourcing Java at some point. If it'd just release the compatibility tests as open source, that would go a long way. (It is currently perfectly fine to 'clean room' Java, as gcj is doing. You just can't call it "Java" without essentially licensing Java and getting the compatibility tests.)

Regardless of Sun's timing in releasing Java as open source, you're completely out of your mind if you think interest in Java is going to significantly lessen because of the introduction of C#/CLR. C# and the CLR are both fledgling technologies, where Java is quite proven and robust. I just read about the first CLR security exploit, and I expect many, many more. Heard of any with JVMs lately?

C# and the CLR only run on small computers and operating systems compared with the high availability big iron that runs Java. Also, Java has penetrated small devices very effectively, with over 100 million Java enabled cell phones to ship this year, very significant embedded penetration, and instruction set support for Java bytecode in all the new generation of ARM chips such as Xscale. Microsoft is caught in the middle (granted the middle covers a lot of ground;).

Despite all the rhetoric to the contrary, I advise you to expect big things from Java on the desktop as well. Sun is quietly staying the course, and is making big improvements to client side Java with every release. Since Java supports Windows, MacOS and Linux, it is a very attractive way to deploy applications (we'll see when C# achieves this milestone;). Earlier releases coupled with slower computers were painful, but things have improved to the point where Java is perfectly usable for lots of applications. Linux + Java is a potential Microsoft killer, make no mistake about it and Microsoft knows it.

My final point for today regarding the "open" nature of C# and the CLR is that quite a lot of the C# class libraries available under MS Visual Studio are not included in the standard. This includes the GUI libraries, so as things stand you can use Java today to write completely cross-platform GUI based programs. It will most likely be a cold day in hell before Winforms are available anywhere but Windows. I'm betting Microsoft's legal team will make sure of it. We'll see if Mono gets far enough to be a test case.

Sigh, now the long wait begins for JDK 1.5. ;-)

(Reptile looks cool, I'll check it out later.)

299,792,458 m/s...not just a good idea, its the law!

Kodak invented OLE?

[blair1q]

I just took a look at the three patents Kodak is suing Sun over, and, huh?

Sure looks like Kodak claims it invented OLE.

Which, hey, they may have, and Microsoft either licensed or stole it.

What's the real story?

--Blair

Re:Kodak invented OLE?

[briansmith]

Kodac got these patents when it bought Wise. I read on JavaLobby.com's discussion of the lawsuit that Wise sued Microsoft three years ago over these three patents. I don't know the outcome of the alleged lawsuit.

Also, a few people on JavaLobby are of the opinion that Kodac just patented three fundemental object-oriented programming techniques. If that is the case, these patents would never hold up in court as almost any SmallTalk program written before 1990 would be prior art.

My pet peeve.

[Malcontent]

This is in regard to the kodak suit.

What I find especially bothersome is the the fact that Koday (supposedly) had these patents. They did nothing with them. Sun produced a product, hyped it, sold it, improved it and put in millions of dollars and man hours into it.
Kodak then comes in and demands money after the fact when they made no attempt to actually do anything.

I think that's crazy. Why punish the people who got off their asses and did something especially if the punisher was too lazy or stupid to actually make use of their idea.

This isn't just about sun and kodak either. Who was suing palm recently? Same thing.

Sit on your ass doing nothing, wait for somebody else to do all the work. Then sue them and retire in the bahamas. It's the american way I guess. Sure beats working.

Re:My pet peeve.

[Captn Pepe]

You shouldn't dump too much on patent owners who aren't fully utilizing their patents -- most small inventors (whether they patent their invention or not) see large corporations swoop in and seize their work before they could possibily have capitalized on it. If they're lucky, they have a patent and a good understanding of patent law, and can thus make something off of the corporation in question. Usually not, though.

You probably don't want to strengthen patents any more than they already are, because we're already seeing all kinds of problems with software patents being used to lock open source solutions out of various areas. Many industries also have the problem that start-ups are impossible because the established players already own the necessary patents, and have no interest in licensing them to a new competitor.

Personally, I suspect that the answer is probably a compulsory license regime for patents. In this case, a sensible solution might be to set default payments which are somewhat high, but that scale with number of units sold and price charged. Thus, large corporations still have an incentive to negotiate with patent holders for lower license fees, but start-ups needn't pay anything until they start shipping units, and would be free to use the patents at that rate whether or not their competitors want to let them into the market. Finally, free software would be protected, since in this scheme the developers would be implicitly accepting the default terms, which wouldn't require payment for copies not being charged for (but RH et al would have to fork out for distros that they sell).

Unsurprisingly, a number of powerful lobbies have ensured that this cannot happen without major changes to our IP system; for one thing, it would require breaking the WIPO treaty, which the megacorps paid really good money for.

Security export rules

[Aceticon]

As usual the "import control restrictions" once again are in full force. From the release notes:

Due to import control restrictions, the JCE jurisdiction policy files shipped with the Java 2 SDK, v 1.4 allow "strong" but limited cryptography to be used. An "unlimited" version of these files indicating no restrictions on cryptographic strengths is available.

The JSSE implementation provided in this release includes strong cipher suites. However, due to U.S. export control restrictions, this release does not allow alternate "pluggable" SSL/TLS implementations to be used

What seems even stranger now is that you cannot used "pluggable" implementations (in JSSE). Maybe the "nasty" europeans/asians/africans/martians would provide some unlimited strong cryptography pluggin otherwise???

Re:Security export rules

[JohnA]

There is already a clean room, open source (BSD License) implementation of the JCE. It's called Cryptix, and simply put is one of the best libraries ever written for Java.

I don't trust black box cryptography... especially when Sun goes the extra mile to obfuscate their default implementation of the JCE crypto modules.

Re:J2EE openness

[customiser]

Sun certification does not have any effect on JBoss's functionality. As I see it, it is just a marketing matter, being able to say "This is a Sun certified J2EE App Server", so that whoever makes the decision on using it (and mainly commercial organisations) can be confident that it really does what it is supposed to do.

btw, as it is a server, it does not run on the client.

Re:Not meaning to troll but....

[mccalli]

What good is this platform really?...It seems to me that Java is nothing but slower than other languages

The platform is not the language.

Java is good partly because of its pragmatic syntax (C++ish with some sugar added, some sugar taken away), but mostly it's good because of its excellent class library.

Though I haven't written anything serious for a year or so due to a job switch, I used to write large-scale multithreaded network servers, where somthing like three to four hundred threads could be running at any given moment inside the server. Java's class library made this really quite easy, and it's syntax is pleasant enough to work with.

Cheers,
Ian

Patent titles

[jeti]

The article says nothing about the nature of
the supposedly infringed patents. Here's their
titles:

US05206951
Integration of data between typed objects by mutual, direct invocation between object managers corresponding to object types

US05421012
Multitasking computer system for integrating the operation of different application programs which manipulate data objects of different types

US05226161
Integration of data between typed data structures by mutual direct invocation between data managers corresponding to data types

Re:Patent titles

[Corrado]

Wow, can they get any more vauge than that!?!?

Java Secure Socket Extension

[srichman]

The Java Secure Socket Extension has provided TLS/SSL support to Java for a long time, and is now part of 1.4.

???

Re:Java Secure Socket Extension

[Anonymous Coward]

JSSE is integrated, and does suport SSL, but the point being made is that fact that JSSE was not updated to support non-blocking I/O. So all the talk about how non-blocking I/O is gonna be this great boon for server programmers is somewhat moot, since they don't do SSL outta the box and developing SSL isn't as easy as just encrypting data.

There is an RFE I entered about this a while back http://developer.java.sun.com/developer/bugParade/ bugs/4495742.html . If you're a Java developer, register and vote for it, to make sure Sun corrects this oversight.

new in 1.4: public Exception(Throwable cause)

[_am99_]

My favorite thing about using 1.4 is code like this:

public void methodA throws MyException {
try { Driver d = Class.forName(driverClass).newInstance(); }
catch (Exception ex) { throw new RuntimeException("problem loading driver"); }
}

can now be this:

public void methodA throws MyException {
try { Driver d = Class.forName(driverClass).newInstance(); }
catch (Exception ex) { throw new RuntimeException("problem loading driver", ex); }
}

Notice the RuntimeException constructor now has the original exception passed to it. It can be retreived higher up the stack, and I believe is printed during a ex.printStackTrace(...). It lets you pass the root cause exception up the stack trace, while preserving the entire state, without having to declare it everywhere.

Re:Open Source Java VM & class libraries

[mlinksva]

Look at the bottom of the classpath page for a list of open source VMs that work with classpath (a free core (i.e., java.* and a few others) class library). All works in progress. I expect that mono and/or portable.net will quickly outpace free java projects. The JDK is a case where the availability of good enough gratis software has seriously hampered the momentum of libre competition. Netscape 4.x is another such case.

Anyone here read the license?

[asb]

5. Notice of Automatic Software Updates from Sun. You acknowledge that the Software may automatically download, install, and execute applets, applications, software extensions, and updated versions of the Software from Sun ("Software Updates"), which may require you to accept updated terms and conditions for installation. If additional terms and conditions are not presented on installation, the Software Updates will be considered part of the Software and subject to the terms and conditions of the Agreement.

6. Notice of Automatic Downloads. You acknowledge that, by your use of the Software and/or by requesting services that require use of the Software, the Software may automatically download, install, and execute software applications from sources other than Sun ("Other Software"). Sun makes no representations of a relationship of any kind to licensors of Other Software. TO THE EXTENT NOT PROHIBITED BY LAW, IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR SPECIAL, INDIRECT, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF OR RELATED TO THE USE OF OR INABILITY TO USE OTHER SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

Ironic/NBIO

[srichman]

I used to write large-scale multithreaded network servers, where somthing like three to four hundred threads could be running at any given moment inside the server. Java's class library made this really quite easy, and it's syntax is pleasant enough to work with.

It's kinda ironic that you should say this, since threads are the wrong way to write "large-scale" network servers, and since Java 1.4 finally gives us non-blocking IO APIs to implement things the right way. (The NBIO APIs in 1.4 are, incidentally, largely a product of the work of the fellow behind the second link I gave.)

Re:skeptical for the desktop

[TheAJofOZ]

Sun is like Microsoft - they make as many features as possible, worry about the bugs later and let hardware catch up to overcome their crippling defects caused by overzealous and misinformed OOD.

Okay, I can't take this any more - Java is not slow or buggy and can produce applications that are indistinguishable from C/C++ applications. The proof of this is simple - rewind the clock back a year to MacWorld where WorldBook Encyclopedia was demoed as part of the keynote with everyone watching and they were all impressed. Months later I was informed by the "head Java dude" at Apple on his Australian tour that WorldBook is completely written in Java - but noone knew.

Most people think that Java is slow, buggy and doesn't look platform native because they assume that anything that is fast, stable and looks and feels platform native wasn't written in Java. It's even cooler though, because the "write once, run everywhere" of Java actually works if you write good code). Sure there are some things that Java can't do that you need native code modules to handle but that facility is available.

The worst thing is that young programmers are led to think that Sun's code is actually *good* which spreads their poor, inefficient form to the next generations.

Java's not perfect, but I seriously don't think that it's Java that corrupts young programmers. You can write good code in almost any language - I see an awful lot of really bad Java code written by C programmers but I'm not about to claim that C is corrupting old programmers.

Unit testing

[Aapje]

I've never used assertions, but they seem a great complement to unit testing. Unit testing allows you to write code to test your functions and easily see if something breaks, the major problem is that they lack an easy way to look inside objects to keep an eye on internal consistency. Assertions can be great to catch those silly little boundary mistakes.

A good unit testing framework for Java is JUnit, they are available for other languages as well.

BTW, you can create your own assertions with Log4J, so even JDK 1.1/1.2/1.3 users can use them:

if(logger.isDebugEnabled())
if (bla>10)
logger.warn("bla>10, bla=" + bla);

This uses almost no CPU-time if debugging is disabled. Log4J is a very good logging package, it surely beats System.out.println, check it out!

Re:Java2 ?

[grantm]

Remember, this is Sun the people who released Solaris 2.0 which:
- was the first version of Solaris
- declared itself to be SunOS 5.0
- was an implementation of System V Release 4.0

Obviously being able to count is not a prerequisite for getting a job in Sun's marketing department.

Re:skeptical for the desktop

[E-prospero]

Most people think that Java is slow, buggy and doesn't look platform native because they assume that anything that is fast, stable and looks and feels platform native wasn't written in Java

I find the example set by WorldBook 2002/MacOSX to be a stunning demonstration of Java's potential if Sun would just wake up and smell the coffee (pun intended).

I like Java a lot - both as a language, and as a bytecode platform. I use it daily at work, and at home for my own projects (after many years of flipping between C, C++, and a dozen other niche languages)

My only major bugbear with the JDK is not with Java itself, but with Swing: It's godawful slow (The Hello world app should not take 30 seconds to display on a P400), it's API is occasionally appalling (JTree anyone?), and it has a habit of being occasionally buggy.

Above all, it reinvents the wheel with widgets. The Look and Feel implementation very occasionally looks and feels like a platform native application (Win2k LnF anyone?). However, it usually looks and feels like someone has tried to reimplement a system native toolkit using only a blunt light blue crayon.

For many a year I have whined to all that would listen "Why the *@*)(!&*@ doesn't the Java widgeting toolkit defer to system native widgets for window display? Surely this would look better and run faster than pixel blitting a widget look-a-like!"

MacOSX provides just such an API. Although Objective-C is the `preferred' language of Cocoa, there are Java bindings. Note - this API is NOT Swing - it is a MacOSX extension API. Consequently, a MacOSX application built in Java should be almost indistinguishable from a native compiled app in terms of look and feel. And according to your comments, performance is also indistinguishable.

I have played with Java bindings for Gnome; they provide blindingly fast gui performance, using the same java runtime as is used by Swing. However, there are several java binding projects for Gnome (all partially complete), and none of them really address the general problem of widgeting across platforms.

I have also played with Eclipse, the IBM Java . Their widget toolkit is cross platform in API but system native in widget; however, I have found the performance of the Eclipse widget set to be almost as bad as Swing. However, it is beta code - we may have to wait and see if anything improves with age.

Java/Gnome demonstrates that it can be done under X. Eclipse demonstrates that it can be done cross platform. MacOSX demonstrates that it can be done well enough as to be indistinguishable from system native widgets.

So can anyone tell me: WHY hasn't it been done? (And don't say its because they don't want to break backward compatibility - Look at 1.4's NIO framework and VolatileImage).

Russ Magee %-)

Headless at last - bye bye XVfb

[Taurine]

My favourite new feature is that lightweight components can now be run in headless mode - see

http://java.sun.com/j2se/1.4/docs/guide/awt/AWTC ha nges.html#headless

You have to set a property to true:

-Djava.awt.headless=true

as a switch when running the VM for example. Then you can generate server-side graphics on Unix without having to run XVfb. This has been an annoyance for some time, as you had to have different deployment rules depending on your target OS, as NT always has a graphical environment taking up resources whether you want it or not, so it wasn't an issue there.

The upshot is that you can now use java.awt.Image.BufferedImage as an image source in servlets that generate dynamic images, instead of java.awt.Frame, which always seemed wrong. It uses less resources too, as it doesn't have to do a context-switch to your X server to create images!
Hey, there are lots of great new features in this new release, but that is the first one that made life easier for me.

Re:Headless at last - bye bye XVfb

[Fjord]

You've always been able to use java.awt.image.BufferedImage to create dynamic images. The application I'm working on does that. But you are right that now you don't have to use xvfb (which I never thought was that big of a pain, but I like the -D solution better).

I'm kind of interested in java.awt.image.VolitileImage. It makes an image using the video card's memory, with the trade off that the image may be destroyed at any moment. I've done some tests and on my machine it didn't improve performance at all, but on a system with a good video card, it may be an awesome class.

Why I Don't Want to Touch This

[Greyfox]

I use Java at work and I had to beat 5 fucking team leads with a crow-bar to convince them to move to Java 1.2. Now they all run the other way when they see me coming -- it's a lot harder to get near them with a crow-bar. By the time my company gets done with its final focus meeting to decide that moving to 1.4's a good idea, Sun will be releasing Java 2.4 (With telepathic user interface code.) If I get all used to how great Java 1.4 is, work will suck more, and it already sucks so much that light can't escape.

Re:My pet hates with Java

[_underSCORE]

I fail to see how a declaration "String str = null" is any safer than a declaration "String str".

You've used this serveral times as an example. You're right, assigning a string to null is not safer than leaving it uninitialized. However, that just gets around the 'uninitialized variable' error from the compiler. You should initialize it with something meaningful, or at least "". That would be more safe, and would be what the compiler wants you to do. This error has saved my butt more times than I care to remember, so don't knock it.
If you want to use variable arguments, pass in a vector or a list. There are ways to make java do what you want to do, they might not be like those in C or C++.

Wording was bad

[SuperKendall]

The story should have read "no LICENSED open source J2EE implementations". There are OS J2EE app servers (JBoss), and in fact they are quite good... the problem (as stated in the article) is that it's hella expensive to get the official seal of J2EE. That doesn't mean it doesn't work!

Now if you think .NET is better, you have to ask how good an open .NET server you're going to be able to build without ASP.NET or Windows Forms. Neither of those are part of the current ECMA submissions, though as stated in the .NET article yesterday they are expected to be submitted at some point...

At the moment J2EE has gone through a lot of refinement, and I think makes a pretty good platform for server side development. I think desktop code is still up for grabs by either Jvaa or .NET (at least under windows). It will be interesting to see if .NET app development is nearly as annoying as MFC was (I doubt it will be).

assert keyword was the right decision

[melquiades]

i don't like the fact that they added an Assert keyword but I don't get to make the decisions.

Dude, read up. There is an excellent discussion of the reasoning behind their design decisions. They give a very good justification for adding a keyword; in fact, it's one of the FAQ questions:

2. Why does this facility justify a language change, as opposed to a library solution?

We recognize that a language change is a serious effort, not to be undertaken lightly. The library approach was considered. It was, however, deemed essential that the runtime cost of assertions be negligible if they are disabled. In order to achieve this with a library, the programmer is forced to hard-code each assertion as an if statement. Many programmers would not do this. Either they would omit the if statement and performance would suffer, or they would ignore the facility entirely.

Unlike a lot of other languages (C++ and C# spring to mind), the Java designers have been very tight about letting multitudes of constructs into the language. Java's minimality and internal consistency is one of the reasons it's been so successful, and its designers know this. They are very intelligent people who are making decisions very carefully -- and they're not going to add something to the language unless they have a very good reason.

In this case, they have a very good reason.