NetBeans 6.7


Finally it’s in the market: version 6.7 of NetBeans, the popular programming environment. The history of the latest release of NetBeans is quite eventful. After a change in the project’s management, far-reaching modifications regarding the release cycle were announced. The release number was pushed back from 7.0 to 6.7 and both the releases were said to follow one another closely. But as the personnel resources ran short, the schedule was not met. So, is the new release worth the wait? Does NetBeans live up to its credo, “The only IDE you need”? Let us look at these issues.

What’s new?

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

Projekt Kenai

In contrast to the community the software behind the
project Kenai ( 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 ( 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

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

net 3


Bug Tracking

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 (
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.

               Fig. 4

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


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.

net 5

       Fig. 5

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 in version 1.0 should
have done.

Apart from the main project a small revolution is taking shape
in the background. The project netigso (
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 (
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.

comments powered by Disqus