Tiger adds new complexity to Java

[Anselm Paulinus]

The whole aim of Jave from day one was to simplify the programming complexities that were in other programming languages such as C++ and it has to a large extent suceeded in doing this; thus becoming a mid level language in terms of difficulty when rated with languages like VB, C and C++. Is tiger out to change this objective?.

[somkiat puisungnoen]

Originally posted by Anselm Paulinus:
Is tiger out to change this objective?.

New Feature in Java 5.0
The development of J2SE 5 was led by Sun and progressed following the Java Community Process (JCP) to include input from a variety of constituents. Some highlights of J2SE 5:

- New language updates: Metadata, Generics, Enumerated types, Autoboxing of primitive types
- New JVM Monitoring and Management API
- Improved out-of-box performance
- New (but compatible) default Java look and feel


And This tutorial is explain to you about Java 5.0 Objective ::

http://java.sun.com/developer/technicalArticles/releases/j2se15/

[Jim Yingst]

No, the objective of Tiger is not to add more complexity. The objective is to simplify, and in most ways I believe it succeeds. In some ways it's not as simple as we might like, and in most cases this is because the new release must have a certain amount of backward compatibility with existing code. (E.g. erasure.) But I don't think there's any question that Sun might have wanted to make things more complex. That's just silly, IMO.

[Siripa Siangklom]

The additional power comes additional responsibility and complexity.

[somkiat puisungnoen]

Originally posted by Siripa Siangklom:
The additional power comes additional responsibility and complexity.

This seem like : The great power comes great responsibility ..

[Warren Dew]

Jim Yingst:

No, the objective of Tiger is not to add more complexity. The objective is to simplify, and in most ways I believe it succeeds.

Er, wha? Java 5 is clearly more complex than Java 2: new operators, new keywords, new syntax, without removal of the old. If their objective was to simplify, they failed.

I think their objective was to make the language more powerful, and they accepted a little added complexity as a tradeoff.

[Jeroen Wenting]

the objective is to simplify day to day operations while keeping the flexibility of the language intact.
In that it succeeds.

The old structures were left in place to guarantee the second objective as well as to ensure backwards compatibility with the masses of existing code written for previous versions.

IMO the only really dangerous part of the Tiger is the metadata. That's just asking to be heavily abused to produce self-writing code and things like that which are impossible to debug.

Generics add type safety to Collections and simplify the syntax for accessing Collections at the cost of a slightly more complex declaration syntax.
Enumerated types were missing from Java from the beginning, this is simply the closing of a void (albeit a small one).
Autoboxing is similar to generics in scope.
Metadata like I said looks highly dangerous to me.
The new LAF to me is unimportant as I don't use Swing in my regular work at all, so all that does is increase the download time and install size of the JVM a bit

[Ko Ko Naing]

Originally posted by Siripa Siangklom:
The additional power comes additional responsibility and complexity.

But Tiger achieve the additional power without additional complexity... As Mr.Jim Yinst mentioned before, Sun is not trying to make Tiger more complex than the previous versions and neither is the objective of Tiger...

[Nicholas Cheung]

I do wish SUN provides more wrapper classes/functions for complex algoritms, like sorting, etc, to reduce our coding effort.

Nick

[Ko Ko Naing]

Originally posted by Warren Dew:
Jim Yingst:

No, the objective of Tiger is not to add more complexity. The objective is to simplify, and in most ways I believe it succeeds.

Er, wha? Java 5 is clearly more complex than Java 2: new operators, new keywords, new syntax, without removal of the old. If their objective was to simplify, they failed.

I don't think learning new things such as new operators, new keywords, new syntax should not be viewed as complex stuff... Indeed those new things make us more easier to code with less effords than before... Then the complexity during the development period got decreased....

[Jim Yingst]

[Warren]: Java 5 is clearly more complex than Java 2: new operators, new keywords, new syntax, without removal of the old. If their objective was to simplify, they failed.

I agree as far as the language itself is concerned. What gets simpler IMO under 1.5 is the code that I can write using the language. To me, that greatly outweighs the added complexity of the language itself, which I think is generally slight.

[Nicholas Cheung]

I feel the old things are still there only becos they wanna support backward compatiability.

I feel you also dont wanna that, if you need to upgrade your current development environment from J2SE 1.4.2 to J2SE 5.0, you need to rewrite everything.

Nick

[Ko Ko Naing]

Originally posted by Jim Yingst:
[Warren]: Java 5 is clearly more complex than Java 2: new operators, new keywords, new syntax, without removal of the old. If their objective was to simplify, they failed.

I agree as far as the language itself is concerned. What gets simpler IMO under 1.5 is the code that I can write using the language. To me, that greatly outweighs the added complexity of the language itself, which I think is generally slight.

I do agree with Mr.Jim Yingst...

Warren, we got to be clear about what becomes more complex and what becomes simpler...

The objectives of Tiger is to simplify... It means that using the language to fulfil the applcation's requirement got simpler... Not in the internal implementation of Tiger itself...

I believe that Tiger's internal implementation got more complex than before... Language design got more complex, but the result from it is simpler usage for the programmers...

[Herb Schildt]

While I agree with many of the foregoing posts, I do need to add one thought.

I my opinion, generics do add complexity. Yes, they also add power and type-safety. Nevertheless, because of the way that generics are implemented, some programmers will initially have trouble with them. Furthermore, because generics are now deeped embedded into the language (and into the API!) all programmers will, in one way or another, need to deal with the complexity they add.

[Marc Peabody]

A way of thinking about it:

Let's consider spoken language...
If everyone spoke with only 50 words it would be VERY easy to learn but difficult to communicate. Me not know how talk good all small word. For each word you add to the vocabulary, learning the language becomes more complex but it becomes much easier to effectively communicate.

Tiger has added a few things to the Java vocabulary. It is more difficult to learn all of it now but can increase productivity. Also, realize that you're not FORCED to use the new... er, "words" of Tiger.
[ August 25, 2004: Message edited by: Marc Peabody ]

[Gregg Bolinger]

Originally posted by Marc Peabody:
Also, realize that you're not FORCED to use the new... er, "words" of Tiger.

Nor are any of you forced to use Java at all, nor do I see any of you participating in the Java Community Process, nor do I see any of you creating your own programming language. It's like bitching about the President when you didn't even vote.
[ August 25, 2004: Message edited by: Gregg Bolinger ]

[Herb Schildt]

Mark: You say Also, realize that you're not FORCED to use the new... er, "words" of Tiger.

In the case of generics, that isn't quite accurate. Because the entire Collections Framework and several other core API classes, interfaces, and methods have been retrofitted with generic type parameters, virtually all Java programmers will need to use the new generic syntax at some point.

[Warren Dew]

Jeroen Wenting:

IMO the only really dangerous part of the Tiger is the metadata. That's just asking to be heavily abused to produce self-writing code and things like that which are impossible to debug.

I would agree with that. Generics, the other major change, add complexity, but I think that complexity is more than compensated for by the safety that they deliver. (Though I do think that people who prefer to code in more of a Smalltalk runtime type checking style ought not to have to face compiler warnings for it.)

[Herb Schildt]

Warren and Jeroen:

As a point of interest, I have seen several comments over the past few months which also express concerns over metadata and its potential for abuse. It will be very interesting to see how this feature is used in practice.