Java SE 6u18 Performance Improvements

Unlike the u17, the u18 update is not released for security, instead, it introduces many improvements on performance.

Faster Jar File Creation If you application need to create a lot of jar files, you will see about 20 percent improvement.

Hotspot VM Enhancement This includes some hardware-aware features, garbage collection improvements, class loading optimization and compile time optimization on code generation. The improved G1 garbage collector is still not yet ready for production, unless you have business support contract with Sun.

Application Startup Time Improvements If you are using JavaFX, you will notice about 20 percent improvement when launching an FX application. Web start and applet application can now download jar files concurrently.

Other improvements include runtime UI application performance, zip file reading and deployment updates. For more info, please check out here.

Other links:

JavaFX Plug-in for Eclipse 3.5.x
javaFX used in Winter Olympics 2010
Review on Essential JavaFX
JavaFX How-tos

Australian Citizenship Test
Free British citizenship Test
US Citizenship Application

Java SE U18的性能提高

JavaFX Used in Vancouver Olympics

I am not sure if this is the first web site that uses JavaFX for production, the official web site of the Vancouver Winter Olympics 2010 is using JavaFX for displaying the medal history of the Winter Olympics Games. In this winter, Vancouver is probably hot for Olympics, so is JavaFX. ( Check it out here: )

This is a very cool demo (oh, I should say real world application) of the JavaFX visualization technologies. Overall, it works well except for some animations were not so smooth. Though the same effects can be achieved by Flash, I would say this is a good start for JavaFX going into practical use. Hope to see more and more such applications in JavaFX.

Other Links:
Games in JavaFX
JavaFX Resources
British Citizenship Test: Life in the United Kingdom Test for settlement and Citizenship

UK Citizenship Test on iPhone

Review on the Book “Essential JavaFX”

It has been a year since the official release of JavaFX. JavaFX had gone through 3 major releases and now the current version is 1.2.1. There are a few books out there on JavaFX. Today I would introduce the book “Essential JavaFX” by Gail Anderson and Paul Anderson. The book is also available in Chinese and it was translated by Sun Asian Globalization Center. You can read my review in Chinese.

Gail and Paul are the founders of Anderson Software Group, Inc. They are both experienced software professionals and instructors. They have coauthored a few textbooks. “Essential JavaFX” is their latest book for people to learn the JavaFX script language. The JavaFX team at Sun had provided technical guidance for the book. The content conformed the JavaFX 1.2 SDK. For this reason, the book can serve as an excellent textbook for students or beginners. Other JavaFX programmers may also find it helpful as a reference resource.

As stated in the preface, the book is primarily for developers with some previous experience in any programming language(not necessarily Java). Readers without any programming experienced are advised to first learn some language such as Java or C++. In my opinion, because the strong intrinsic relationship between JavaFX and Java, I would consider that Java programmers are the most likely to learn JavaFX and have the lowest barrier to master it. Other developers with OO (Object Oriented) programming experience may also find familiar concepts and syntax in JavaFX.

I have multiple years of experience in various programming languages such as VB, Java and C++. When I start to learn a new language, I usually go through a HelloWorld like example to quickly understand its style and characteristics. Then I will skim through its grammar or syntax. After I got some basic ideas, I will dive into the details of each language construct. I find this approach extremely effective. Since the chapters of the book are organized in the same way, I find it very easy to follow.

The first chapter tells you how to download and setup your development environment. You basically need JavaFX SDK and NetBeans IDE. If you have experience on modern IDE like NetBeans or Eclipse, it won’t be difficult for you to install everything. A working development environment speeds up your progress in learning because you can try out the sample code while you are reading the book.

The second chapter provides an overview of JavaFX by an example called GuitarTuner. This example gets you on fast track to understand key concepts in JavaFX, such as declarative syntax, scene graph, binding and animation. After the first two chapters, you will probably get a feel of what functionalities can be achieved by JavaFX and how they are done in the language.

The third chapter is about the language elements, such as variables and types, operators and expressions, classes and objects, functions and triggers. This chapter may seem tedious for experienced programmers. However, these are the fundamentals of a language, so my suggestion is to go through it fast and come back from time to time for language references.

The next two chapters introduce the graphical objects and UI components. You need to know them in order to construct your UI by using nodes, shapes, layouts, skins and SWING wrappers provided by JavaFX. If you know SWING or Java2D well, you may be able to identify some links between JavaFX and Java.

The sixth chapter elaborates on a JavaFX project “Piano” to demonstrate various features to build a rich application. By digesting this example, readers learn how to put everything together to build a JavaFX application. After finishing this chapter, a Java programmer should be able to write applications in JavaFX.

Chapter 7 and 8 illustrate two important features of JavaFX: animation and image handling, which include topics on Timelines, Keyframes, interpolation, path, transition, Image and ImageView classes. If you want your application to get “richer” and have better user experience, you should spend more time on these two chapters.

Chapter 9 gives more details on getting internet data through RESTful web services. Getting remote data is almost a must for any RIA. Readers will learn two classes of JavaFX: PullParser and HttpRequest to retrieve and parse JSON or XML data. An example shows how to invoke web services from flickr’s photo services.

The last chapter describes how to develop a JavaFX mobile application. The Mobile Emulator in NetBeans is introduced. If you are going to develop a mobile application, you should definitely read this chapter to understand some mobile-specific issues. As an example, the authors walk you through the process of migrating a desktop JavaFX program to run on a mobile device.

In general, the content of the book “Essential JavaFX” is easy to be understood and the examples are quite instructive. I think the authors probably aim at writing a textbook for junior or intermediate programmers, hence some advanced features of JavaFX are not covered, such as multi-media and reflection. To sum up, I would recommend it to people who are about to learn the JavaFX language. It helps you learn JavaFX effectively.

P.S. if you are interested in other JavaFX books, you can check out Jonathan Giles’ blog of Mini ‘Pro JavaFX Platform’ Book Review. I may write some comparison of a few JavaFX books too. So check back my blog later.

Earthquake Hits JavaFX

What does an earthquake have to do with JavaFX? It is not so obvious, eh?

After I published my post about a JavaFX Online Wish Tree Application, I received some emails from readers reporting there were some problems to start the JavaFX client of the wish tree demo. I double checked and found nothing wrong in my code and the deployment environment. So I provided some hints and started to work with those readers to troubleshoot the problem. javafx online Wish Tree

After a few rounds of emails back-and-forth, we finally determined that it was due to a recent earthquake occured near the Taiwan region. The earthquake caused serious damage to the communication cables underneath the Pacific ocean. These cables are backbones connecting the internet between Asia and North America. As a result, people in Asia could not visit almost 70% of web sites located in North America. Still, how was this related to my JavaFX app? Here is the fact: the JNLP file of JavaFX requires connecting to every time the application gets launched. Due to the outage of network, users in Asia could not connect to This eventually caused the failure of launching my JavaFX demo.

Since Sun does not allow redistribution of the JavaFX binary code, a user must connect to to get some necessary jar files in order to run a JavaFX application. I suppose JavaFX should provide an alternative approach to resolve this kind of issue. Right now, the workaround is to have the javafx jar/dll files uploaded to the web server and modify the JNLP file to include them for the application.

Other JavaFX Articles:
JavaFX Nodes Usded in Swing Apps       JavaFX API for Java
Building JavaFX Menu       How can Java Code Call JavaFX?

JavaFX API for Java?

Last week, in a poll many java developers said they did not want to use JavaFX in their applications. A reason is probably that the APIs of JavaFX is not yet stable. It is true that JavaFX language itself is still evolving. If we search on the internet and we often get obsolete examples which no longer run in the latest JavaFX version. So “pay attention to the publishing date” is a useful tip when you are looking for documents on JavaFX.

The second reason that developers stay away from JavaFX is the lack of convenient way to integrate existing Java applications with JavaFX. Undoubtedly, the strength of JavaFX is that it is based on Java. It gets compiled into bytecode, runs on a JVM and it can call methods of java classes. While compared with Flex or Silverlight, JavaFX has the advantage of n million of Java developers and a huge amount of Java applications. This is great and it gives a robust start to JavaFX. Unfortunately, there is no official way(except for reflection) for Java to fully utilize JavaFX features directly. This becomes a substantial barrier for people to adopt JavaFX.

JavaFX’s attraction to Java developers is the functionalities that are not available in Java SE, such as animation, media processing, charting. However, the price may be too high for developers to convert their existing Java code into JavaFX only to leverage the new features. There are many Java applications out there which cannot be easily changed, esp. for enterprise applications. If we have an easy way to call JavaFX functions from Java, the adoption of JavaFX in the Java developer community will be a lot faster and wider.

I think an ideal architecture of JavaFX API may look like this:

I am not sure technically how difficult it is to come up with a JavaFX API for Java, but I think it should be given some consideration for future JavaFX releases. Since JavaFX is still in its early stage of development, I hope we can see something like this sooner rather than later.

Related Articles:

How to Display JavaFX Scene in a Swing Window

Using JavaFX Features in Java

Interoperability between JavaFX & Java

How to Show a SWING Menu in JavaFX

Convert Swing to JavaFX

Pure Java Code to Call JavaFX Class

In my previous post Interoperability between JavaFX and Java, I discussed three possible approaches to invoke JavaFX features from the Java side. These approaches were:

1. The ScriptEngineManager class. It is based on JSR-223, the java scripting API, which allows a java program to call a script(such as JavaFX Script, javascript).
2. The JavaFX reflection API. It can probably call any classes in JavaFX.
3. The JavaFX class implements a Java interface so that a Java program can invoke the JavaFX class via the interface. The interface acts as a bridge between the two sides.

The third one seems the most elegant to call JavaFX from Java. However, there is a drawback: the program should start from the JavaFX side. The reason is that it is simpler to use JavaFX code to instantiate the JavaFX classes which can be passed to Java code. Nevertheless, in some scenario, it would be better to start the program from the java side. For example, if you want to add in some JavaFX features to an existing large java application, it is better to have java code as the entry point. To solve this issue, I am combining the essence of Approach 2 and 3 to create the below example.

Let’s say we want to invoke the latest charting functions of JavaFX 1.2 from the java code. We will first use the JavaFX reflection API to instantiate the JavaFX class. We then use it via its java interface. So we define a Java interface first.

 * @author Henry Zhang
package javatest;
public interface JavaInterface {
  public void addData(String name, float data);
  public void showChart();

The next step is to create a JavaFX class MyChart to implements this interface:

 * MyChart.fx
 * @author Henry Zhang
package javatest;

import javafx.scene.chart.PieChart;
import javafx.scene.Scene;
import javafx.scene.text.Font;
import javafx.scene.text.Text;
import javafx.stage.Stage;
import javafx.scene.chart.PieChart3D;

public class MyChart extends JavaInterface {
  var chartData :  PieChart.Data[] = [];
  public override function addData( l:String, v: Number):Void {
    var labelString = l;

    var data =  PieChart.Data {
      label : l
      value : v
      action: function() {
        println("{labelString} clicked!");
     } ;

    insert data into chartData;

  public override function showChart() : Void {
    var chart =
      PieChart3D {
        data : chartData
        pieThickness: 25
        pieLabelFont: Font{ size: 9 };
        pieToLabelLineOneLength: 10
        pieToLabelLineTwoLength : 20
        pieLabelVisible: true
        pieValueVisible: true
        translateY: -50

    Stage {
      title: "PieChart Window"
      width: 520
      height: 300
      scene: Scene {
        content: [
          Text {
            font : Font {
                    size : 16
            x: 200
            y: 20
            content: "Pie Chart"

The last thing is to write the java main class JavaTest.

 * @author Henry Zhang
package javatest;

import javafx.reflect.FXClassType;
import javafx.reflect.FXLocal;
import javafx.reflect.FXLocal.Context;
import javafx.reflect.FXLocal.ObjectValue;

public class JavaTest {
  public static void main(String args[]) {
    Context context = FXLocal.getContext();
    FXClassType instance = context.findClass("javatest.MyChart");
    ObjectValue obj = (ObjectValue)instance.newInstance();

    JavaInterface ji = (JavaInterface)obj.asObject();

    String [] labels = {"January", "Febuary", "March", "April"};
    int [] values = { 18, 20, 25, 37 };

    for ( int i=0; i < values.length; i++ ) {
      ji.addData(labels[i], values[i]);


In the above code, there are three lines for instantiating a JavaFX class via reflection:

    Context context = FXLocal.getContext();
    FXClassType instance = context.findClass("javatest.MyChart");
    ObjectValue obj = (ObjectValue)instance.newInstance();

The next line is to convert the JavaFX instance into a java interface so that it can be used by Java code:

    JavaInterface ji = (JavaInterface)obj.asObject();

If you are using NetBeans IDE, you can set javatest.JavaTest as the main class in your project properties(so that it can be the entry point of your program). Build this project you will get a javatest.jar. Running this program produces the below screenshot:

Java PieChart via JavaFX

To run it from the command line, use the below command:

   javafx -jar javatest.jar

Actually, you could do it in the purest java style by including all the JavaFX runtime stuffs, the command would look like this:

 java -Djava.library.path="<path to javafx sdk lib>" 
     -classpath "<all javafx sdk jars>" -jar javatest.jar

Since there are many jar files used by the JavaFX, this purest java approach turns out to be very troublesome. I would rather use the javafx command, which is a wrapper of the above java command.

Please leave comments if you have any questions.

This article is cross-posted at Calling JavaFX Classes from Pure Java Code. The Chinese translation can be found at

JavaFX Used in Winter Olympic Games 2010
Review on Essential JavaFX
US Citizenship Practice Test

Pac-Man Widget for JavaFX 1.2

To fully take advantage of the power of JavaFX 1.2, Stephen Chin had just released the WidgetFX 1.2 API beta version. There is even a widget contest running until the end of July.

Just before the JavaOne 2009, Jim Weaver asked me to write a widget for my JavaFX Pac-man game. The WidgetFX API was quite simple to use, so I finished it pretty soon. The game widget later got demo-ed on Jim and Steve’s JavaOne sessions. There was a small problem of the pac-man widget: it run relatively slow due to the performance issue of JavaFX 1.1. Since JavaFX 1.2 and WidgetFX 1.2 are ready now, I am modifying the code to see the improvement on performance.

First, the code of the Pac-Man game needs to be modified a little bit for JavaFX 1.2 . Since multi-inheritance is gone, we need to use mixin classes now. You can refer to my articles on for details of the code. Changes for JavaFX 1.2 were given on comments of Article 4 by Patrick Webster. I also added in a pausing key(“P” button) handling for the game. I compiled the game into a pacman.jar file.

The next step is to write the widget. Actually, the code is quite simple if you do not have stuffs like configuartion etc. Let’s take a look at the code below:

 * PacManWidget.fx

package pacmanwidget;

import org.widgetfx.Widget;

 * @author Henry Zhang

def defaultWidth = 528.0;
def defaultHeight = 576.0;

def maze =  pacman.Maze {};

var widget:Widget = Widget {
    width: defaultWidth
    height: defaultHeight
    aspectRatio: defaultWidth / defaultHeight
    resizable: false
    content: maze          

    onDock: function():Void {

return widget;

In the standalone game, an instance of the Maze class was put into the content variable of a Stage. Now, instead of putting it into a Stage, we add it into a Widget. To do this, we can just set the content variable of a Widget instance. Other attributes of the Widget class are quite straightforward, mostly for resizing purposes. The next thing is to write a onDock() function to pause the game when the widget gets docked. The game can be resumed after pressing the “p” button when it is undocked.

The last thing is to deploy it on a web server. We need a JNLP file. Be sure to write the jnlp file of the JavaFX 1.2 style. Netbeans can generate the JNLP file which we can modify for deployment. I listed below part of my jnlp file. Besides the widget code PacManWidget.jar, there are supporting jar files( pacman.jar and WidgetFX-API.jar) under the /lib folder as well. Notice that there is a bug in the generated JNLP file by NetBeans 6.5.1: the <update> tag is missing a slash(/) at the end of the tag.

 . . . . . .
     <j2se version="1.5+" />
     <extension name="JavaFX Runtime"
     <jar href="PacManWidget.jar" main="true"/>
     <jar href="lib/pacman.jar"/>
     <jar href="lib/WidgetFX-API.jar"/>
 <application-desc main-class="com.sun.javafx.runtime.main.Main">
 <update check="background" />
 . . . . . .

Now, you can click on the below button to start the Pac-man widget for JavaFX 1.2. Enjoy!

Pac-Man Widget 1.2

Pac-Man Game Widget for WidgetFX 1.2

JavaFX Pac-Man Game Article 5

On, there was a post by kfarnham about my articles on writing Pac-man game in JavaFX. He wondered whether there would be a fifth article. The answer is positive. Yesterday, my last article of a series, “Writing the Pac-Man Game in JavaFX Part 5“, had been published on This final article detailed the chasing algorithms of the ghosts. I think it is probably one of the most interesting things in the code.

When writing the game, there are a few points we need to consider before designing an algorithm of the ghosts, such as effectiveness, randomness, simplicity. You can refer to the article about considerations on these aspects. An excerpt from the article is listed below in blue text. It discussed the choice of a proper algorithm. This algorithm not only serves as the chasing logic, it can also control the escaping behavior of the ghosts.

. . . . . .
After some thinking, I found that the distance between a ghost and the Pac-Man is a good ranking metric. The shorter the distance is, the higher the score is given to a particular choice. The advantages of using the distance as a metric are obvious. It is very simple and can be caculated easily. Besides, this algorithm makes a ghost move in the direction that has the shortest distance to thePac-Man. To illustrate this algorithm, let’s look at the below figure.

In the figure, the ghost Blinky is moving into an intersection from the right to the left. When it reaches the intersection, it has three possible choices of its next movement: to go up, to go down and to continue heading left. Going down is not a valid move because it hits the border of the maze. So we need to compare the other two options. The below table shows the computation of the distance of the two possible moves:

Choice X distance Y distance Total
Intersection 3 10 13
Up 3 9 12
Left 4 10 14

As shown in the table, the distance from the intersection to the Pac-Man character is 13 (The distance between two adjacent dots is 1). If Blinky goes up, the distance is reduced to 12. If it heads left, the distance becomes 14. Therefore, going up seems a better choice for Blinky. In this way, Blinky should be able to get closer and closer to the Pac-Man and eventually catches him.

Of course, this simple algorithm does not take into consideration for the walls in the maze. For this reason, sometimes the calculated score does not in fact represent the shortest path. However, this inaccuracy makes the ghosts appear “stupid” in the game, which is the randomness we want to achieve in the behavior. So we are going to implement it in our code. We rewrite the class MoveDecision. When the function evaluate() calculates a score, it takes in two arguments: the reference to Pac-Man instance and whether the ghost is in a hollow state. The variable distance is used to compute the score. If the ghost is going after the Pac-Man character, the score is 500-distance, which means a shorter distance yields a higher score. If the Pac-Man is hunting the ghosts(when they are hollow), the score is caculated as 500+distance. This makes the ghosts running away from the Pac-Man.
. . . . . .

Now that all the articles had been published and I hope you enjoyed reading them. The game was originally written in JavaFX 1.0, and was compatible with JavaFX 1.1. Because multi-inheritance has been removed in JavaFX 1.2, I made some minor changes to the code. The abstract class MovingObject had been changed to mixin class. The code for JavaFX 1.2 can be download from JavaFX Game Download Page.

You can now click on the below image to play the completed Pac-Man game, it is based on the newly released JavaFX 1.2 . With the improved performance, the game run very smoothly.

click to run

click to run

Related Articles:

JavaFX Pac Man Part 5
Develop Games in JavaFX
JavaFX MineSweeper Demo Game
JavaFX Demo Game: LinkUP
WidgetFX Game Widgets: Pac-Man
My First JavaFX Game Demo
JavaFX Discussion Blogs

The Featured Articles on

May 14, 2009: Writing the Pac-Man Game in JavaFX – Part 1

May 21, 2009: Writing the Pac-Man Game in JavaFX – Part 2

May 28, 2009: Writing the Pac-Man Game in JavaFX – Part 3

June 4, 2009: Writing the Pac-Man Game in JavaFX – Part 4

June 11, 2009:Writing the Pac-Man Game in JavaFX – Part 5