1. You just need to download the latest NbAndroid plugins from NbAndroid
2. The Goto Menu – Tools – Options,
   on Miscellaneus – Android,
   and set your android sdk there.
3. You are done.

Now you are ready to develop Android App from Netbeans IDE

Java Swing Future

It is still not very clear yet, how Java Swing will evolve in the future as said in the blog above

The crux of the problem is that Swing is rooted in the antiquated AWT, rather than being integrated into the 2D coordinate system. Fixing this would require some massively incompatible changes and once you march down that path, well, you start asking yourself what other incompatible improvements should be made ….pretty soon the remodel becomes reconstruction and you realize that a new foundation is really needed.

But don’t get me wrong, it is not whether Swing will vanish or not, of course everything will be evolved. But, the focus is on the evolution of Swing and it is still unclear how Swing will evolve in the future. As you can see from the things that I quote above, “Swing is rooted in the antiquated AWT… and fixing this would require some massively incompatible changes …remodel becomes reconstruction …”

However, the good news is that whatever decision Oracle made to Swing evolution, “it’s still there and it isn’t going anywhere” as Amy said.

Java FX Future

On the other hand, Java FX get the most focus and attention for Java client side and have much more clear roadmap. In contrast to Swing, Java FX has more modern underlying structure (Prism + scene-graph + UI controls) plus a hardware-accelerated graphics pipeline with a UI rooted in a 2D/3D scene-graph can do. Imagine what you can do as Java developer for either business application or RIA media frenzy application like you saw on iPhone, etc with hundreds of rotating media cubes or jumbling block. It will gonna be interesting.

And from what I can understand from Amy’s blog. Currently, Oracle is converting JavaFX to a proper Java library and killing JavaFX script. So Java developers don’t have to learn a new language to use it. And the good news is “… Much of the JavaFX stack has already been ported off of script, so this is all quite real and the team is ecstatic to be doing Java again..” said Amy

Development Environment/Tools (Netbeans)

“A sleeper detail from Thomas Kurian’s keynote is that NetBeans will be the Java development IDE of choice going forward. This is very good news for Swing, ensuring it’s support and upkeep for a long time to come.”

And on the JavaFX front “we are working closely with that team to ensure JavaFX2.0 is toolable from the start.”

Summary

So my summary are
- Swing evolution is uncertain yet, but Swing is here to stay.
- JavaFX script is dead, but soon there will be JavaFX as Java library.
- Netbeans will provide tooling support for JavaFX

Sources:

• A Heartfelt Ramble on Swing & JavaFX
• JavaFX 2.0 at JavaOne 2010
• JavaFX 2010-2011 Roadmap

The chapters structure is nice and follow the logical step and easy to follow:

• Chapter 1, Module: the basic building block of Netbeans Platform Application.
• Chapter 2, Forms: You learn how forms are created for usage on the NetBeans Platform, how their layout is set, and how to implement the related handling of events.
• Chapter 3, Window System: The NetBeans Window System, together with the API that it exposes, lets you arrange forms on the screen within a docking framework.
• Chapter 4, Lookup: The Lookup API provides a communication mechanism, comparable to an event bus, which is of central significance in the creation of NetBeans Platform applications.
• Chapter 5, Actions: You learn how to create actions and how to invoke them from menus and toolbars, including keyboard shortcut and context sensitive action.
• Chapter 6, Nodes and Explorer Views: A sophisticated MVC implementation for displaying business objects is made available via a set of extensible Swing components, which you can use without very much work at all.
• Chapter 7, File System: The File System API lets you access a NetBeans Platform’s virtual filesystem, which serves as the application’s central registry and configuration system.
• Chapter 8, Data System: The Datasystems API gives you access to the content of files. You learn how to extend a NetBeans Platform application to provide support for custom data types.
• Chapter 9, Dialogs: The responsibilities of dialogs in an application extend from the display of simple messages to the management of step-by-step procedural wizards.
• Chapter 10, Settings: which introduces you to the most important APIs and the entry points into the centralized Options window.
• Chapter 11, Help: HTML files constituting your documentation can be integrated into the application which can be invoked using action or keyboard shortcut
• Chapter 12, Branding: which enables the application’s ancillary details, such as icons and splash screens, to be customized.
• Chapter 13, Distribution and Updates: To let you distribute applications, and examine the various distribution mechanisms for NetBeans Platform applications including installer and online update.

Important, the book’s author write

“This book doesn’t aim to explicate all that the NetBeans Platform offers or to explore each and every corner of its many features. Rather, this book guides you through the development of a specific Java desktop application, while showing you everything that is relevant in the context of the particular application itself. That process, in turn, will lead you through the main features relevant to the development of most general
applications on the NetBeans Platform.”

For me, this book is really good to introduce Netbeans Platform development. It discuss all or most important API in Netbeans Platform from basic module creation to deployment and how to integrate them all together. Another good thing is this book using single application sample (Task Management Application) through out all the chapters. So each chapter add more features to the application sample, rather than each chapter using different example to describe the Netbeans Platform API. However, this book is not without flaw. Chapter 2 (Forms) discuss too much about Swing Layout and Netbeans Form Builder which is not necessary (IMHO, this book is not about Swing and Netbeans IDE, but about Netbeans Platform). Other than that, the book is good introduction to Netbeans Platform development.

I have been developing Netbeans Platform Application since few years and release (public release) at least 3 applications based on Netbeans Platform, so I know my way around Netbeans Platform API. But this book still give me few surprises regarding Netbeans API, and my favorite is the Lookup API (Chapter 4). And yes you can teach old dog new trick

Link To the Book

• Netbeans Platform 6.9 Developer’s Guide
• Book Errata
• Another Review of this book by Tushar Joshi

Additional Link related to Netbeans Platform

• NetBeans Platform Teaching Resources

Packt launch 5th annual Open Source Awards

Birmingham, UK. 9th August 2010

The 2010 Open Source Awards was launched today by Packt, inviting people to visit www.PacktPub.com and submit nominations for their favorite Open Source project. Now in its fifth year, the Award has been adapted from the established Open Source CMS Award with the wider aim of encouraging, supporting, recognizing and rewarding all Open Source projects.

WordPress won the 2009 Open Source Content Management System (CMS) Award in what was a very close contest with MODx and SilverStripe. While MODx was the first runner up, SilverStripe, a Most Promising CMS Award winner in 2008, made its way to the second runner up position in its first year in the Open Source CMS Award final.

The 2010 Award will feature a prize fund of $24,000 with several new categories introduced. While the Open Source CMS Award category will continue to recognize the best content management system, Packt is introducing categories for the Most Promising Open Source Project, Open Source E-Commerce Applications, Open Source JavaScript Libraries and Open Source Graphics Software. CMSes that won the Overall CMS Award in previous years will continue to compete against one another in the Hall of Fame CMS category.

These new categories will ensure that the Open Source Awards is the ultimate platform to recognise excellence within the community while supporting projects both new and old. “We believe that the adaption of the Award and the new categories will provide a new level of accessibility, with the Award recognizing a wider range of Open Source projects; both previous winners while at the same time, encouraging new projects” said Julian Copes, organizer of this year’s Awards.

Packt has opened up nominations for people to submit their favorite Open Source projects for each category at www.PacktPub.com/open-source-awards-home. The top five in each category will go through to the final, which begins in the last week of September. For more information on the categories, please visit Packt’s website www.PacktPub.com/blog/packt’s-2010-open-source-awards-announcement

http://blogs.msdn.com/ie/archive/2010/03/16/html5-hardware-accelerated-first-ie9-platform-preview-available-for-developers.aspx

This is great news for SVG designers or developers, because soon all major browsers will or already support SVG. Some already support SVG (Firefox, Google Chrome, Opera) and Microsoft Internet Explorer will follow the suit.

Step 1: Create ComponentOrientation support class

This step is optional, but make the testing easier, because it use the value component orientation from System.getProperty(“..”), and use auto (based on Locale.getDefault() if nothing specified.

    public class ComponentOrientationSupport {
 
        private ComponentOrientationSupport() {
            throw new Error("ComponentOrientationSupport is a utility class for static methods"); // NOI18N
        }   
 
        /** 
         * Return component orientation base on the value of
         * {@code System.getProperty("alkitab.orientation")} <br/>
         * If it is not specified it will return ComponentOrientation.LEFT_TO_RIGHT
         * Possible value are:
         * <code>
         * - auto (Default), automatic setting based on Locale.getDefault()
         * - ltr, force to use Left to Right orientation
         * - rtl, force to use Right to Left orientation
         * </code>
         * @return ComponentOrientation
         */
        public static ComponentOrientation getComponentOrientation() {
            ComponentOrientation orient = ComponentOrientation.getOrientation(Locale.getDefault());
 
            String str = System.getProperty("component.orientation");
 
            if (str != null) {
                if (str.equals("ltr")) {
                    orient = ComponentOrientation.LEFT_TO_RIGHT;
                } else if (str.equals("rtl")) {
                    orient = ComponentOrientation.RIGHT_TO_LEFT;
                }
            }
 
            return orient;
        }
 
        /** Apply the getComponentOrientation to the specified container
         * @param container Container
         */
        public static void applyComponentOrientation(Container container) {
            container.applyComponentOrientation(getComponentOrientation());
        }
    }

Step 2: Apply the component orientation for the MainWindow

In order to apply the component orientation to the MainWindow, you need to do that in the ModuleInstall eg:

    @Override
    public  void restored() {
        super.restored();
 
        // initialize the orientation
        String orientationKey = "component.orientation";
        String strOrientation = System.getProperty(orientationKey);
        if (strOrientation == null) {
            strOrientation = "auto";
        } else {
            strOrientation = strOrientation.trim().toLowerCase();
        }
        System.setProperty(orientationKey, strOrientation); // re-setting the System property to the correct value
 
        // do something else
        //....
 
        WindowManager.getDefault().invokeWhenUIReady(new Runnable() {
            public void run() {
                ComponentOrientationSupport.applyComponentOrientation(WindowManager.getDefault().getMainWindow());
 
                // do something else
                //....
            }
        });
    }

Step 3: Apply the component orientation for each TopComponent

You need to apply component orientation for each TopComponent you have eg:

    public final class MyTopComponent extends TopComponent {
        private MyTopComponent() {
            initComponents();
            setName(...);
            setToolTipText(...);
 
            // do something else
            //....
 
            ComponentOrientationSupport.applyComponentOrientation(this);
        }
    }

Step 4: Testing

Because it is using System.getProperty(“..”), so it is easy to test the UI. You only need to assign that component.orientation=auto|ltr|rtl to the environment. In Netbeans Platform based application you can do that in the suite project.properties by adding

run.args.extra=-J-Dcomponent.orientation=rtl ...your other things eg: -J-Xms64m -J-Xmx128m ...

Or for deploying you can use ../etc/yourapp.conf as above. Or if you are not setting it up, it will use “auto” by default which is based on Locale.getDefault()

There are a lot of them from various categories: Aerospace & Defence, Oil & Gas Services, Geospatial, Bio & Chemoinformatics, Scientific Modelers, Monitors, & Analyzers, Healthcare, Network Management & Communications Systems, Retail, Graphic Design & Image Manipulation, Music & Entertainment, Software Development.

So let’s me iterate again (or read this instead) why it is good idea to use RCP (Rich Client Platform) vs Java plus libraries. For me Rich Client Platform (RCP) is a set of libraries with tight integration, it was build from ground up to work together as a platform so other application can be build or run on top of it. In contrast, Java plus libraries is a mix and match of libraries to support the application eg: give new features, etc.

One main problem with the mix and match style is because that libraries may not be designed to work together, they could be excellent library on its own, but once they integrated together to form a single system (an application), sometimes it may require some glue or bridge code to make them work together. On the other hands for RCP, these set of libraries will work together since it is designed that way from beginning.

The module some.package.path is not a friend of some-path\some.jar

So what is friend dependency anyways. Friend Dependency is caused by a Module that have an API which its author is not yet comfortable exposing to just anyone, because it might not be fully stabilized yet. In this case, the module with the API can declare some public packages, but also stipulate that only a predefined list of “friend modules” are permitted to use them. The friend modules just declare a regular specification version dependency, but unknown modules are not permitted to use any packages from the API module.

So in order to declare a dependency to that module, you need to use an implementation dependency. Please read the following Netbeans Wiki Dev FAQ on how to declare this implementation dependency and to enable friend dependency.

note: please also understand that implementation dependencies cause special problems for Auto Update. It is explained on the Netbeans Wiki Dev FAQ as well

Because there is already review of this book by Alex Ruiz who focused on pro and cons, so in this review I will focus on the book’s content itself.

Swing Extreme Testing book is come with 311 pages. The chapters structure is nice and follow the logical step and easy to follow. This books use real life application as the example rather than using imaginative sample. The content is very interesting it start with the methodology (Extreme Testing) as the author called. What needs to be tested, who is to write the tests, when they are to be written, so on. Then go to management of test class and test data. And the testing of User Interface itself. This books also describe the technique to test JavaHelp, ResourceBundle Testing, Server and User Interface Testing, and Multiple JVM testings.

In this books, the author present Cyborg, a higher-level wrapper for java.awt.Robot class. This is the tool for user interface testing. The books also discuss some very important techniques for testing Swing applications. These techniques are: how to set up user interfaces in a thread-safe manner, how to find the objects representing particular components on the screen and how to interrogate a component for its state.

The book is closed with flaky test, tests that occasionally fail or do not terminate. As the authors says

“The problem with having flaky tests is that they remove the element of reproducibility from our testing process. If our tests pass, we don’t know whether all the bugs we’re testing against have actually been fixed, or whether they just happened not to manifest themselves in that testing run. If our tests fail, this could be due to either production errors or testing errors, or both. If we can’t be sure of our test results, we can’t be sure of our software.”

Finally, all the tests presented are automated test. This books also contains many tips and trick using real life application (what worked for them and what didn’t). Those tips and tricks itself worth the book.

Some note: I really surprised when book also describe the ResourceBundle and JavaHelp tests.

If you are wondering how do we track Java version, please visit this step by step guide on how to track java version using google analytics at
http://cowwoc.blogspot.com/2008/11/tracking-java-versions-using-google.html

Here is our Java visitor stats, it is fresh from Google Analytics data 05 December 2008 – 05 January 2009

and the corresponding Operating System (OS) stats

Based on the above, Java 1.6_xx seems to have very nice grounds, and the Java 1.5 (9.36%) seems come from Mac OSX (12.90%), not set is probably from visitor who disable javascript (noscript).

The only things that puzzle me is the Java 1.8.0 (6.59%). Where does it come from or is there really a Java 1.8.0 ? If you know where this 1.8.0 come from, please do not hesitate to drop me a note.