What strikes initially at the first call up on a Mac is the new Look-and-Feel, which is quite tidy compared to version 6.5. The layout has generally remained the same, apart from the category Versioning in the menu board which has been replaced by Team. This is the category where the most important changes can be found. The main focus of this version is teamwork. Three essential features have been added under “Connected Developer Tools”: integration with the Bug Trackers Bugzilla and Jira, support for the project platform Kenai and a plug-in for working with the Continuous-Integration-Server Hudson. Maven support has once more been improved and is now part of the standard distribution. The NetBeans Rich Client Platform has also experienced a number of improvements, although it is not the main focus of this release.
In contrast to the java.net community the software behind the
project Kenai (http://kenai.com) has
been developed by Sun themselves. Currently the project is in the
Beta phase, but it already supports many interesting features such
as project wikis, a chat function and provides support for
Mercurial, GIT and Subversion. The idea behind the project is to
transfer Web-2.0 features to the Open Source Community and develop
a modern variation of the classical Forge. Sun’s Cloud is also to
play an important role in that. The killer feature for projects
hosted there is the possibility to set up one’s own Hudson instance
as Continuous Integration Server for the project, as announced on
this year’s JavaOne. This is now complemented by the smooth
integration with NetBeans.
Those who are not interested in the Kenai project will hardly realize the integrated functionality. Apart from one entry in the sub menu of the new Team-menu nothing is visible at first sight. But as soon as one has logged in (Team | Menu | login), a new rider appears in the Explorer section (Figure 1). There one can download sources and open them as projects. So far, the wiki and the download page can only be opened in the browser. There is an integrated user interface for the Issue Trackers Bugzilla and JIRA. The Bugzilla support is included by default, JIRA support can be simply installed with a few clicks. As project owner one can set up a chat for one’s community. A client is implemented in the IDE. Project news is announced via Taskbar Icons.
Those, who want to generate their own project on Kenai, need an invitation of another project owner. After that everything is quite simple. One either starts from scratch and is guided through the process by the two page wizard (Team | Kenai | New Kenai Project...), or one simply uploads a local project (Figure 2).
One of the growing up problems of the plug-in is that the versioning system cannot be chosen in the latter case. Subversion is used per pre-adjustment, although Kenai, JIT and Mercurial are supported as well. In case of the Bug Tracker there is neither a possibility to choose, even though both JIRA and Bugzilla are supported by NetBeans and Kenai. Apart from that the integration seems to be fairly mature. As not every user will be interested in Kenai, it would have sufficed to provide the functionality via the plug-in center. Anyway, due to its decent integration the plug-in is at least not unpleasant in case it is not used.
The excellent Hudson plug-in will probably soon have a broad user group. The Hudson Continuous Integration Server ranks among the most popular projects on Java.net (hudson.dev.java.net). Due to its good user interface the project has found a loyal fan community, which is more than justified. The new plug-in even facilitates creating a build. One can easily download the latest Hudson release and test it oneself. The server is started via the command:
java -jar hudson.war.
After that the local instance has to be registered in the Services-Rider (Hudson | Add Hudson Instance...). To do so one only names the URL (http://localhost:8080/). Then one can upload any NetBeans project via the context menu of the registered instance. All configuration files are automatically taken over by Hudson. A build can also be simply started via the project’s context menu (Figure 3). The console version and the changes between two builds are displayed in the IDE itself. This works both with ANT-based and with Maven projects. The initial effort in introducing continuous integration into a project is thus almost nothing.
Innovations are also to be found in the section Bug Tracking. Compared to Eclipse with its Mylyn plug-in NetBeans had nothing comparable to offer for a long time. In version 6.7, support for JIRA and Bugzilla has been implemented (Figure 1). It is slightly difficult to understand, however, why nobody had thought of the Open Source project Cube°n (http://code.google.com/p/cubeon/) in connection with the Bug Tracking support. This project already provides excellent support for many Bug Trackers. Cube°n was even the winner of last year’s Developers’ Challenge and is thus a project sponsored by Sun. The plug-in offers a fully integrated, task-oriented user interface, a fully developed API/SPI and support for Trac, JIRA, Bugzilla and a local repository. Instead, a new plug-in has been developed which slightly lags behind the existing project as regards functionality. In general every improvement in this section is certainly to be appreciated. It would be welcome, however, if the NetBeans team better cooperated with the community in this respect.
On the surface the Editor experienced only a few changes. As a tribute to the Eclipse community the function Synchronize Editor with Views has been introduced. The automatic code completion has also been improved. It is possible to specifically influence the behavior in the new-designed options dialogue (Figure 4). Thus, one can, for instance, choose whether type-compatible arguments shall be inserted when a method call is made.
But the Editor has not only been improved on the surface. After the Lexer-API, the parser interface of NetBeans has now been standardized. The Schliemann project for simple declarative support of new languages has at the same time been staggered into the “Low Maintenance” mode. Some people might regret this decision, but in the long run it is surely better that we have now finally the answer to the question how to integrate a programming language into NetBeans.
One of the main attractions of the new release is without doubt the Maven integration. On this front essential improvements have again been made. At last, Maven support is part of the default distribution. “Compile On Save” has been supported in ANT-projects since version 6.5; this feature is now also available for Maven projects. As usual, NetBeans is able to identify Maven projects. No further meta data is needed. The cooperation with other IDEs in the team is thus uncomplicated. The Project-Object-Model-(POM) Editor now has hints and alerts, for instance when using RELEASE or LATEST as version number. In addition, the editing is facilitated by automatic code completion and code generator for plug-ins, dependencies and profiles (Figure 5). The automatic completion is even more practical when adding dependencies. Here all integrated repositories are automatically searched during the entry. In addition to these improvements new archetypes have also been integrated. Among many others there is now finally an archetype for generating NetBeans platform applications, which is simple to configure. Step by step the Maven support is gaining more and more importance in this section.
The Rich Client Platform
There are also many innovations for developers using NetBeans as Rich Client platform. Above all the window system has been improved. It is possible to maximize, minimize, close or relocate windows. This is done by setting Properties. The persistence of form data on the user interface between two sessions has also been facilitated via the @convertAsProperties-annotation and the methods readProperties and writeProperties. The data is written into a settings-file which also contains the other state data of the window in the session.
Many entries in the Registry file (Layer.xml) have also been rendered superfluous by annotations. With the @ServiceProvider-annotation a class can be exported as service. The possibility of importing projects and even whole module clusters is an immense improvement. Now it is easier to generate different distributions of a project and re-use modules of third parties. Until now this was only possible via manual adaptation of the build process. Dependency management has become more comfortable in other areas as well. When one adds a new module to the project, transitive dependencies can also be dissolved at the touch of a button, which was a time consuming process. In addition there are many small innovations, for example methods for simply reading files. With FileObject.asText(), there is now one API making the reading of a text so easy as java.io.File in version 1.0 should have done.
Apart from the main project a small revolution is taking shape in the background. The project netigso (http://wiki.netbeans.org/OSGiAndNetBeans) provides a variation of the IDE which even treats OSGi-bundles as fully adequate plug-ins. Thus, Distributed OSGi can be realized with NetBeans even now (http://eppleton.sharedhost.de/blog/?p=711). The project is still in an early stage, but the most important technical obstacles have already been overcome. Jaroslav Tulach, one of the founders of NetBeans and the main architect of the platform is behind the project.
Features on demand
One of the most important changes in this release is not to be found among the feature highlights of the website. Contrary to Eclipse NetBeans tries to provide a complete solution; it is, “The only IDE you need”. In reality, this has prompted almost all users to download the complete pack including all server-, language- and framework support. However, the startup time of the complete IDE clearly differs from the basic version. The number of the plug-ins installed has also considerable effects on the performance. In view of the growing functionality, this has become a serious problem. Here the changes regarding the infrastructure have put things right. If one downloads the programming environment, only the basic functionality is activated at first. Continuative features are only installed when they are used for the first time. In practice this results in an IDE that is clearly more exciting to work with. At the same time this is an investment for the future that hopefully will provide many new features in the time to come.
Generally, the new release makes a good impression. There are some quite positive innovations. The support for Maven is excellent now. The integration with Hudson is a nice additional feature, which makes it even easier to start with Continuous Integration. Despite contradicting announcements, the pack contains a number of long awaited improvements for RCT developers. The Kenai support might not be so relevant for all users to be part of the default distribution. For Kenai users the integration is certainly very practical. The integration with JIRA and Bugzilla is also a good idea. Here, cooperation with the Cube°n project should be a goal for the future. The infra-structural changes of the “Features on demand” constitute another improvement concerning the performance of the platform. Furthermore, the IDE is made more future-proof. One can only hope that this investment into the future of the IDE will pay off after the Oracle takeover and that the NetBeans project will receive the deserved support in the future.