Lew wrote:

Just to give you some ammunition and a caution: With Java 5 there were quite a
few changes.  The best known are the addition of generics, enums and the
"enhanced-for" loop structure.  Less well known but arguably more important
were the addition of the java.util.concurrent and related packages, and the
cleanup of the so-called "memory model" for multi-threaded programs.  These
have made multi-threaded, concurrent programs much easier to craft for
stability and reliability.

<http://java.sun.com/javase/6/docs/api/java/util/concurrent/package-summary.html>
gives a brief overview.

The memory model in Java 1.4 and prior had some subtle issues that tended to
show up more frequently in multi-processor architectures.  The new memory
model makes it easier to reason about and create correct concurrent programs.

The new API classes make it easier to implement concurrency and to prevent
bugs like deadlock and starvation, while maintaining high performance.

Furthermore, the JVMs have improved markedly since Java 1.3.  They are faster,
easier to tune and better at optimizing than ever before.  Current JVMs have
tricks to load faster and take up less memory than before.

On top of that, the new syntactic sugar since Java 5 does enhance programmer
productivity.

With all that said, it is not entirely unreasonable to maintain a Java 1.3
platform.  If you aren't encountering weird concurrency bugs and your
productivity is acceptable, it's understandable the boss is reticent to make a
change.

One way to ease concern is to create a testbed with the new Java version (6,
these days).  First, make sure your code compiles correctly on the new
platform.  The presence of keywords like 'enum' or 'assert' in old code causes
a glitch.  Assuming you get through that all right, measure performance
between the platforms.  You should see improvement with the current JVM.  (You
may wish to run it with options like "--server" to enhance optimization.)
Again assuming all goes well, you can then make a case for scheduling an
upgrade to the production platform.

There is no free lunch.  To take full advantage of the new features could well
involve some re-engineering of the code base.  Given that version 1.3 is seven
and a half years old now, and obsolete, and that the re-engineering will
generally improve the code (it probably needs it anyway - most older code
does), this is likely to be a worthwhile investment of effort.

(Java 5 is already over three years old - hardly a spring chicken among
software products.)