Use of “main” method

Each Java class can include a “main” method to perform class execution. This feature is especially useful for experimenting, testing and debugging the pertaining code within the class without resorting to using helper class. Generally it is more efficient and productive to test a particular class (if one already pinpoint the problematic class) rather than to test a whole application that has more overheads and which takes longer time to run. By including a “main” method in class, other developers can also quickly experiment with different API of the code within the class without creating additional testing helper classes. In addition, it is easier to build a reliable application if the classes that make up the application are reliable themselves. Apart from this, the use of “main” method will also encourage one to design the class to be “simplified” so that it can easily test from “main” method.

That to say that the “main” method is not a replacement for unit testing, and vice versa. Their intent and usage are different. Unit testing is more formal whereas the “main” method is less formal. Many test cases are included in unit testing and is run periodically to ensure that nothing break the code and create bug from modified code as in the case of time-consuming build process. Unit testing is usually automated and does not involve GUI interaction since the unit testing can be invoked in command-line prior to software development process like build process or check perform by version control system after code check-in.

On the other hand, the “main” method does not subject to such intense test and is not run unless one modify that class and want to have a quick test ensure correct behaviour and result. Developers are free to change whatever in the “main” method of the class during development as long as the “main” method of the class is not used to start up the application, and not call by other classes (It is bad practice to reference and use “main” method from other class.).

onModuleLoad: GWT’s version of “main” method

For those who create Java desktop application can benefit from the use of Java’s main method to help build reliable application. However, for those who use GWT to build desktop-like web application may not apparently take advantage of the “onModuleLoad” method as main method as the official GWT documentation did not actively promote it as equivalent of “main” method but rather frequently utilise it as the EntryPoint interface method to run a application, giving the impression that the onModuleLoad method is only applicable for class that use to start up a GWT application, and nothing more. That perception is further entrenched when GWT examples often use the following onModuleLoad signature to run the class that implements the EntryPoint interface.

In reality, GWT team has in fact make “onModuleLoad” method a lot more flexible and capable of behaving like Java’s “main” method.

Foremost, the following behaviours of “onModuleLoad” method make it possible to perform like Java’s “main” method".

• A class need NOT implement EntryPoint interface at all in order to be run as EntryPoint class. As long as the public “onModuleLoad” method is presented in the class, GWT will be able to run it. EntryPoint interface is optional but it is a good practice to implement it for the class that need to start the GWT application. In this way, one can easily use IDE to discover all classes that implement the EntryPoint interface (eg Intellij’s Find Usage)
• A “onModuleLoad” class need not be public in order to be run.
• It is possible to add a static qualifier to “onModuleLoad” method so it looks and behaves like Java’s “main” method. It is important that the “onModuleLoad” method is public if it did not implement the EntryPoint interface (all interface method is public).
   
• If the following signature is used,
  
        public void onModuleLoad() // Instance method
  
  The class must have a no-default-argument constructor (public, default, private) since GWT will attempt to instantiate the class using the default argument and after which it will call the “onModuleLoad” method. Otherwise, GWT will throw a NoSuchMethodException complaining that class has “no default (zero arugment) contructor”. Hence, using this signature enforce the “runnable” class to have a default constructor, and one has no control over how the class can be run (since GWT instantiates the class automatically and call the onModuleLoad) and designed (eg developers may not want a default constructor)
  
  

  class TestApp // implements EntryPoint <= Optional {   TestApp()   {  // This will always be called by GWT first }              // It is not good practice to call this method by other classes.     public void onModuleLoad()        {  // After class instantiation, this method will be called }    }

On the other hand,       

         public static void onModuleLoad()  // class method

behaves like Java’s “main” method. When the static qualifier is used, GWT will NOT instantiate the class but rather run it as class method (eg AppClass.onModuleLoad() ). This ramification means that one can decide how the class can be instantiated and how the constructor can be designed as in the example. This signature is more natural and preference to use since it conforms to the signature of the ubiquitous Java’s “main” method (public static void main(String[] args).

Note that if static onModuleLoad is used, the class cannot implement EntryPoint interface since interface method is for instance method not class method.

• There might be concern that having “onModuleLoad” method will make the resultant JavaScript file larger after Java-to-JS compilation. However GWT is smart to remove any “dead code” that is not used and thus “onModuleLoad” method will be removed during compilation as long as it is not referenced by other classes.

Just like one will often use “main” method to test classes in Java application, one can also leverages on “onModuleLoad” in GWT to perform similar function.

In Summary, this is the suggested guidelines:

• Only implement EntryPoint interface for the class that essentially use to start up a GWT Web application. That means this is the class that implement the “onModuleLoad” instance method since interface method cannot be static.

       public void onModuleLoad()  // EntryPoint Interface method
  

• For other classes, use the “onModuleLoad” class method

     public static void onModuleLoad()  // Behaving just like “main” method

• There should be one entry-point tag in the GWT XML module file for project.

Challenges

However, the use of “onModuleLoad” method as “main” method may feel unnatural since IDE currently does not support running the “onModuleLoad” class the same way as “main” method (eg Run directly from IDE). Currently, this is more a manual process whereby one will need to switch the entry-point tag explicitly pointing to whatever class that is to run in GWT module file.

* However, I am currently developing the switching application in AutoItScript that allows one to use it in Eclipse and Intellij that at least allow user to change the entry-point with a shortcut key easily without relying on IDE’s plug-in. This will be further elaborated in coming Part2 of this tip.

Objective

A profiler is a very powerful tool to help pinpoint performance and memory issues. It offers a variety of ways to which a developer can help track down classes that lead to dismal performance, inefficiency and memory leak issues. This includes taking and comparing snapshot at certain point in time, watching how CPU time and memory is consumed in realtime in a visual chart and marking interested classes for analysis.
There are many profilers in the markets , both open-source (eg VisualVM that bundled with Java SDK) and commerical offerings. However, this document will show the steps to configure two of the best commerical Java profilers in the market, YourKit and JProfiler, to profile GWT client application in Eclipse in the Windows environment.
Even though both profilers are just as effective and powerful, both use different approach to profile the application.

Still, the following steps will work with any IDE (eg Intellij ) since it is just a matter of adding adding additional profiler’s agent as argument to the JVM. All IDEs allow argument to be passed to the JVM that run the project application.

Yourkit and JProfiler offer a 15 and 10 days evaluation trial respectively.

JProfiler profiling GWT Web client app (FigA)

Yourkit profiling GWT Web client app (FigB)

Profiling GWT client Application

Profiling a HTML web client application is considered a tedious process. Despite having tools like Firebug to assist development, it may not be sufficient as these tools are not designed for robust software development, lacking sufficent important tools and conveniences to help analyze performance and memory issues at the code level. Besides, profiling JavaScript for memory leaks manually through analyzing DOM is a near impossible task consider that developers have to manually explore the DOM tree structure in a unintuitive manner.
Traditionally a Java profiler is used to profile Java application (eg desktop and server). GWT takes a unique approach of cross-compiling Java code into JavaScript to build complex AJAX web client application. Even though Java and JavaScript share a different language and behaviour characteristics, still the notion of resolving memory leak through best practices applies.  

Profiling JavaScript for performance and memory leak can be somewhat difficult if not “mission impossible”

http://googlewebtoolkit.blogspot.com/2008/11/profiling-gwt-application-performance.html

Configuring JProfiler
As of current, the Eclipse plug-in for JProfiler does not explicitly support GWT. However, through the use of Remote Session, the same result can be achieved.

For more information on setting up remote profiling,
http://resources.ej-technologies.com/jprofiler/help/doc/indexRedirect.html?http&&&resources.ej-technologies.com/jprofiler/help/doc/helptopics/config/remoteProfiling.html

There are essentially two steps after installing JProfiler.

1) Setup JProfiler GUI  to communicate with the agent.
2) Prepare GWT Project Configuration to use JProfiler through agent

1) Setup JProfiler GUI  to communicate with the agent.

Go to Session => Integration Wizards => New Remote Integration

Just accept those default options, and choose the desired JVM. The final screen will show the summary.

The wizard help to produce the necessary information that will be added into IDE’s project configuration.

Remember to add those PATH since it need to refer to those JProfiler DLL libraries.

The following line will be added to JVM argument. The JVM will be used to run the GWT system.

-agentlib:jprofilerti=port=8849  "-Xbootclasspath/a:C:\devsys\java\app\jprofiler\bin\agent.jar"

You can rename the session by [Session] => [Session Settings] so next time you can identify the session. Each session will automatically be saved for subsequent use.

2) Prepare GWT Project Configuration to use JProfiler through agent

To add support for profiling, simply add the above JVM line to the <VM arguments> in Argument tab of Run Configuration as shown below.

The final step is just to run the configuration as per normal, and also ensure that Session is listening for activity. Refer to (FigA) image.

The video will also show the whole process of configuring JProfiler and GWT project in Eclipse.

Configuring Yourkit
As of current, the Eclipse plug-in for Yourkit does not explicitly support GWT. However, through the use of Remote Profiling, the same result can be achieved.

For more information on setting up remote profiling,

http://www.yourkit.com/docs/80/help/agent.jsp

There are essentially two steps after installing YourKit.

1) Prepare GWT Project Configuration to use Yourkit through agent

2) Setup Yourkit GUI  to communicate with the agent.
 

1) Prepare GWT Project Configuration to use Yourkit through agent

There are other way to enter the agent path but the convenient way is to specific absolute path.

The following line will be added to JVM argument. The JVM will be used to run the GWT system.

-agentpath:C:\devsys\java\app\YourKit\bin\win32\yjpagent.dll

The final step is just to run the configuration as per normal, and also ensure and then startup Yourkit.

2) Setup Yourkit GUI  to communicate with the agent.

Upon sensing the agent running, Yourkit will automatically show the active session in the main screen. Simply click on that session will bring up analysis screen (FigB).

YourKit works by taking snapshot at various time for analysis and comparison

The video will also show the whole process of configuring Yourkit and GWT project in Eclipse.

Video

Watch the video because it says it all…

Final variable is used to define constant value and reference, and can only define once. In most cases, declaring a final variable is just a matter of assigning to a primitive value or a object reference directly.  However, in some cases, declaring a final class/instance variable may be more involving especially it get assigned from method that throws Exception (eg API for database access, web access), or it may involve multiple statements. In such cases, the code may become cluttered with class helper method and dummy temporary variable that help define final variable, making the code look less elegant and harder to maintain. The following common ways of declaring a final variable in those situations might look familiar to many.

Declaring final variable by instance/class method

 Declaring final variable by instance/class variable with static/instance initializer.

The aforementioned ways definitely get the work done but at the cost of elegancy. The helper method and variable help to define the final variable but it inevitably becomes part of class method and variable.

Recommended way: Assigner Design Pattern

A better way to declare final instance/class variable is to use Generic method and interface with the advantages of

• forcing initializing method in the same statement  as the final variable declaration.
• reusing as design pattern (term: Assigner Design Pattern) and enhancing code readability

There is generic helper class whose interface and method accept a parametric type similar to the type of final variable.  The advantage of using Generics is that the type mismatch will be caught at compile time rather than runtime. This design pattern is termed Assigner because it assigns value to a variable from initializing method.

Using the design pattern, the code becomes cleaner and elegant.

The above can be downloaded

assigner.zip (1kb)

Some will probably argue that Assigner Design Pattern may not be efficient compare to the first two ways since additional bytecode classes are generated for Assigner helper class and inner class. However, like other design patterns, code readability and reusability may outweigh the negligible performance loss and inefficiency.

I know exactly what you thinking because it is exactly what I’m thinking when I first see this surreal picture. A picture that is so skillfully doctored to show a large plane landing near to the coastline as short to the start-point of runaway. To created such a illusion with perfectly matched details to thwart even the meticulous critics will require very highly-skilled artist and countless hours of work. Just look at those shadow, lighting and other amazing details that fit so well with the environment, not to even mention that no airline in the world is so sane to put the public in such a dangerous area.

Amazing as it seen, this is NO Photoshop-ped image but a common sight that you will get to see if you happen to be in Princess Juliana International Airport in the Netherlands Antilles. Passenger plane that lands as dangerously close to the public accessible area with the wheels of the plane just few metres away from the fence is a trick that only pilots with the utmost confidence and judgment are capable of executing, and all this is done with zero-record of mishap.

The following video is the proof of its authenticity. No Hollywood special effect can even come this real <:^}.

How about experiencing the thrill from the pilot’s cockpit ?

I always thought that there is ought to be better way to develop JavaFX application, with kind of similar and gratifying experience as developing Java Swing application. Traditionally in developing desktop application, one normally develop and test using class file to save time, and only uses JAR file for deployment (or if running in mobile emulator or device). However with the advent of RIA platform, the trend is to use a application container file (eg jar, swf) as default way of development since it facilitates seamless running in several modes without hassle (eg as Applet, webstart, and mobile device). Unfortunately, this is rather inefficient if one is developing desktop application, or experimenting with ideas. Unnecessary waiting time only disrupts the creativity and programming flow. Saving a few seconds for every run will accumulate into significant saving of time. Besides, it is rather counter-productive to use container file as the only mode of development if the technology can support alternative efficient way.

Flex’s dilemma

The case in point is that JavaFX does not need to suffer the same fate as Flex in term of development. Flex which is based on Flash technology requires the generation of SWF container file for every change need to be made. This actually increases the waiting processing time as composite files that store in SWF file grow in number and size. For RIA application that a rich appealing user interface that relies extensively on custom-made graphics, developers often have to use lower quality “proxy” graphics in place of high-quality but larger file size graphics to avoid the time wasted to create SWF file for day-to-day development. Hence, developers have to find creative ways to improve the waiting time by reducing the number and size of files to be processed into the container file during development. In the future, Adobe will probably allows development and testing of application in “exploded” format rather than only through SWF.

JavaFX

So how does Flex’s “inefficient” development relate to JavaFX ? Like Flex, JavaFX default to using JAR file as mode of development in NetBeans. Everytime, a JavaFX application is modified, it will be compiled into a JAR file for execution. However, unlike Flex, JavaFX does not actually require using container JAR file for execution unless it is deployed as applet, webstart or mobile application. JavaFX is truly capable of running off from class file using classpath much like its Swing application counterpart. One less unnecessary step means one less waiting time.

JAR file execution: Compile => JAR generation => JavaFX.exe

Class file execution: Compile => JavaFX.exe

NetBeans support of “Running by class file”

Out of the box, NetBeans does not explicitly support JavaFX development through class file. The JAR will automatically be generated and run every time the application is modified and run. Developers do not have much control for this case from GUI side of view as see from the Project Properties. However, with some experimenting and understanding of how NetBeans works with JavaFX, it is in fact possible to make NetBeans supports running of JavaFX application by class file. Bear in mind that the subsequent method refers to running in Standard Execution model (Desktop application), not the webstart, browser applet and mobile mode as these modes require JAR file.

Since the default behaviour is to generate JAR file, it will be useful if the Standard Execution includes a checkbox to explicitly indicates running of Application by class file, thereby bypassing generation of JAR file.

Let’s start the exploration
The best way is to learn the concept along side with real practical example so that developers can follow and understand it better.  I am using Windows 7 running NetBeans 6.8 with JavaFX v1.2.3 (the latest as of current. Go to the end on how to add JavaFX v1.2.3 support to NetBeans 6.8 which contains outdated version of JavaFX).

In this case, I use a JavaFX sample example [PathAnimation]from NetBeans. The following applies to any JavaFX application develop in NetBeans. After creating the sample, run the JavaFX example once so that the following file structure will appear as below.

You have to use the Files view tab in order to see the full JavaFX application file structure.

There are many files in JavaFX application, however I will only  explain those files and directories that are crucial for “Running by class file”.

The  [build.xml] file is the first file that will be called to initiate the compile and run process.

As see, it actually call [build-impl.xml] file which contains the implementation instruction for the build file. This build file when invoke, will create the [build] directory and compile and store the JavaFX class file there (All JavaFX source will be compiled into bytecode class file). When run command is issued,  it will build the JAR file using class files from [build] directory into [dist] distribution directory and then invoke java command to run the JAR file. This is the default behaviour for JavaFX development in NetBeans.

Now open [build-impl.xml] file into the editor and modify some sections (you can also copy this file and alter the file and point that file in [build.xml] file. But for quick demonstration purpose, the original [build-imp] is used instead)

Modification of  [build-impl.xml] file

• “Disable” generation of JAR file
  Javafxpackager is a JavaFX tool responsible for compiling JavaFX source codes into corresponding Java class files, and generation of JAR file. Note that there is currently no way to turn off the generation of JAR file. The JAR file will always be generated (as far as I know).  It will be elegant if Javafxpackager include command-line option to produce java class from JavaFX source without generating JAR file although the following workaround will prevent this generation from happening

  Search for :
  <exec executable="${platform.fxhome}/bin/javafxpackager${binary.extension}" failonerror="true">
   
  a) Replace the line
  <arg file="${dist.dir}"/>
  with
  <arg file="k:\javafxhack"/>  where k stands for any NON-EXISTING drive. It is important to use a non-existing drive because Javafxpackager will attempt to create the directory. The dummy directory is needed to trick Javafxpackager into thinking that it is using a valid directory. If you are using Linux then adjust the path accordingly.

  b) Next, replace
  failoneerror="true"
  with
  failoneerror="false"  
  This step is important because Javafxpackager will complain about invalid JAR file from a) and will not proceed further until this is set to false. 

  After modification, you will get the following

  

• Running of JavaFX application through class file
  Since the JAR file is no longer generated, JavaFX application must be run through class file in the [build] directory.

  Search for:
  <java classname="${main.class}" classpath="${dist.dir}/${application.title}.jar" 
  

  and change it to the following:
  <java classname="${main.class}" classpath="${build.dir}/compiled"
  
   
  
  Now, JavaFX application is configured to run from [build/compiled] directory rather than through JAR file.

Running by Class file

Now,  run the JavaFX application, and NetBeans will show the following console message.

Even though the jar file cannot be found, the application will still be executed because it is now running off through class file.  You can delete the [dist] directory to verify that JAR file is not generated.

The time-saving is very much depend on the size of the JAR file. You can compare the time with and without using JAR file by simply adding FX.exit() at last statement of run() function of  Main.fx. NetBeans will report the time taken when JavaFX application terminates.

As for my case, this example running on Pentium M 1.5Gz takes around 9s on JAR file, and 6s on class file, a saving of 33%  time saved, though this timing varies from machine configuration and performance over time.

Tips

• You may want to create another build of [build-impl.xml] file (eg build-impl-classfile.xml) just for the above setting, and then change [build.xml]’s import tag to use the implementation file accordingly. 
• NetBeans will request for regeneration of [build-impl.xml] file for every change to Project Properties if you have altered the file. This will overwrite the changes you make. Hence, using alternate implementation file will be a good choice.
   
• For performance reason, NetBeans caches the settings of [build-impl.xml] file in memory, and any change to the file will not be recognized by NetBeans unless it is edited in Netbeans editor. This means that if  [build-impl.xml] file is modified outside NetBeans (eg using Notepad), and the project is run, those change will not take effect. Only updating the file in NetBeans will those change be reloaded.

Running JRebel with JavaFX

Yes ! It is true that by using the aforementioned method, you can actually use JRebel with JavaFX. In the past, there is no easy way that JRebel can work with JavaFX if the JAR file is used to run JavaFX application but by using the class file method to run the application, JRebel can now detect change to those classes automatically and perform its magic. Now, you can get more productive time by running through class file and using JRebel. The best way to see this effect is change the event handling through JavaFX function call

For some unknown reasons, I am unable to run the JRebel plug-in in NetBeans, however you can still use JRebel by adding the following to JVM arguments (change the JRebel path accordingly):

 -noverify -javaagent:"C:\devsys\java\lib\jrebel\jrebel.jar"

Just make the change and compile the JavaFX file, and JRebel will automatically reload those changes.

Video showing demonstration of JavaFX application running by class file and with JRebel

How to add JavaFX SDK v1.2.3 to NetBeans 6.8

You can update to the latest JavaFX SDK simply by replacing the old version with the new version.

Just place the updated JavaFX files into <NetBeans directory>\javafx2\javafx-sdk

Dyer: The first skill is what we call "associating." It’s a cognitive skill that allows creative people to make connections across seemingly unrelated questions, problems, or ideas. The second skill is questioning — an ability to ask "what if", "why", and "why not" questions that challenge the status quo and open up the bigger picture. The third is the ability to closely observe (observing) details, particularly the details of people’s behavior. Another skill is the ability to experiment (experimenting) — the people we studied are always trying on new experiences and exploring new worlds. And finally, they are really good at networking with smart people who have little in common with them, but from whom they can learn.

Fryer: Which of these skills do you think is the most important?

Dyer: We’ve found that questioning turbo-charges observing, experimenting, and networking, but questioning on its own doesn’t have a direct effect without the others. Overall, associating is the key skill because new ideas aren’t created without connecting problems or ideas in ways that they haven’t been connected before. The other behaviors are inputs that trigger associating — so they are a means of getting to a creative end.

Gregersen: You might summarize all of the skills we’ve noted in one word: "inquisitiveness." I spent 20 years studying great global leaders, and that was the big common denominator. It’s the same kind of inquisitiveness you see in small children

To read on, click here

Issue in NanoXML

Back in 2008, a version of NanoXML v2.2.4 is “unofficial” released to add comment feature (Javalobby mirror). However, there is one problem that persists which prevent developers from using NanoXML to manipulate xml file. The developers might use xml file for to store profile for their application and will need to manage xml file (etc delete, rename, add). However, it turns out that NanoXML is locking the xml file while waiting for the Garbage Collector to kick in and release the file. However the GC is behaving unpredictably and might not release the file as and when the program expects it. The developers will thus want more control over the release of file resource. Unfortunately, there is currently no API to force release of file resource under current release.

NanoXML v2.2.5

Therefore, I have modified NanoXML and released it as  NanoXML v2.2.5 to allow developers to use a specific method to release file resource manually so that the file can be manipulated (etc delete, rename).

• public void close()
  This will release all file resource that are held up by Reader.

The aforementioned method will release the file resource that is created using the static method IXMLReader fileReader(String filename) in StdXMLReader class.

Example

public class XmlTest
{

// ## means new features added.

    public static void main(String[] _args) throws Exception
    {
        IXMLParser parser = XMLParserFactory.createDefaultXMLParser();

        /*// If pass string, use stringReader
        IXMLReader reader = StdXMLReader.stringReader(“<root></root>”);
         */
        // Pass by file. Important to use toURL method otherwise exception will be thrown.
        IXMLReader reader = StdXMLReader.fileReader(
                new File(“c:/test.xml”).toURI().getPath());
        parser.setReader(reader);

        // parse() method does not include comment
        IXMLElement xml = (IXMLElement) parser.parse(true);   // ## true means parse comment too

        IXMLElement _x = xml.createElement(“newChild”);
        _x.setComment(“This is new child”); // ## Adding comment
        _x.setAttribute(“att1″, “me1″);
        _x.setAttribute(“att2″, “me2″);
        xml.addChild(_x, 0);  // ## Adding at specific position.

        IXMLElement _b = xml.getChildAtIndex(1);
        xml.removeChild(_b);  // Remove tag

        XMLWriter writer = new XMLWriter(System.out);
        // Default for write is excluded comment
        writer.setIncludeComment(true); // ## Include comment at generation.
        writer.write(xml, true);

        reader.close();

    }

}

Download NanoXML v2.2.5

The following file contains the full source code and the library jar file. To check on those changes that I have made, you can search for ‘GeekyCoder’ in the source code.

NanoXML-2.2.5.zip (93kb)

Released on 6 Feb 2010

I have to admit that I like the Default FullZoom Level extension which significantly improve on the FireFox’s rudimentary Zoom feature.

This extension not only put it in par with Opera’s highly acclaimed zoom feature, but it has a major advantage over the latter with the ability to add enhancement with the use of XUL programming. Default FullZoom Level is just a extension with full source code that I can peek and experiment with. What I like to do is to add a attractive real-time zoom called Visual Zoom, which takes the inspiration from Office 2007’s zoom. So instead of selecting from the popup-menu, you can just zoom using the slider with screen update in real-time. I mock up how it looks like when it’s done. Ignore the inconsistent icons and colour of slider because those  elements are captured from Office 2007.

Enhanced Default FullZoom Level with Visual Zoom 

There are two buttons beside the slider, which is Fit To Window and Reset icons. There are two new items in Popup, [Options] and [Hide Visual Zoom]. It is situated on top rather than on last item since it is the least frequently used items compare to the zoom selection.

So anyone know if there is any zoom extension that already offer this slider zoom ?  If not, this will make a very good excuse for me to learn XUL programming. In the meantime, let me see if other projects need important attention first …

And by the way, Default FullZoom Level is written by a Japanese http://space.geocities.yahoo.co.jp/gl/alice0775. Another good reason for me to visit Japan one day.