We test the top 6 Java visual IDEs

The latest pack of Java tools delivers full JDK 1.1 support, raises the bar on performance and features

1 2 3 4 5 6 Page 3
Page 3 of 6

Although the current tools score badly in this area, we think open architecture is important enough to mention. When our reviewer chaired a panel at last year's Java Internet Business Expo on Java tools, the panelists and audience felt that this was the single most important feature that needed to be implemented.

Reviewers' pick

JavaWorld readers have expressed that they want us to name the best tool, our favorite choice. Doing so is difficult; indeed, all of these tools can get the job done. For our needs at this time, we prefer VisualAge for Java, because it lets us concentrate on creating the methods for doing the real "work" (like business rules), while the tool facilitates most of the GUI programming. We also like SuperCede because it has native compilation and RAD features (i.e., the ability to change running code, and fully integrated use of the debugger).

The best way to use this comprehensive assessment of the six major Java 1.1 visual IDEs is to create your own weighted criteria and consider the strengths and weaknesses of each tool, as well as the information in the Major features table. The issues you prioritize (performance, stability, help and documentation, GUI designer, ease of use, etc.) will greatly impact how you should interpret the provided information.

On to the tools

In the following six sections, we cover each tool in depth. We hope to provide you with enough data so that you can pick the best tool for your needs.

SUBHEAD_BREAK: Borland JBuilder 1.0 Professional http://www.borland.com/jbuilder

You don't have to visit Delphi (home of the Oracle) to know Borland's new baby needs a Turbo boost. While JBuilder boasts comprehensive breadth, its usability and help options don't equal Borland's earlier tools (Delphi, TurboC++, etc.).

Click image for expanded view

JBuilder's Interaction Wizard is useful only for

defining events to visual objects that have been

defined for the wizard. On the other hand, JBuilder

can generate very straightforward Java code, without

the usual confusing kludges that many builders put in.


Of the professional versions of Java tools, JBuilder includes the most complete database tools. Installing the complete tool takes about 170 megabytes of disk space, not including the Local Interbase and the Intrabuilder trial. In addition to the standard JDK 1.1 classes, JBuilder comes with JavaBeans of its own (JBCL), applets from Sun, the Java Generic Library (JGL), and beans from KL Group. Each library is filed under its own tabbed page on the palette; you can also add your own pages, and your own beans to any of the pages.

JBuilder is a two-way tool (like Visual Café); it can take source code that originated outside the tool and generate a visual representation -- most of the time. There are exceptions to this, and it would take a lot of use to understand them all.

JBuilder help consists of many separate "books" in a hypertext system. Each book is well indexed, and there is a master index, so you can search for something without having to know where it comes from. Some of the extra libraries included in the tool, such as the JBCL and the classes from KL Group, have extensive help documentation, including examples. The standard Java APIs and JGL do not have examples. In the earlier Borland tools, all APIs, including standard library functions, had excellent documentation with examples.

JBuilder's GUI designer (like that of VisualAge and Java WorkShop) lets you drag and drop objects to place them in a layout manager like GridBag layout, so you do not have to completely understand the complex layout constraints to use these layouts. It also (like VisualAge and Visual Café) lets you select multiple objects to perform operations upon, including copy, cut, and changing of properties.

JBuilder does have an API for its framework that lets vendors hook their tools into the JBuilder IDE.

JBuilder emphasizes creating database applications, so it concentrates on features for this purpose. The programmer's manual is almost entirely dedicated to database programming tasks, while the user's guide is involved in more general aspects of the tool. As you'll see in the section below, its database application focus leaves JBuilder somewhat lacking in some of the RAD and convenience features.


JBuilder runs slower than most tools -- basically along the lines of Java WorkShop. In some cases, you press a button and several seconds pass before something -- even a change in the cursor's appearance to let you know your button-press registered -- happens. On a 133-megahertz Pentium, we found JBuilder unbearably slow; on a 266-megahertz Pentium II, performance was adequate.

Although JBuilder doesn't have a visual way to create interactions, it does have an Interaction Wizard. There are several reasons why this isn't as convenient as VisualAge for Java:

  • The objects are not as easily selected. You select the involved objects from a list; the object selected visually when you start the wizard has no effect.
  • You can't use the Interaction Wizard to define an interaction with a non-graphical bean.
  • The wizard knows how to deal with only those beans it has been told about. (Most tools get all the information they need from the bean reflection interface.)
  • The wizard does not automate a lot of code generation for you. The amount of programming you'll need to do manually will depend on the controls themselves. The JBCL beans are designed to interface easily with each other, so defining certain interactions that would be complicated in the AWT is simple. For example, you can easily populate a multi-column list from the database because the database bean knows how to deliver the data in a format that the list understands.

In addition to its limitations, the Interaction Wizard also has a minor annoyance: You must run it from the main menu rather than from a right click on the object itself, and it doesn't even default to the currently selected object. Also, the wizard is an unmovable model dialog, so if you forget the name of one the objects you want to interact with, you might have to quit the process and start over in order to see the screen.

A customization tool lets you tell the wizard about beans that it does not know about. There are a few bugs and inconveniences in this tool. For one thing, this wizard doesn't list all beans in its pull-down menu, just AWT and JBCL beans that already exist in your source code. If you want to define the interaction with a bean that isn't listed, you'll need to type in the fully qualified name (such as java.awt.List). If you get to this customization screen from the wizard itself, you won't even have the option of typing in a name. Another problem is that (occasionally) once you type in the bean name, the window that is supposed to show you all the events is too small. You'll need to use the arrow key to go down and read the names one at a time as they are selected and shown. This seems to be an intermittent bug.

Many tools in this review do not let you draw simple shapes within the GUI builder. JBuilder does, but not in a free-form manner. JBuilder does not give you the standard canvas widget on the palette and allow you to draw on it. Instead, it provides a shape control for its own JavaBeans Control Library. You can set this shape control to be one of the standard shapes (circle, rectangle, rounded rectangle, vertical or horizontal line, etc.) and then control its size, color, and position. You cannot use this control to draw arbitrary shapes, or even to draw lines that are not at 45-degree slants.

SUBHEAD_BREAK: Cosmo Software Cosmo Code 2.5 http://cosmo.sgi.com/products/studio/code/

Cosmo Code is great for putting together quick little applets. If you need to do commercial development, Cosmo's lack of integration with other tools will hold you back. Cosmo Code was originally a product from Silicon Graphics Incorporated, but was spun out into a separate company called Cosmo Software.

Click image for expanded view

Cosmo Code presents most of its debug information

(breakpoints, data values, call stack, console

messages, etc.) in a tabbed dialog (bottom). This

makes it very efficient in its use of screen real

estate, allowing use on small monitors or low



One of Cosmo Code's more distinct features is its convenient ability to analyze your code. For example, you can find out which methods are used by another method, determine which methods read or modify a particular variable, or locate every occurrence of a variable, method, or class by name. For example, if you decide that you need to change the type of the total variable in one of the classes, and you want to see which methods are affected, you can enter total into the Search field, pull down Methods Modifying Members in the Using Query field, and press Find. In this case you would also search again using Methods Reading Members. It would be a touch more convenient to have another Using Query value for Methods Using Members, just as Cosmo Code has a Methods Using Methods query option.

In adding the component wiring feature, Cosmo Code has stepped up its support for visual programming. Like VisualAge, Cosmo Code has a component wiring feature that lets you createand edit interactions among all (visual and non-visual) components. Cosmo Code also can now select multiple items in the GUI designer, so you can copy, delete, or modify attributes on a group of objects. The only problem is that any attempt to mouse-select multiple objects by enclosing them just drags the background (the toplevel instance, or the current panel) so what you need to do is Select All, then use shift-clicks to de-select the background and any objects that you don't want to manipulate. Alternatively, you can select multiple objects by clicking on the first object, and then using shift-clicks to select each additional object.

Cosmo Code's GUI designer (like those for JBuilder, VisualAge, SuperCede and Visual Café) lets you select multiple objects and perform copy and cut operations.

Also, if you would like to do your development on a Silicon Graphics computer, Cosmo Code is available, although it is advertised as version 2.2 and we have not explored whether it has the same capabilities.


The sample projects provided with Cosmo Code are very weak, and do not at all explore the nature of this tool. Some are not even fully brought into the tool. For example, although the "impression" example compiles, Cosmo Code won't let you run it. When you try to open the "bounce" portfolio and bring up a visual representation, it fails. (The error message is Stage is not in CLASSPATH. Stage is a class used in the project, so you would think that it wouldn't need to be in the CLASSPATH.)

In looking for the cause of and solution to this problem, we found two other strengths of the tool: The convenient ability to set environment variables, and an extensive list of known problems and workarounds in the readme.txt file. Unfortunately, neither of these helped solve this particular problem.

Cosmo Code's GUI is somewhat non-intuitive and modal. For example, if you want to close the current portfolio (similar to a project), when you're working with a file or form, you won't find a Close option in the conventional location (under the File menu). Instead, you'll need to select the portfolio in the Project window, and then the file menu will give you the Close option.

Cosmo Code's online help is awful. It uses just the basic Sun documentation for the Java language and APIs. As a result, the APIs have no examples, and the "see also" links are very limited. It lacks method and class context-sensitive help, and many necessary Cosmo Code features are not documented. For example, while editing the properties of a JavaBean, you may come across focusTraversable, a True/False radio button, which may be grayed-out. When you press F1, it brings up help on the general filling out of a dialog -- nothing at all about focusTraversable or other properties, just general information, like how to use (click-on) a spinner, or a radio box. If you search help, you won't find anything about this bean property, nor anything about focus at all.

Similarly, although Cosmo Code offers serialization as an option when creating a new project, it is not mentioned anywhere else. There is no help on implementing serialization.

There is no way to search help other than the defined index, which does not contain Java APIs and Java language information. When you bring up these topics from the index, you'll have only a few limited hyperlinks to allow you to navigate, so you'll be doing a lot of scrolling.

Saving your code to the wrong name may mean losing the visual representation of your application forever. We haven't been able to get a file containing the GUI information to successfully import, and as Cosmo Code is not a two-way tool, an import of Java code loses all visual representation and still needs a lot of tweaking before it will work. You also cannot copy a GUI from one project to another, because of two issues: The GUI designer cannot select multiple objects, and when you do copy an object, it loses almost all information, including its position and size.

Cosmo Code's GUI designer (unlike JBuilder, VisualAge, and Visual Café) does not allow you to change properties of multiple objects.

SUBHEAD_BREAK: IBM VisualAge for Java Professional 1.0 http://www.software.ibm.com/ad/vajava

The tool with the most visual programming capability is well named. VisualAge for Java possesses major strengths and only minor handicaps.

1 2 3 4 5 6 Page 3
Page 3 of 6