The evolution of the Java language and VM continues! Mark Reinhold (Chief Architect of the Java Platform Group) announced yesterday that the first release candidate for Java 7 is available for download, he confirms that the final released date is planned for July 28.

For a good overview of the new features and what’s coming next in Java 8, I recommend this video on the Oracle Media Network, which features Adam Messinger, Mark Reinhold, John Rose and Joe Darcy. I think Mark sums up Java 7 very well when describing it as an evolutionary release, with good number “smaller” changes that make for a great update to the language and platform.

I had a chance to play a bit with the release candidate (made easier by the Netbeans 7  JDK 7 support!), and decided to list 7 features (full list is here) I’m particularly excited about. Here they are;

1. Strings in switch Statements (doc)

Did you know previous to Java 7 you could only do a switch on char, byte, short, int, Character, Byte, Short, Integer, or an enum type (spec)? Java 7 adds Strings making the switch instruction much friendlier to String inputs. The alternative before was to do with with if/else if/else statements paired with a bunch of String.equals() calls. The result is much cleaner and compact code.

    public void testStringSwitch(String direction) {
        switch (direction) {
             case "up":
                 y--;
             break;

             case "down":
                 y++;
             break;

             case "left":
                 x--;
             break;

             case "right":
                 x++;
             break;

            default:
                System.out.println("Invalid direction!");
            break;
        }
    }

2. Type Inference for Generic Instance Creation (doc)

Previously when using generics you had to specify the type twice, in the declaration and the constructor;

List<String> strings = new ArrayList<String>();

In Java 7, you just use the diamond operator without the type;

List<String> strings = new ArrayList<>();

If the compiler can infer the type arguments from the context, it does all the work for you. Note that you have always been able do a “new ArrayList()” without the type, but this results in an unchecked conversion warning.

Type inference becomes even more useful for more complex cases;

// Pre-Java 7
// Map<String,Map<String,int>>m=new HashMap<String, Map<String,int>>();

// Java 7
Map<String, Map<String, int>> m = new HashMap<>();

3. Multiple Exception Handling Syntax (doc)

Tired of repetitive error handling code in “exception happy” APIs like java.io and java.lang.reflect?

try {
    Class a = Class.forName("wrongClassName");
    Object instance = a.newInstance();
} catch (ClassNotFoundException ex) {
    System.out.println("Failed to create instance");
} catch (IllegalAccessException ex) {
    System.out.println("Failed to create instance");
} catch (InstantiationException ex) {
   System.out.println("Failed to create instance");
}

When the exception handling is basically the same, the improved catch operator now supports multiple exceptions in a single statement separated by “|”.

try {
    Class a = Class.forName("wrongClassName");
    Object instance = a.newInstance();
} catch (ClassNotFoundException | IllegalAccessException |
   InstantiationException ex) {
   System.out.println("Failed to create instance");
}

Sometimes developers use a “catch (Exception ex) to achieve a similar result, but that’s a dangerous idea because it makes code catch exceptions it can’t handle and instead should bubble up (IllegalArgumentException, OutOfMemoryError, etc.).

4. The try-with-resources Statement (doc)

The new try statement allows opening up a “resource” in a try block and automatically closing the resource when the block is done.

For example, in this piece of code we open a file and print line by line to stdout, but pay close attention to the finally block;

        try {
            in = new BufferedReader(new FileReader("test.txt"));

            String line = null;
            while ((line = in.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            try {
                if (in != null) in.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

When using a resource that has to be closed, a finally block is needed to make sure the clean up code is executed even if there are exceptions thrown back (in this example we catch IOException but if we didn’t, finally would still be executed). The new try-with-resources statement allows us to automatically close these resources in a more compact set of code;

       try (BufferedReader in=new BufferedReader(new FileReader("test.txt")))
       {
            String line = null;
            while ((line = in.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }

So “in” will be closed automatically at the end of the try block because it implements an interface called java.lang.AutoCloseable. An additional benefit is we don’t have to call the awkward IOException on close(), and what this statement does is “suppress” the exception for us (although there is a mechanism to get that exception if needed, Throwable.getSuppressed()).

5. Improved File IO API (docs 1, 2)

There are quite a bit of changes in the java.nio package. Many are geared towards performance improvements, but long awaited enhancements over java.io (specially java.io.File) have finally materialized in a new package called java.nio.file.

For example, to read a small file and print all the lines (see example above);

       List<String> lines =  Files.readAllLines(
       FileSystems.getDefault().getPath("test.txt"), StandardCharsets.UTF_8);

       for (String line : lines) System.out.println(line);

java.nio.file.Path is an interface that pretty much serves as a replacement for java.io.File, we need a java.nio.file.FileSystem to get paths, which you can get by using the java.nio.file.FileSystems factory (getDefault() gives you the default file system).

java.nio.file.Files then provides static methods for file related operations. In this example we can read a whole file much more easily by using readAllLines(). This class also has methods to create symbolic links, which was impossible to do pre-Java 7. Another feature long overdue is the ability to set file permissions for POSIX compliant file systems via the Files.setPosixFilePermissions method. These are all long over due file related operations, impossible without JNI methods or System.exec() hacks.

I didn’t have time to play with it but this package also contains a very interesting capability via the WatchService API which allows notification of file changes. You can for example, register directories you want to watch and get notified when a file is added, removed or updated. Before, this required manually polling the directories, which is not fun code to write.

For more on monitoring changes read this tutorial from Oracle.

6. Support for Non-Java Languages: invokedynamic (doc)

The first new instruction since Java 1.0 was released and introduced in this version is called invokedynamic. Most developers will never interact or be aware of this new bytecode. The exciting part of this feature is that it improves support for compiling programs that use dynamic typing. Java is statically typed (which means you know the type of a variable at compile time) and dynamically typed languages (like Ruby, bash scripts, etc.) need this instruction to support these type of variables.

The JVM already supports many types of non-Java languages, but this instruction makes the JVM more language independent, which is good news for people who would like to implement components in different languages and/or want to inter-operate between those languages and standard Java programs.

7. JLayerPane (doc)

Finally, since I’m a UI guy, I want to mention JLayerPane. This component is similar to the one provided in the JXLayer project. I’ve used JXLayer many times in the past in order to add effects on top of Swing components. Similarly, JLayerPane allows you to decorate a Swing component by drawing on top of it and respond to events without modifying the original component.

This example from the JLayerPane tutorial shows a component using this functionality, providing a “spotlight” effect on a panel.

You could also blur the entire window, draw animations on top of components, or create transition effects.

And that’s just a subset of the features, Java 7 is a long overdue update to the platform and language which offers a nice set of new functionality. The hope is the time from Java 7 to 8 is a lot shorter than from 6 to 7!

Early reviews of Google+ are in and they’re generally positive. Obviously, not everybody love Google’s latest social network experiment, but I’d like to debunk one piece of criticism that keeps being repeated over and over. And that is, that the Google+ Circles feature is basically the same thing as Facebook’s Friend Lists.

Facebook Friend Lists lets users group friends under different lists; family, co-workers, etc., so that you can share things with subsets of your overall Facebook friends. As in real life, you don’t share everything with all the people you know, and with the Friend Lists feature you can emulate that. Sounds very similar to Circles right?

The problem with Friend Lists is the poor usability of this feature. Unlike Circles, you get the feeling that this feature was tacked on, and that it’s not a central component of the service. Creating and assigning people to Circles in Google+ is a lot easier and friendlier than managing Friend Lists, just look at this video from Google which gives you a good overview of how the Google interface handles this.

The main problem with Friend Lists is that once setup they’re a pain to use, which is probably why a lot of Facebook users either don’t know about this feature or don’t bother to use it.

Let’s try to share a message only intended for our family;

First non-obvious thing you have to do is click on the padlock icon. This icon gives you 4 choices; “Everyone“, “Friends of Friends“, “Friends Only” and “Customize“. Unlike Circles, it doesn’t list your Circles of friends or in this case your Friend Lists. What you have to do here is select the “Customize” option which opens up the “Custom Privacy” dialog.

The “Custom Privacy” dialog now gives us another 4 choices; “Friends of Friends“, “Friends Only“, “Specific People…“, “Only Me“. Again, Facebook decides not to show you your Friend Lists, and to select one you have to chose the “Specific People…” option. Now, in the previous screen, we already told the interface we don’t want to send a message to “Friends Only” or “Friends of Friends”, why is it showing us these options again? Bad UI design.

There’s also the strange option to only share an item with yourself (“Only Me“), I guess that’s usefull to save things and share them later. But instead of listing this, I’d rather see my family Friend List.

To find our desired list, again we select “Specific People…“ (1), which shows an empty text entry field. As we start typing “f” for family (2), Facebook is nice enough to show us friends with first or last names that contain the letter “f”. Note that I have so many friends with that letter that in none of the choices my family Friend List shows up. After typing a bit more, “fa” (3), we still see other friends but at the bottom of the choices we finally see our family Friend List. Finally we select it (4) and our family list is added to the field.

Another bad design choice is how Friend Lists are mixed in with regular (singular) friends, at the very least it would be nice to get a visual hint that something is a Friend List vs a singular specific friend.

We then click “Save Setting” at the bottom right of the dialog and go back to our Facebook wall. Obviously, the last step is to press the “share” button, unfortunately Facebook doesn’t make it clear what Friend List or group of friends I’m sharing with. To see that, you need to click again on the padlock icon which instead of indicating what Friend List is selected, it shows a cryptic “Custom edit” selected item on the padlock popup menu. Not clearly showing who we’re sharing with makes it easy to share the wrong thing with the wrong group of people by accident. Again, bad UI design.

And that’s how Friend Lists are used in Facebook. The feature is hidden via the padlock icon, the option is not clear (“Customize“), selection is cumbersome, and Facebook does its best to hide away Friend Lists from the user. It’s almost as if the UI is designed on purpose to discourage the use of this feature.

In contrast, in the Google+ interface, you simply type the text you want to share (or image, video, etc.) and then click on the “Share” button;

From right there you can select with Circle of friends you want to share with. The Circle can be typed in or selected from the list, if it’s not shown in the list simply clicking “more …” will show the rest of the Circles. Unlike Facebook, Circles are not hidden but featured front and center. In this case 2 clicks allow me to quickly select who I want to share with.

Another key usability item to note, once a Circle is selected, Google+ makes it very clear who you are sharing with. In this example we can see the family Circle highlighted in blue and with a Circle icon to denote it represents a group of people. Singular friends added to the group, will also be shown highlighted in blue but without the Circle icon to differentiate them with Circles.This is much better than clicking on a padlock and trying to figure out who “Custom edit” is.

Simply put, when contrasting both approaches we note that;

1. Google has spent a lot more effort on usability in their User Interface design; minimizing clicks, removing the need for additional dialogs, preventing users from sharing information with an unintended Circle, etc.
2. Circles is a key and central feature of Google+, whereas Friend Lists seems more like a feature added as an afterthought, rather than a fundamental aspect of how people share information with different groups of friends.

It is clear that Google+ Circles are friendlier and easier to use than Facebook Lists. On this one central aspect of sharing, it seems Google has done their homework while Facebook really needs to evaluate and reinvent their approach to usability.

A photo I took with James Gosling, during happier times (for Sun)

Uh oh … “Why I Quit Oracle”

eWEEK got quite the scoop interviewing Java creator James Gosling, where he finally spills the beans on why he quit Oracle earlier this year.

If you are a tech geek, or more likely a Java geek, you probably know who Gosling is. I first saw him presenting at my first JavaOne, and in JavaOne 2006 was fortunate enough to talk to him about how we were using Java for one of our projects and take a picture with him.

It’s hard to image a JavaOne without Gosling’s on stage and infectious enthusiasm. His tradition of catapulting T-shirts into the audience will be missed (maybe somebody at Oracle will give it a try? Let me know).

In the interview he mentions several things that contributed to his discontent; his salary, a modified job title, and perhaps more importantly a feeling that he had lost quite a bit of control and influence over the important decisions dealing with Java.

Gosling is a bit uncharacteristically harsh when he describers his previous boss,”He’s [Ellison] the kind of person that just gives me the creeps,”.

Ouch.

I have mixed feeling about this article. At first glance, and considering the timing (week of Oracle’s first JavaOne), it sounds like sour grapes. That was my first reaction. To be fair to Oracle, I don’t think it’s horribly unreasonable that if they acquired a company that wasn’t able to sutain itself, a lot of things were going to change, and they all include a lot of what James mentions (who makes decisions, job titles, how you are compensated).

A good example is this:

However, at Sun, any executive that was a vice president or above was given what amounted to a bump or bonus based on the performance of the company. “In a mediocre year you did OK, but in a good year you did great” in terms of this compensation, he said.

Perhaps this was part of the problem? Maybe Sun executives shouldn’t have been getting bonuses at all in a “mediocre year”. I’m not sure Oracle is being entirely unreasonable here.

On the other hand, based on Gosling’s description, it sounds like things could have been handled much better. He mentions that he felt he and his peers felt that their ability to decide anything was gone, and it’s completely understandable that this would be extremely frustrating. Specially when he’s the creator of the language, and is a well known and respected “tech celebrity” (do people in the real world know there’s such a thing?).

At the end of the day, Gosling has every right to complain, just like Oracle has every right to make internal decisions about how to run their business.

I hope James Gosling can still find ways to contribute to the project he gave birth to, just like people like Gafter and Bloch continue to be involved even though they work at different companies now (I mean Gafter is at Microsoft of all places!!!).

You can follow what James Gosling is up to at his blog.

JavaFX Script is officially dead.

Oracle has decided to continue investing in JavaFX as the UI platform for Java client applications, but at the same time they’ve realized that the JavaFX Script language was probably a limiting factor in the general adoption of their RIA technology.

History

On November 8, 2006, Sun engineer Chris Oliver published an entry in his blog introducing a project he had been working on called “F3″. His blog entry explained the general concepts behind the project;

My name is Chris Oliver. I came to Sun through their acquisition of Seebeyond in September 2005. I’d like to present something about my current work – it’s not public yet but it should be open-sourced on java.net shortly.

My project is called F3 which stands for “Form follows function”, and its purpose was to explore making GUI programming easier in general.

F3 is actually a declarative Java scripting language with static typing for good IDE support and compile-time error reporting (unlike JavaScript…), type-inference, declarative syntax, and automatic data-binding with full support for 2d graphics and standard Swing components as well as declarative animation. You can also import java classes, create new Java objects, call their methods, and implement Java interfaces.

Chris’ first blog post on F3 introduced code snippets showing off the main features of the language, and a follow up post had a set of very impressive demos meant to show off the language and how it could compete with other RIA technologies like Flash.

At JavaOne 2007 F3 was rebranded as JavaFX Script, and we were shown some cool demos, like this JavaFX PDF Reader which unfortunately was never released.

JavaFX 1.0 was released on December, 2008.

At JavaOne 2009, Sun showed off a much needed JavaFX designer tool. The demo showed how the tool would allow for visual design of JavaFX applications on different “screens” (desktop, mobile, TV, etc.). This tool hasn’t been released to the public, instead there’s a more developer oriented Netbeans plugin with Matisse like UI design capabilities that was released a while ago.

But it’s not Java

The complaint I would often hear from developers when talking about JavaFX is that it was not Java. Unlike Java, F3 was designed from the beginning with UIs in mind. Chris Oliver wanted the flexibility of a declarative language, and decided that XML was not the best fit for this, thus the need for the F3 language.

The problem was that the new language was very different from Java. I remember doing a JavaFX Script presentation for a JUG in Panama, and even after having written a few programs in it, the context switch between it and Java was quite big for me.

At the last JavaOne I attended, I could overhear a lot of people rejecting the idea of learning yet another new language just to do a Java based UI. Not only a new language, but one that was so different from what they were used to. People often forget that one of the reasons Java dominates the development landscape today is because it was so similar to it’s predecessors; C and C++. While the benefits of a new UI focused language are many (the binding features alone in JavaFX Script are a good example), one thing that I’ve noticed is that modern UIs are being done in less exotic ways; just take a look at the UI framework in Android which is Java language based and on iPhone which uses Objective C.

JavaFX technology in Java, and other languages

Oracle has published the proposed roadmap for JavaFX 2.0. The key standout feature listed there is “Port JavaFX Script APIs to Java”, which will make JavaFX not only easily available to Java developers but to those who use other dynamic languages like Scale, JRuby, Groovy, Javascript, etc. The roadmap also mentions support for lambda expressions (closures), which I can already see being very useful for UI programming.

There are other notable features listed there, like additional UI controls, web views and integration with HTML5, HD playback, etc. The roadmap mentions the binding API, I’m curious to see how it would be integrated in the core Java language.

I think Oracle has made the right move here, the JavaFX stack is already pretty advanced and shows a lot of promise. It should be used more, but was being hindered by the lack of adoption of JavaFX Script. Porting these APIs to Java, and supporting other dynamic languages should allow a lot more developers to leverage the power of JavaFX.

Sorry for the long post, but I wanted to include a bit of history at the beginning about F3. I wonder how Chris Oliver and the other engineers that worked so hard on the core JavaFX Script language feel about this development. Hopefully they feel pretty proud about their work, because even though the language is being dropped, it seems the core of JavaFX is pretty strong. Adoption should grow now that there is no “new language” excuse.

At least that’s what I’m hoping for.

So Delta has a cute “We’re Experiencing Some Turbulence” error message when they have an internal error on their website. I’ve seen this error many times before, I think the first time I chuckled a bit.

The other day I was enjoying the new Wi-Fi Delta offers in some of their flights. I checked my email, my facebook account, everything worked great. Then it occured to me to check my delta account. I was wondering if they credit your miles after take off or later when you land (yeah I was bored). Suddenly, I get the familiar error message; “We’re Experiencing Some Turbulence“. I go, “oh crap” what’s going on? For a couple of seconds I forgot I was getting an error message for a website, and thought I was reading a message about my flight, a problem serious enough that they bothered to notify me via the new Wi-Fi connection.

Now I did say it was a couple of seconds, of course I quickly realized this had nothing to do with my flight. But for a couple of seconds I did get a bit freaked out by the message, specially seeing it on my browser. It got me thinking; how did my brain go into alert mode that quick when I know better?

It was all about context.

The context in this situation is this; traveling on Delta flight, on the official Delta website, checking my account and current flight information and then getting a message mentioning a very specific phrase about air travel. Obviously, if I get this message at my home, the train or the airport there’s no problem. Everything changes once I’m on a situation that is directly related to the term used in the error message.

So it’s probably not a good idea to keep these cute error messages, when you think that there’s a new context for use of this site. Before it wasn’t possible to read this from a plane but now it is. It just highlights how sometimes when you consider usability, you have to think about all the possible scenarios that your users will be in while interacting your application.

BTW, I’d love to hear from other people on potential error messages that might be scary in other contexts.

During this morning’s JavaOne general session, the “James Gosling’s Toy Show”, Tor Norbye gave another preview of the “JavaFX Authoring Tool” (TODO: Needs a cool codename!!!).

In 2007 when I blogged about the original JavaFX announcement at that year’s JavaOne, one of my first questions was about the tooling. At first we basically just had JFXPad to play around, then came more integration with Netbeans. However, these are not designer tools, and a RIA application needs more access points of people who are not software developers. This was partially answered with the JavaFX plugins for tools like Adobe Photoshop and Illustrator, but what was really missing was a visual place to bring content together interactively and created animated content.

So now we see glimpses of the JavaFX authoring environment that Sun plans to release. The tool seems to be in the early stages of development and it is unclear when it will be released. However, some of the features look very compeling and familiar. Like any of the versions of the Adobe Flash tools, it features a timeline with the ability to edit key frames and create animated transitions. It also allows you to drag and drop media and JFX components (including the new 1.2 controls) to compose your app.

The coolest feature is that the tool aims to deliver on the “multiple screens” theme of JFX, you can easily output your project for a JFX desktop application, mobile and the plan is to have output for TV applications.

The following videos demonstrate the basics of the tools …

And this next video features the visual binding feature that allows you to graphically bind properties between target and source objects, with inline display of the properties.

The tool looks nice, but it’s too early to compare it to any of the equivalent Adobe or Microsoft tools. To me this type of tool is key to adoption, so I wish the team the best of luck and that they hopefully find an effective way to get feedback via previews just do sanity checks on the tool (hint, hint, I wouldn’t mind preview access

One final note, I think there’s a need for a JFXMattise like tool. I don’t know if this tool is it, I don’t think so. Basically, maybe a subset of this tool, embedded in Netbeans that allows developer type people to visually compose their JFX applications, with an emphasis on visual UI control and layout composition. As it stands, I think there’s a big gap there even if this tool is released.

Update 1: I added another video showing how you can edit “multiple screens”. That is, tweak your JFX application in other devices with different resolutions out of a main project. In this case, you can have this full resolution application with several smaller windows targeted for mobile devices. The cool thing is that you can tweak one of the target devices to say have less buttons so it can still be tailored for other platforms.

Also Tor has posted a blog entry about the tool (which is the current project he’s working on).

Update 2: New screenshots of the JavaFX Design Tool