Preview of Java 1.5

gafter writes "An early access prototype implementation of the proposed new J2SE 1.5 language features is available. The prototype includes generics (JSR 14), typesafe enums, varargs, autoboxing, foreach loops, and static import (JSR 201). In other words, all the new language features planned for 1.5 except metadata (JSR 175). The prototype includes full sources for the compiler, written in the extended language. You can download the prototype from java.sun.com. It requires J2SE 1.4.1 and provides some examples of how to use the new language constructs. The prototype includes an experimental type system (variant type parameters) for Generic Java that is being considered for Tiger (1.5) based on a paper by Igarashi and Viroli at ECOOP 2002 . Comments and votes for the new type system are being gathered at bugParade."

Comments

good and bad ...?

[bubzer]

Some of these things are certainly nice (typesafe enums...) - but wouldn't it be nice to try and keep the java language *simple*? There are iterators for doing stuff like foreach-looping ... varargs? Why? It is an object-oriented language - take use of that polymorphism!

Re:good and bad ...?

[Dan-DAFC]

I agree. Enumerated types are something Java has been lacking for too long, so these type-safe enums will be welcome (though Joshua Bloch, the specification lead on JSR 201, has a nice alternative in his excellent Effective Java book).

I really don't care much about the rest. I'll give the generics and the autoboxing a go, but I don't really like the new for loop syntax. Firstly I think it's ugly, they've compromised to avoid adding a new keyword (I don't really know why, they were happy to add new keywords in 1.2 and 1.4) and it also means that for the first time we get built-in language support for classes outside of the java.lang package, which strikes me as a bit strange.

What would be nice from a purely aesthetic point of view (it'll never happen because of backwards compatibility) is if we could have a Java 2.0 (which would be confusing in it's self since 1.2 was "Java 2") that cleaned up the messy parts of the core libraries. Move the collections framework out of the java.util package either into the java.lang package (since we know have built-in language support for it) or into it's own package, remove all the of the methods/classes that were deprecated in or before 1.2 (developers have had enough notice to stop using them and legacy code is likely to continue running on old runtimes), fix naming inconsistencies (System.arraycopy should be System.arrayCopy for one, and do you call size(), getSize() or length() to find the size of something?).

As somebody pointed out below, varargs are not mentioned in JSR 201, they won't be in 1.5. I can see from my limited experience with C++ that they can be quite powerful but I'm not keen on them. They can turn compile-time errors into runtime errors and it would make method overloading more complicated.

Re:good and bad ...?

[Anonymous Coward]

for (int i = 0; i < C.length; ++i) {/* ... */}
for (int i : C) {/* ... */}

These fragments have different meanings.
In the first loop, i is 0, 1, ..., C.length-1.
In the second loop, i is C[0], C[1], ..., C[C.length-1].
That's why they chose e as the loop variable in the example "for (int e : a)". The loop variable is not an index.

Re:good and bad ...?

[cookd]

Iterators should not be used to replace the counting case:

for(i = 0; i < count; i++) { ... }

You can use iterators for this, but (depending on the implementation) it is likely to be slower, since the object in question must create an iterator instance.

Iterators should be used (in fact, are pretty much a necessity) on types that are not easily indexed, such as hash tables or linked lists. As long as the Java language doesn't have support for iterators, developers creating non-indexable container classes have to design and implement some kind of iterator themselves. With language support, the language enforces a particular design (making programs more consistent) and provides help with the implementation.

Yes, it is sugar, but it is useful sugar.

Varargs are also sugar. You could always just make the user create an array of objects as the variable parameters. But that takes a few extra lines of code for each call, and confuses the purpose of the code. You have to deal with the distraction of constructing an array instead of dealing directly with your problem.

Varargs makes a few tasks just a little bit simpler. It doesn't add any functionality, but it adds convenience.

CallStoredProcedure(db, "MyStoredProcedure", param1, param2);

Isn't that nice and simple? Syntactic sugar, when used appropriately, should simplify life for the programmer. In my opinion, "sugar" is appropriate if it provides a clean way to do something that would have been messy before. It should be avoided if it provides two equally good ways to do something. In the case of varargs, I think both criteria are met. In the case of iterators, the first is met, and the second is met as well as long as developers understand when iterators are appropriate and when they are not.

Re:good and bad ...?

[__past__]

You honestly think that
for (int i = 0; i < C.length; ++i) {/* ... */}
is more complex than
for (int i : C) {/* ... */}?

In a way, yes. The first uses the (little) possibilities the core language offers. The second uses a language feature that depends on a specific part of the class library.

So, even if the resulting code itself is easier to read, if conflates two layers of the language that should better be cleanly separated, IMNSHO. It basically boils down to the fact that you cannot change the class library anymore without possibly breaking the core language.

Sounds like what C# has that makes it better...

[Anonymous Coward]

Surprisingly (!!!) all the things C# had (or will have - generics) that made it superior. This is going to be fun seeing these two compete. So far I am on the C# side but who knows :) this is really fun.

Simplicity lost

[abies]

While, as a java developer, I'm looking forward to most of these changes, I'm a bit afraid that java may lose it's positions as simple OO language which can be used for teaching in schools. Java was originally built with idea that you can read every java program in the world without problems. A lot of expresive power was sacrificed because of that - most notable preprocessor (to avoid people designing their own 'languages' for each project and library, as it is done in C).
Anonymous inner classes was first major ugliness which came into language - not very clear, hard to explain to a newcomer. But with all these new proposals, significant complexity is added to code in terms of visual overview. This is not critical for developers - perl hackers are faring very well, despite of having language 10 times as complicated as java as far as syntax is concerned - but pure-OO, java-is-new-pascal-for-algorithms academic society will probably start looking for a new language soon... (ok, maybe not really 'academic', I'm thinking more about secondary-level school programming basics).

Interested in learning more about these generics

[smittyoneeach]

You could troll and say that Java has finally caught up with where C++ was better than a decade ago.
More constructively, maybe the implementation will improve on things from all that time and experience.
Java is the best defense against the .Net onslaught. Good luck, Java.

Re:No subject.

[Kethinov]

As a "weenie who can't handle pointers" I take Java's slowness very seriously. I wish that a better method could be used to process Java programs because I believe that future high level programming languages are going to be modeled around Java. PHP certainly is being modeled around Java. Am I the only one here who'd like to some day be rendering serious 3d graphics through Java? I think the language has potential and I don't just shrug off its slowness as an inherent property, I want it to improve in that respect too.

Java is passe

[73939133]

I've pretty much stopped using Java. Sun has broken their promises when it comes to making Java an open standard (and, in fact, they have several patents on core Java technologies). And technically, even with these additions, Java 1.5 is still behind C# in several important areas (native code/data interfaces, genericity, support for numerical computations).

Also, after trying to live with it for years, I have concluded that "100% pure Java" just doesn't meet my needs. "99% pure" is good enough for me: it means that porting is easy, but the last 1% of platform specific code is what makes the difference between applications that merely run and applications that integrate well with each platform.

I expect Java will continue to survive in some niches (most notably, bloated web services implementations), but Sun has largely missed the boat when it comes to creating a general-purpose programming language: it's too little too late technically, and they have annoyed too many people. I think C#, .NET, and Mono have a chance if Microsoft doesn't shoot themselves in the foot with stupid legal threats against open source projects. Otherwise, there are plenty of other languages; the choice isn't just between Java and C#, you know.

Re:Java is passe

[haxor.dk]

But what should I choose if I want and open, platformindependent programming language?

Generics

[The Bungi]

There's an apropos article over at kuro5hin. Well written, I think.

It seems to me that languages like Java and C# really don't need them.

Re:Generics

[be-fan]

One thing I never understand about anti-C++ rants. Where's the beef? All I see is a whole bunch of hand waving and vague references to pseudo object orientation, incoherency, etc. No real meat at all. So from my point of view, some real evidence:

1) C++ is a systems programming language. The lack of pointers would make it entirely unsuitable for that purpose. For normal use, you should use references or smart pointers. Not doing so is no excuse. Using a C-style array when you don't need it is akin to deliberately writing an infinite loop. It's entirely the programmer's fault.

2) The object model doesn't lack anything that Java's model has, except introspection (which is fragile at best). If anything, Java's model is equally broken, because everything is not an object. What exactly about the object model is missing?

3) What's wrong with the C++ syntax? How is it that different from Java's syntax?

From my POV, peoples' biggest problem with C++ is that it doesn't prevent you from hurting yourself. That's okay. I hate all the consumer protection bullshit, and Nader and his "don't run with scissors" party, so I have no problem with my language having some teeth. I do a lot of low level programming, and I find that C++, more than any other language, allows one to do that will still maintaining a high level of abstraction.

Re:Generics

[Anonymous Coward]

Did you actually understand the article you linked to? It specifically says that inheriting from a common base class (which is Java's "solution" to the same problem) is not a good replacement.

It's criticism of templates as they are in C++, not criticism of generics in general.

Using dynamic OO style containers in a statically typed language is one of the biggest mistakes of the original Java design.

Is the single instance of VM in?

[Kjella]

...because there's nothing like running a 2kb calculator and a 2kb notepad and both have them run on separate 10-15mb VMs. That is a real drag for any non-monolithic use of Java (yes I do know of servlets etc.)

Kjella

varargs - shmarargs

[BranchingLichen]

JSR 201 says nothing about "varargs".

Dylan

[oodl]

Sounds like they are adding a lot of features that the Dylan programming language has had since it's release (approximately 1995).

But whereas the features were elegantly incorporated into Dylan since the beginning and are consistent and easy to use, I suspect that in Java they are a hack.

Wasn't Java designed to be a simple language?

Re:Too litttle, too late.

[Dan-DAFC]

It's correct to say that the start-up time for JVMs is a concern (more so than actual Java execution speed) but fortunately things are getting better in this respect. Java 1.4.2 (which is in beta at the moment) has made some significant improvements in this area.

The problem: Improving programmer productivity

[BjornStabell]

These additions seems to put Java on par with C#, but to make a quantum leap in expressiveness you need a dynamically typed scripting language.

Most applications these days can be written in higher-level languages, resulting in 5-10 times less source code compared to Java/C#, and making them correspondingly simpler to code and maintain.

Java doesn't really have a kick-ass companion scripting language. In MS world, VB plays this role. VB is really popular, but (I think most people would agree) a crap language and not really that high level. JavaScript just doesn't seem to cut it (pretty much only used in browsers).

Why doesn't Sun take a hint and phase JavaScript out in favor of a powerful multi-purpose high-level language like Python or Ruby? That'll put them miles ahead of Microsoft in terms of increasing programmers' productivity... and programmers' quality of life.

Re:Mini Ask Slashdot

[j-b0y]

Don't know about JBoss, but Tomcat is a breeze; untar and start it up; you can start drop in webapps straight away.

Now, if you're talking about a secure, robust Tomcat installation, using apache httpd to serve static content, well, that's another matter.

Tomcat is for one of the examples of the success of Java code married to the Open Source model; Sun likes Tomcat becuase they farm out RI work for the Servlet and JSP specs, leaving engineers to concentrate on, well, coming up with more convoluted specs. Sun and its ISVs neither can or want to make any money on a pure Servlet container + JSP implementation.

J2EE, on the other hand; well, Sun hates JBoss, as it is eating to ISV revenue and Sun can't create a monoculture around Java (as Microsoft has very successfully with Win32) if someone is going to give implementations away for free

Re:Sounds like what C# has that makes it better...

[cookd]

foreach isn't really redundant. It just gets used a lot when it shouldn't be used. If a type can easily be iterated-over with a standard for loop (for(i=0; i < obj.count; i++) { }) then you shouldn't use foreach. In .Net, at least, the iterator version is somewhat slower.

foreach is designed for cases where you can't simply use an index (i.e. obj[i]), such as a hash table or a linked list. In these cases, you need some kind of state for your iteration -- hence, an iterator.

While you can implement some kind of iterator without language support, language support in this case helps simplify the code. Instead of implementing the iterator yourself in your way (how many ways can this problem be solved?), you use the language-supported way. Much cleaner.

Syntactic sugar is bad when it leads to many ways to do something, but good when it simplifies the common case. I think iterators do this as long as they aren't used inappropriately.

Re:Java Vs .net

[Billly Gates]

Speaking of mercy and fud responses from the pro .net/mono crowd you can always mention the SCO effect. Corporations obsses with legal costs and potential lawsuits. Company Image is not something that is easy to get back if its hurt. This is important when picking a solution

Most major corporations who are planning on moving to Linux if they have not done so are cancelling and puting their plans on hold thanks to SCO.

If you use mono at work assuming its mature enough and ms pulls a sco you can kiss your linux workstation goodbye.

According to MS halloween documents, legal fud got a negative response form %80 of all bussinesses.

More Wrong Choices

[ChaoticCoyote]

I program Java for several customers, from scientific to business apllications.

Autoboxing is yet another way of hiding overhead; the wrapper classes still exist, but are now a big "secret" masked by autoboxing.

Why add autoboxing to make containers look more "natural with POD types, then ignore the crying need to operator overloading in scientific and engineering applications? Why one piece of syntactic sugar as opposed to another?

Overall, I'm not terribly impressed. The new generics seem weak; I don't see an emphasis on fixing bugs, stability, or independent standardization. Much as I like Java, 1.5 does not address most of my needs.

Re:All the features of C++

[Anonymous Coward]

Java is NOT slow. For numerical work I use IBM's JVM which has occasionally given me BETTER performance that optimised C++. Sun's 1.4 VM is typically 10-30% slower than C++ in most cases, I find.

Even a slight performance hit is well worth the safety and security of Java. Many products and companies were wrecked through the use of C++ as a development language in the late 80s and 90s, as a result of buffer overlow and pointer bugs.

Re:Sounds like what C# has that makes it better...

[krumms]

My bet would be that C# was developed taken into consideration common complaints about Java - or things that were already planned to be added to Java 'some time in the future'.

And hats off to Microsoft for doing so, C# is a nice language.

I agree, however, that the next release of Java will raise a few eyebrows wrt 'fixing' Java's current 'problems' (if you could call them that - they're more like syntactic unpleasantries).

Should be interesting ;)

Java's not original

[Jonner]

I sure hope future languages aren't modeled on Java. That will retard language development like too much reliance on C has retarded it over the last couple of decades. But Java isn't even as original as C was. The language design is purely derivative, a cleaned-up, restricted C++ with some features added from other languages, according to Jim.

I'm not saying Java is a bad language, but that it would be a bad one to base others on.

Re:Why a Large Bank Junked Java

[bokmann]

I'm tired of hearing that 'java isn't used in real-world applications", then some stupid example touted as proof. Java is used in plenty of real-world scenarios. The U.S. State Department uses java, and so do a large number of countries around the world to aid in the export control of nuclear, chemical, biological, and other hazardous materials.

Re:No subject.

[Mithrandir]

Am I the only one here who'd like to some day be rendering serious 3d graphics through Java?

No, but I've been doing it for years. Don't know which closet you've been hiding in, but there are heaps of alternatives for doing 3D graphics in java. Java3D, GL4Java, LWJGL and more. In fact, our (open source) toolkits use all of these and we have hundreds of users running on everything from PDAs up to CAVEs all done in Java. We've just released code to handle Elumens Domes/VisionStations too, which, again, is in Java (although that one required a small amount of native code to slap Java3D into gear to do it).

Take a look at Xj3D for more information.

iteration

[jefu]

While most of these changes are quite positive, I think the iteration mechanism still could use some changes. Most simply, along with :
for (int i : C) {... }
also allow :
for (int i : C.iterator) { }
so that iterators other than the default (the SimpleIterator named "iterator") could be used.

This would not complicate the iterator syntax much and would make using different iterators easy - and thats something that is often needed.

Since the "C" above is an expression, it could be a function that returns an "Iterable" - allowing interesting hackery to provide alternate iterators using inner classes or other fun. However while I think this allows programmers to do about what they need, it does not make things exactly readable and that is a bit bothersome.

Another thing I'd like, and would like to have efficient and easy to use, is a way to iterate over the indexes of an array - in particular a multidimensional array. I get tired of doing things like the following (which I can't get to indent easily) :

for (int i = 0 ; i < ilim ; i++)
for (int j = 0 ; j < jlim ; j++)
for (int k = 0 ; k < klim ; k++)
b[i][j][k] = a[i][j][k] + 1

It would be much easier to do something like

for ( (i,j,k) : a.indexes) { ... }

In a way, no.

[Latent Heat]

for (int i = 0; i is something I understand and can read in an instant. I call this a "C-ism" in that from C to C++ to Java to C# it means the same darned thing, and it occurs so often I don't have to blink when I see it.

for (int i : C) {}

or more properly

for (CMemberType cMem: C) {}

is something that I have to scratch my head about. The fact that people conflate i with c_mem and confuse a collection member with a loop index tells me that the new construct is going to give problems.

Yeah, yeah, Law of Demeter and all that style stuff, you shouldn't be pulling values out of objects and doing logic on them, you should be telling an object what to do and have it do it. But you can take all this OO purity so far, and the first way is instantly recognized by every C, C++, Java, and C# programmer.

You take all this OO purity stuff so far and you have something that looks like Objective C, Smalltalk, (God forbid) Eiffel, or C++ STL on a bad hair day. I am a Pascal person myself, but as of 2003 I am willing to concede that C-style syntax has won: there is a huge "installed-base" of programmers familiar with it. I am all in favor of staying consistent with it instead of going of inventing all kinds of bizarro syntax.

Re:Everyone's bashing java

[Jagasian]

The way generics are implemented in Java might be a hack, but parametric types are a very sound mathematical construction (see type theory, category theory, etc). When implemented correctly in a programming language, they can:

1. improve programmer productivity
2. improve quality of code
3. improve efficiency (speed/space) of developed software

However, I am sure Java's generics are nothing more than heavy syntactic sugar. Still, anyone who complains about generics in Java doesn't know very much about programming languages. Generics are a good thing, and Java's only mistake is that it didn't have them designed into the language from the begining.

Same goes for Java having "primitive" datatypes. Yeah, that just complicates both syntax and semantics. They seem to be patching up these problems with these new features.

Re:I'll care when native compilers become the norm

[Glock27]

Buuuuzzzzzz! Wrong! Nu-uh!

That is impossible. Java has to do the same as the C code, plus the extra overhead of doing the JIT. There is no way Java can be "as fast".

Ah, the "impossible" word. ;-)

You're presuming that the ahead-of-time compiler can "know" everything that the JITC can. That isn't true, in many common cases.

Another point regarding JITC compilation is that it can be for the exact target processor, something not typically the case for traditionally compiled programs.

All that said, current JVM performance certainly varies between 'better than C++' and 'worse than C++', with pathological cases in both directions.

The current 1.4 JVMs actually took a hit on some math operations, though that is supposed to be fixed in 1.5.

I hope gcj gets to the point where it supports the latest language spec. The libraries are tougher, and many of them aren't needed for interesting projects. For certain applications, an ahead-of-time compiler is nice.

By the way, for a good example of a 'fast' Java program, check out Eclipse from www.eclipse.org.

Lisp is not slow

[Anonymous Coward]

Lisp is certainly not slow, even when compared with C++. It can even do certain things faster than C++ with most tasks in a very acceptable range, including being much faster than java and having a much better and more stable garbage collector.

http://www.norvig.com/Lisp-retro.html

Also Java sucks when compared to Smalltalk in terms of productivity and ease of use. Smalltalk should be a mandatory first OO languages in universities especially for concepts. Java is more popular than Smalltalk and has a lot more libraries, standardization and available programmers, but it still sucks, albeit less than C++.

Everyone tries to defend languages that they're fond of and used to without getting out of their comfort zone and trying something that might be better. If someone claims that Java is better than Smalltalk or Lisp, then they have not worked with Smalltalk or Lisp.

There are a lot of good languages out there with useful features, nice libraries and support for different paradigms which are better. Take Objective Caml for instance, which is very fast, strongly typed, dialect of ML and is certainly a better language than many, but it is doomed to live in academia, because people from the industry (pointy haired bosses) are too dumb and scared to even know about these things.

However, I see these new additions to Java as a welcome change. Hopefully someday people would not have to use some other language in the JVM just to implement closures and hopefully Java will catch up with languages like Lisp and Smalltalk and Python and Ruby and Haskell and Perl and Scheme and Dylan after it finishes catching up with Objective C.

Re:Good ol days

[LordMazza]

Try Component Pascal. You can get a compiler here which will compile to either the .NET platform or to Java byte code, so you still have access to all that underlying modern stuff if you really want it. :)

Teach the kids Scheme or Smalltalk.-eToys.

[Anonymous Coward]

I agree with Squeak one can teach some powerful ideas even to kids (which is one of Alan Kay's goals). You can just like Java run applets in your browser.