A Peak into the JavaOne 2009 Classrooms

As an attendee of the 2009 JavaOne Conference, I was eager to drilldown into the latest and greatest Java technologies and technical session offerings.
##CONTINUE##
Accordingly, I thought I’d start off by attending a session dedicated to the Java Platform SDK Version 7 (TS-5363). Unfortunately, to my despair, when I approached the designated classroom, I found that this session had been canceled.

Although I was a slightly disappointed, I knew that there where many other sessions to choose from. With only a few seconds to spare, I meandered along and found myself in a session entitled "Script Bowl 2009: A Scripting Languages Shootout" (PAN-5348). As a traditional Java applications developer, this session would have been my least favorite topic to explore. However, to my surprise, I found this session to be an interesting and excellent overview of the most popular and powerful Scripting Languages.

Basically, as with any piece of software or hardware, choosing a suitable Scripting Language depends upon the technical and business requirements; moreover, in this session, five major Scripting Language gurus battled it out. First of all, Groovy was presented; and for those traditional Java developers (such as myself) Groovy may be well suited as it has a Java-like syntax yet it is also agile and dynamic. Additionally, Groovy provides features that are currently unavailable in Java such as closures and regular expressions.

Secondly, the JRuby guru took the stage and praised JRuby for its reflective, dynamic and interpreted object-oriented concepts as well as all the interoperability with Java platform applications and existing Java user applications.

Third, there was a Jython demonstration, and for those Python programmers who are dedicated to the Python syntax but would like to utilize the plethora of Java Classes instead of Python modules, Jython could possibly be the antidote.

Fourth, the Scala representative showed off its code magic, and for those who prefer concise code, Scala provides the benefit of a short syntax and static typing which results in a boost in productivity. Scala is likewise seamlessly integrated with the Java libraries and existing Java application code.

Finally, Clojure (the newer kid on the block) was revealed. As it turns out, Clojure can very beneficial to concurrent programming in which deadlocks must be avoided. Actually, having worked on Artificial Intelligent systems that utilized both Lisp and Java, I found Clojure, given it’s similarities to Lisp, to be the most interesting of the Scripting Language that were discussed here.

After having my Bowl of Scripting Languages, I proceeded to find a session that was better suited for my interest so I selected a session entitled “Small Changes in JDK Release 7” (TS-4060). As the title suggests, changes and enhancements to the JDK are most likely to be release candidates if they are relatively small. This small partiality combined with a broad applicability predilection exists to ensure source compatibility, binary compatibility, and behavior compatibility. Currently, there are still 120 possibly proposed good language enhancements waiting to be born (or aborted).

So what language changes are we likely to see in SDK 7 and beyond? I’ll highlight a few that were of particular interest to me:

1.) Automatic Resource Termination – this change would eliminate the requirement of the developer to clean up his or her used resources. In particular, resource closing with those messy try-finally blocks or try-try-finally-finally blocks could be completely avoided. Great news, right?!

2.) The Diamond Operator < > – this enhancement would eliminate the need to retype the Generics on both sides of the assignment statement. Instead of repeating the full Generics syntax on the RHS of the statement, the developer would simple type < > on the RHS and the datatype would be implied from the LHS.

3.) Improved Exception Handling – this change allows developers to catch multiple exceptions in a single try-catch. For example, the following single statement would catch all three types of exceptions:

try { …
}
catch (NamingException, RemoteException, CreateException exc) {
…
}

Again, I view this one as a fantastic change - using a separate
try-catch for every possible exception gets rather cumbersome and
tedious.

4.) String Switch Statement - this change allows developers to define a switch statement based on the String type. For example, the following code would now be legal:

String input = “string”;
switch (input){
case "string":
System.out.println("I am a string!");
…
I personally feel that the String Switch enhancement was long overdue and I can’t wait to start employing it!

Well, now that’s a lot to look forward to! Additionally information on SDK Release 7 can be found on Joseph Darcy’s Project Coin website.

-----------------------------
BY Terry-Lynn
Source：ZDNet

Copyright © 2009 CBS Interactive Limited. All rights reserved.