Java SDK 1.5 'Tiger' Beta Finally Released

kingkola writes "Finally, after about two years of development, the Beta for Java SDK 1.5, aka Tiger, has been released. Features added in this edition include generics support, autoboxing of primitives, syntactic sugar for loops, enumerated types, variable arguments, sharing of memory between multiple VMs and a bunch of other bugfixes, enchancements, etc."

Comments

Re:Why?

[jimbolaya]

Java is probably the most popular language today; undoubtedly within the top 5. And the Java-is-slow-C-is-fast myth is just that...a myth. Dynamic recompilation (HotSpot) in modern Java Virtual Machines can actually make Java as fast or faster than C. And forget not that you can write a slow program in any language, C included.

What Java is is a memory hog. "Hello World" can easily consume a megabyte of RAM. The shared memory will help this situation. (Incidentally, the shared memory idea was originally developer by Apple for Mac OS X. Apple worked with Sun, and donated code, to make it universal).

an annoying quirk

[Dogun]

A friend of mine is bitching about this: if you type a list, say ArrayList, you can't use that as an argument for a function that takes a ArrayList. He's tried casting it, it just doesn't like it. Anyone else seen something like this?

About time too

[DrXym]

This finally puts Java the language onto the same level as c#. While most of the syntax changes amount to sugar (the compiled code being the same), it is still welcom to see a proper enum at last. And things like generics should make it considerably less tedious to walk through collections (a bane of Java development).

Another change that caught my eye was a skinnable theme for JFC called Synth. I wonder if this will help Java capture some of the kewl market for media players etc.

I also see the beta is being made available for 64-bit Linux.

As a platform, Java is still miles ahead of c#. But I sometimes wonder if the message is lost amongst all the specifications and implementations of specifications. The .NET strategy has gotten some ill-deserved 'buzz' from managers who've heard the spiel without quite understanding the implications if they go that route (i.e. lock-in). Someone in Suns marketing department should produce a massive wallchart detailing everything Java can do, every major solution for it and arrows showing how they all join together and then mail it out to every CEO / CTO in the country.

Re:About time too

[Seahawk]

The .NET strategy has gotten some ill-deserved 'buzz' from managers who've heard the spiel without quite understanding the implications if they go that route (i.e. lock-in).

How is java less lock-in than ,NET? Both are closed products with free alternatives. Java has Kaffe, lots of small jvm's and classpath - .NET has Mono.

In my eyes you are about equally locked in - but people tend to hate .NET just because its MS.

My view is that c# is a bit more "clean" as a language, but the classlibrary is much more immature than the java classlibrary.

Re:About time too

[Tal Cohen]

Not true: If Sun drops dead, Java will live on with interested parties such as IBM and Oracle. Their agreements with Sun are such that Sun cannot simply pull off the product and prevent further development.

Re:About time too

[Uksi]

In C#, any code you write MUST run on a Windows-supported platform under Windows

That's not correct. Next time, please say "according to blah, ...". For example:

According to the Mono faq:

Question 58: Can I develop my applications on Windows, and deploy on a supported Mono platform (like Linux)?

Yes, you can.

As of today, Mono is not 100% finished, so it is sometimes useful to compile the code with Mono, to find out if your application depends on unimplemented functionality.

So in short, yes, you can compile C# and C++ to bytecode under Windows and run it under Linux.

Although what you said about CLA (being able to call other languages' functions) is correct.

Saves loads of code

[cerberusss]

What is great about this, is that this saves loads of code. Lots of explicit typecasts can be left out now, there is a very short-handed for-loop, you can import constants, etc. etc.

I played with the alpha and gave a presentatation about it at my employer. Lots of people were enthousiastic.

Plug: java-1.5_new_features_en_v2.ppt

Benchmarks

[SashaM]

Actually, 1.5 beta has been available for a few months now, but the link wasn't on the main java.sun.com page.

Here are some highly unscientific benchmarks of startup time I just ran on my Athlon XP 2000+ under Mandrake 9.2:

[sasha@jupiter tmp]$ time -p /usr/java/1.4/bin/java HelloWorld
Hello World!
real 0.30
user 0.22
sys 0.03

[sasha@jupiter tmp]$ time -p /usr/java/1.5/bin/java HelloWorld
Hello World!
real 0.17
user 0.16
sys 0.02

These are relatively consistent over multiple runs.

The good and the ugly

[brett_sinclair]

I really like the new language features (and will use them in about 5 years when our server is upgraded :-().

But Swing is even uglier than before. Metal still looks very old, but now it looks like someone very old with obscene amounts of make-up on.

The GTK+ look is even worse. It doesn't look like GTK+ at all (I'm not even sure whether it's supposed to be GTK1 or GTK2).

Worse: font rendering is abysmal. Buttons and menus are barely readable using the GTK+ emulation L&F. The Java VM still doesn't use Xft/Freetype, which pretty much makes the attempt at GTK+ emulation useless.

Just a Question for everybody:

[nberardi]

I don't want to start a flame war, but do you think that the pressure of .Net pushed some of these features through that Sun seemed to be holding off on for the longest time.

Such as enums, generics, boxing, foreach loop, etc.

Just a question that I have had, because I never heard anything about these features comming into Java until after .Net made it's comming out in 2002.

Excuse me but:

[gargleblast]

1. The type checking is much weaker than what? It is perfectly strong at runtime.
2. Verifying the correctness of any program in any Turing-complete language is in general impossible
3. The reusability "argument" of OOP is rubbish too.
4. The abovementioned problems are nonsense and as such create nothing. In addition, the banking sector is not universally regarded as sensible.
5. You must be thinking of C++ templates which are (1) Turing complete and (2, coincidentally) are a significant burden to the compiler and linker. Java's generics are neither. They are a simple syntactic sugar for type casting. C++ with templates is still LALR(1)/Context-free/Chomsky type 2. Chomsky hierarchy has nothing whatsoever to do with secure correctness checking. If a language is Turing complete, there is in general nothing you can prove about it's programs.
6. In my limited experience with Lisp's authorities, they encourage much and discourage little. Provide a citation please.

Class Data Sharing comes from Apple

[Arkham]

One of the new features, Class Data Sharing, comes as a contribution from Apple. On the Apple Java Page, Apple describes this feature as:

On other platforms, each Java application consumes some system memory, so you might end up using more memory than you need to when running multiple Java applications. Other languages, such as C or C++, solve this problem using what's called shared libraries. Apple developed an innovative new technology that allows Java code to be shared across multiple applications. This reduces the amount of memory that Java applications normally use. And it fits right into Sun's Hot Spot VM, allowing Mac OS X to remain compatible with standard Java. In addition, Apple has given this implementation to Sun so the company can deploy it on other platforms. It's just one example of how Apple supports standards and shares ideas to benefit all.

Pretty cool stuff, and it shows that Sun does accept changes to Java from the outside that are of clear benefit.

Can we thank .NET for giving Sun a push?

[alien_blueprint]

Sun have been promising generics for Java since 1997, and I have been patiently waiting for it all this time.

I haven't had the chance to look at C# in detail yet, but it's certainly no co-incidence that these features finally saw renewed activity after C# appeared. So, thanks, MS, for applying a little competitive pressure onto Sun for us :)

I'm also a little disappointed to see just how similar Java generics are to C++'s templates. I was hoping that we were waiting for a *reason*, and that reason might be because it was a new and interesting approach. But, at least superficially, this looks almost exactly like C++ templates, with all the positives and negatives that go along with that.

not enough

[ajagci]

These are language fixes that should have happened years ago. The real question is: why did it take Sun so long? Why is the process by which the Java language evolves so severely broken?

And many serious problems remain with the Java language:

• Java genericity has no special support in the runtime, which limits the type safety it can provide.
  
• Generics over primitive types are boxed, meaning they are inefficient.
  
• Java's native code interface is still inefficient and complex.
  
• Java still lacks value classes and operator overloading, making it a poor choice for applications involving numerics or graphics.
  

The most serious problem with the Java platform is and remains, however, that it is basically proprietary: all Java 2 platform implementations depend crucially on code licensed from Sun (e.g., there is no independent Swing implementation). Furthermore, there doesn't exist a Java standard that people can implement without having legal constraints imposed on them by Sun.