An excellent choice for beginning developersForté for Java 2.0, Community Edition

Sun Logo

Sun Microsystems' Forté for Java is a line of integrated development environments (IDEs) designed specifically for Java developers. It is based on the NetBeans Tools Platform, an open source, standards-based, modular IDE that was written in Java. The Forté for Java Community Edition is a productized version of NetBeans, and it is available for free. The Forté product line also includes two commercial implementations: the Internet Edition (currently available), and the Enterprise Edition (release pending as of this writing). Both of these editions are built on top of the Community Edition, and the basic interface experience is the same for all three.

Although Sun has contributed the source code from the Community Edition to the NetBeans Open Source project—and the company pays the salaries of many of the people involved in that project—Sun insists that NetBeans technology is evolving independently. Sun explains the relationship this way: "... NetBeans is to Sun what Mozilla is to Netscape/AOL."

Whatever its origins, that technology has been getting some serious attention lately from some serious people. James Gosling himself has described NetBeans as "... easily my favorite IDE." Late last year, Forté for Java won an Honorable Mention in Java Report's Writers' Choice Awards.

We called on software development consultant and author Mitch Goldstein to review the 2.0 release of the free Forté for Java Community Edition. Despite Mitch's general aversion to IDEs, he found many things about the product he liked, and some he didn't.

—John K. Waters
Product Review Editor

[email protected]

3 Cups Version Reviewed:
Forté for Java 2.0, Community Edition
Current Version: 2.0
5 Outstanding 4 Very Good
3 Acceptable 2 Has Potential 1 Poor

First, a disclaimer: I am not a big fan of IDEs, although I probably should be. I've made a great living as a consultant taking systems that were developed using these environments and reengineering generated source code into something reusable and maintainable. I do, however, recognize that IDEs are popular development tools, and that they have their place in the grand scheme of things. Lots of developers use them—I've used them myself—and so, despite my predisposition, I have looked at this product with what I believe is the requisite degree of objectivity.

Forté for Java is an IDE targeted at the Java development community. It is based on a freeware product called NetBeans, which has been forged into a respectable open-source platform for creating development tools. The NetBeans platform allows modification of most of the environment's capabilities, including the ability to create modules that support development in Java extensions as well as other programming languages.

When NetBeans first hit the scene, it was competing with other commercial IDE products that were developed as native applications. Because it was developed in Java, NetBeans suffered from traditional performance and scaling problems that became especially evident as the size of projects grew. Since its acquisition and renaming by Sun, the product has improved dramatically, likely due to significant advances in performance as the JDK matured.

The fundamental concept behind the NetBeans platform is an approach that relies on the abstraction of development environment features into a set of layered APIs. The core APIs provide extensibility of project behavior by exposing different capabilities as Java objects. These objects include an abstract view of projects, options, and components; representation of file and directory systems; and hierarchical viewing of project components and events.

The Forté Approach
Forté's user interface is rich and well organized. It provides a tremendous amount of information about project contents, allowing for a great deal of customization. Projects are organized in "filesystems" that are a platform-neutral representation of the project components. Information about source files and classes are organized in a hierarchical "explorer" that allows drill-down into the particulars of an object's structure. Forté also provides several workspaces for organizing development activity; these are organized onto a tabbed panel and allow for quick switching among source editing, GUI editing, browsing, execution, and debugging capabilities. However, I did find that switching among these tabs, especially in larger projects, caused flashing and repainting delays.

Figure 1
Figure 1. Forté explorer window.

Forté provides a combination of "templates" and palettes to provide access to the various components that can be added to a project. The configuration of all components is customizable and is advantageously stored in XML format. When a template is used to create a container in a project, the palettes can be used to select components for inclusion in the container. When containers and components are added to a project, their hierarchical information is also added to the explorer tree. Surprisingly, the component palettes do not support drag-and-drop.

By navigating the explorer tree, the various project components can be browsed by a "component inspector," which provides a localized view of a container's contents, or by a property browser that allows direct modification of properties. Properties of components are organized into different categories: commonly used, expert, event, and code generation. This allows modification of most of a class's properties without typing any source code. I was taken aback when I tried to set the "size" and "location" properties of the JFrame and JDialog containers I created. These properties must be manually set in the source code.

The Forté source editor is interesting; it provides some useful capabilities, but is lacking in some essentials. It does have syntax-coloring capability and allows definition of editing behavior based on source file type. This would allow a developer to create editing properties for any programming language. It has plug-in capabilities for key bindings and an externalized engine for "smart" indentation of source code. One thing I was not happy with is that there is only one source window available in the application, even though one can have many GUI editing windows open. In addition, the source window is not "splittable," so there is no way to look at two sources or two different sections of the same code simultaneously. There is also no macro facility, which I have found quite useful in practice.

The source editor does provide brace matching, auto-completion of method declarations, and a useful facility for creating "javadoc" comments in code. Even though auto-completion seems like a useful capability, I used the "global properties" to turn that facility off. When I did, the overall performance of the IDE improved significantly and I was no longer plagued by painting problems caused by the floating selection windows. I noticed several similar problems in other parts of the IDE, especially with items like "tooltips" and pop-up menus. These problems were annoying, but did not affect the usability of the program. They are a result, in my opinion, of issues with the maturity of the Swing component architecture, which is the basis of the IDE implementation.

Also missing from the source editor is the ability to examine source code for classes referenced in the code. Forté's competitors provide the capability of locating the source code for a class selected in the source editor. This is a feature I make extensive use of myself.

The key selling point of an IDE like Forté is the notion of rapid development. As with Forté's competitors, this notion shifts the focus of development from education and good design practices, to automation and code generation. Although the GUI builder approach to development does produce code more rapidly, it has some serious, long-term side effects that degrade the quality of developed code. For example, when the "template" mechanism is used to create application containers, the initialization code and child components are marked as "private." This makes the generated code effectively non-reusable. Since another feature of the source editor is to disallow modification of generated sections of code, the connection with the GUI editing capabilities must be broken to properly reorganize the source code.

Other conveniences, such as the ability to generate event-handling code by connecting components visually, insulate developers from the details of implementation, but create code that generally performs poorly and is very difficult to maintain. These issues lead one to the conclusion that these capabilities are best for a programmer who is learning how to develop Java code, and not actually developing in a real production environment.

The other important capability Forté provides is an integrated debugging environment. I found that Forté made a tremendous amount of information available during a debugging session, even though much of the displayed data appeared to be "leaking" from some of the IDE implementation classes. I also came to like Forté's JAR packaging utility, which was simple to use and well integrated.

Finally, as I continued to build projects, I began to notice that the performance of the IDE in general degraded quickly. As the number of source files in the project reached 50—which seems like a typical number of classes—the IDE became very difficult to use. With an increased number of classes, using the integrated debugging capabilities became laborious, sometimes taking several minutes to reach the entry point of the application. In addition, as the size of the project increased, the number of painting and pop-up errors also seemed to increase. To the credit of the Forté developers, the IDE did not crash, which seems to have become a traditional behavior for beleaguered Java development environments.

Another effect of having a large project in the Forté environment is that the explorer and other windows become quite cluttered with information. This is especially apparent in GUI containers that are deeply nested. The "component inspector" does allow isolation of portions of the containment hierarchy, which is necessary for examining components in deep hierarchies.

Room for Improvement
As a freeware product, Forté Community Edition is an excellent choice for beginning developers or as a tutorial environment. Although it has come a long way, there is still a lot of room for improvement, especially in the realm of performance. As a professional developer, I would almost rather see a significantly simpler environment that focused less on rapid development and more on helping developers create more organized and reusable code.

Vendor Info
Sun Microsystems Inc.
901 San Antonio Road
Palo Alto, CA 94303

Review in a Nutshell
  • Java 2 platform, version 1.3
  • Recommended RAM
    • 128 MB RAM minimum
    • 256 MB RAM on Microsoft Windows platforms
    • 512 MB RAM on Solaris environment, 3 GB swap space available
Operating System: Windows 2000 (5.00.2195)

Hardware: Pentium III 933 MHz, 256 MB RAM

Forté for Java, Community Edition: Free

Forté for Java, Internet Edition: 30-day trial, $495 for full license


  • Web download
    • Forté for Java, Community Edition: 7 MB–10 MB
    • Forté for Java, Internet Edition: 21 MB–26 MB
  • CD
  • Runs on any platform that supports JDK 1.3
  • Based on an extensible open-source platform (NetBeans)
  • Provides a metadata repository to allow integration of business data across enterprise platforms
  • Stores forms and properties in human-readable XML format
  • Editor is configurable and customizable, provides type-specific editing of text materials
  • Offers customizable toolbars and templates to allow integration of commonly used components
  • Good customizability of component palettes, menus, and keystroke bindings
  • Provides a rich set of property editing capabilities, and also takes advantage of JavaBeans and "input methods" capabilities
  • Allows importation of projects and source from other IDE platforms
  • Ability to enable and disable IDE extensions
  • Performance problems on larger projects
  • Generated code makes classes difficult to reuse developed classes without significant re-work
  • IDE becomes cluttered and difficult to read as project size increases
  • Switching among editing workspaces can be slow and awkward
  • Some inconsistent presentation of basic properties, overuse of property editors
  • Source editor window does not allow examining of multiple sources at once
  • Editor does not provide examination of source code for referenced classes
  • Painting and floating component problems
  • No macro facility for source-code editing
  • Lack of examples and tutorials