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

As an IDC research analyst recently noted, 1997 was "the year of the [Java] tool." Indeed, in the June 1997 issue of JavaWorld, we offered the first comprehensive comparative review of the best JDK 1.0 tools (Asymetrix SuperCede 1.0, Microsoft Visual J++ 1.1, Sun Java WorkShop 1.0, Symantec Visual Café 1.0, and Visix Vibe). Since then, Java tools have matured, and now many provide full support of JDK 1.1 features. To help our readers evaluate this latest generation of visual integrated development environments (IDEs), JavaWorld in this issue compares the professional versions of the top six visual development tools for JDK 1.1:

  • Borland JBuilder 1.0 Professional
  • Cosmo Software Cosmo Code 2.5
  • IBM VisualAge for Java 1.0 Professional
  • Sun Java WorkShop 2.0
  • SuperCede Inc., SuperCede 2.0 Professional
  • Symantec Visual Café 2.1

Note that three of these six tools -- Borland JBuilder, IBM VisualAge for Java, and Cosmo Code -- are new (or were not released in time to be included in our last comparative review). The other three tools have been upgraded since our last review to include JDK 1.1 support and various enhancements.

The evolution of Java visual IDEs over the past nine months has been astounding. Last year, most Java tools wouldn't stand up against the capabilities of even the early versions of Borland C++. Fortunately, this new group of tools is powerful and friendly.

Review criteria

In this review, JavaWorld looked at the major Java JDK 1.1 tools that tout a visual integrated development environment. A great many Java tools have been released or improved in the past few months. We can't review every one of these, but we try to describe them all (as well as all sorts of other Java developer products) in JavaWorld's comprehensive Developer Tools Guide. (If the Tools Guide is missing your favorite tool, let us know.)

The reviewed tools are quite powerful now, and many are relatively inexpensive and/or provide free trial versions, so there are plenty of alternatives if you don't have much money to spend on tools. For example:

  • Parts for Java from ObjectShare has a free 30 day trial
  • The beta version of SNiFF+J Professional is available for free download from TakeFive Software
  • Super Mojo from Penumbra Software is available for an introductory price of 9.95

(See the Resources section for URLs.)

On one hand, only recently have some tools become JDK 1.1-savvy. On the other hand, the list of visual Java development environments is a long one; choosing the top candidates for this review was no easy task. Based on input from JavaWorld reader surveys, data from research companies, and the experience of the reviewer, we established a set of criteria. To be chosen for inclusion in this review, a given tool had to:

  • Be fully released (not in beta)
  • Provide support for visual programming, at least to the point of placing objects without programming
  • Provide good support for JDK 1.1, including the ability to create and consume beans
  • Claim a substantial marketshare among similar Java tools
  • Offer a "professional" edition or equivalent. (Products that are marketed primarily as "enterprise," "database," or "multi-tier" development environments, such as Sybase PowerJ Enterprise, inherently warrant a broader set of evaluation criteria, and thus were not compared to the professional tools in this review)

Of these criteria, the most difficult one to quantify is "substantial marketshare." What makes this so difficult is that beyond the top three leaders (VisualJ++, Café and Java WorkShop) the market analysts' opinions greatly differ. Using a variety of sources including JavaWorld's own reader surveys, we had to make our best guess.

Who didn't make the cut

We excluded Microsoft Visual J++ from this review because its new version (renumbered 6.0 to be in sync with the version numbers of other Microsoft development tools, such as Visual C++) wasn't yet released. (Just before our publication deadline, Microsoft did release a version 6.0 beta. But even if the post-beta release was currently shipping, it may not have met the criteria for this particular review.) For more information on Visual J++ 6.0, see "Microsoft takes wraps off Visual J++ 6.0: Software giant creates thicker ties between Java and Windows with WFCs" in this issue of JavaWorld. (And be sure to check out the extensive collection of hand-picked resources accompanying the VJ++ article!)

The current shipping version (1.1) of Visual J++ is not reviewed here because it hasn't changed substantially since we reviewed it last June. (Since then, Microsoft has added its Software Development Kit (SDK) for Java 2.0, which provides most JDK 1.1 support, but Visual J++ 1.1 doesn't fully support beans, and its resource editor supports only a subset of visual objects.)

We did not look at Visix Vibe this time because the JDK 1.1 version wasn't ready yet. Visix also is working on a JDK 1.2 version. Visix still will offer VFC, as these provide cross-platform support, high functionality and high performance (because the VFC are compiled to native code).

We excluded Metrowerks Code Warrior Professional because its support of the visual metaphor and JDK 1.1 is very weak. Its visual tool (Constructor) is not fully integrated in the IDE; it cannot generate all of the code to instantiate controls on the screen; and it does not have tools for bean creation.

Enterprise-level tools, which are made for multi-tier development, require a whole different set of criteria. If evaluating an enterprise-level tool, we would look at its support for working with databases, performing RMI (remote method invocation), and accessing legacy systems. We'd also expect tools of this level to have floating licenses and offer training and help-line support. For this reason, the enterprise version of tools and enterprise-specific tools like Sybase PowerJ are not reviewed. We hope to compare enterprise tools in a future review.

Testbed systems

Each tool was tried on two different machines, a Pentium II 266-megahertz PC (with 64 megabytes of RAM, a 5.2-gigabyte disk drive, and 20-inch monitor) and a Pentium 133-megahertz PC (with 32 megabytes of RAM, a 4.3-gigabyte disk, and a 17-inch monitor), each running Windows 95 OSR2 (OS Release 2). We created projects under each tool and evaluated them against a list of major criteria including the features which enabled us to rapidly create projects and create and reuse beans.

To minimize the possibility of mistakes, we did our best to verify our findings with the vendors.

How to navigate this review

We've organized this review into two main areas:

  • The General overview/summary section provides a good abridged description and evaluation of the reviewed products and their features. Here you'll find our comprehensive Major features table, as well as discussions of key concepts such as the visual programming paradigm, native compilation, and integration of manual programming.

  • The remaining six sections are product-specific, and extensively detail the strengths and weaknesses of each visual tool.

  • We also provide a comprehensive Resources section containing select links to related documents.

SUBHEAD_BREAK: General overview/summary

Java tools have grown a lot since we last reviewed them. So much so that many tools reviewed last June do not even meet the criteria today.

There are two main tasks in object-oriented programming: defining your classes and instantiating them -- or, in Java vernacular, JavaBean creation and consumption. All the tools reviewed here are adept at both creation and consumption of beans. In addition, each tool lets developers visually create and place visual objects, such as AWT classes, to create their user interface forms.

General information about the tools

General Information Price/AvailabilityBorland JBuilder 1.0 ProfessionalIBM VisualAge for Java 1.0 Pro


Software Cosmo Code 2.5

Sun Java WorkShop 2.0SuperCede Inc. SuperCede 2.0 ProfessionalSymantec Visual Café Pro Dev Edition 2.1

Free trial

version available

Tutorial versionEntry-level limited to 100 classes, virtually no help or online docsYesYesYesYes
Platforms supported for developmentWin95/NTWin95/NT, OS/2Win95/NT, SGI

Solaris (both),

Win95/NT, HP-UX




Suggested price (Street price)99 (48)9 (1)29 (25)9.95 (same)95 (15)99 (75)

As we said earlier, many Java tools have been slow to adopt the friendly productivity features that Borland Turbo tools have had for years. These include rapid development features and great API-level help. At least as far back as 1992, for example, in Borland C++ you could place your cursor on a function name in your code, press a key, and get help on that particular function. You could then look at example code (which included any additional functions that might be necessary), and if you so desired, copy it into your code. This level of context-sensitive help with examples exists only in JBuilder, and even then only on the class libraries that Borland added.

Tools for Java, however, have some new things to worry about -- like layout managers. Much of this review concentrates on these language-specific items. For example, Java layout managers look at certain properties of the objects to determine how to place them. These properties are called layout constraints. GUI designers, when placing objects, should understand what object layout constraints make sense based on a given type of layout. Some tools (that were not included in this review) are so crude that they don't recognize the meaning of these properties. They allow you to put in only property names and values. It is up to you to look up which properties to use, and manually type them in with their values without the benefit of interactive error checking.

Disk space is not really an issue worth comparing on these products; they all take 50 to 60 megabytes for a typical install; Borland JBuilder can use up to 170 megabytes with all its goodies installed.

When using these tools, we recommend that you have at least 48 megabytes of RAM, and a screen capable of at least 1024x768 resolution. If you have a low-resolution screen, you'll be shifting windows constantly to uncover what you need. If you must use a lower resolution, SuperCede and Cosmo Code may best serve your navigational needs, thanks to their small floating palettes and tabbed dialogs.

All of the tools in this review are now form-based, which means that the GUI designer is fully integrated into the development process. This was not the case in last year's review, when Visual J++ used a separate resource editor for the GUI, and then you worked with files in the visual studio. All of the tools now support sub-projects, at least in the form of packages.

Major features

Requirements for a Java tool differ among individual developers. The items we've listed in the Major features table have been important -- even critical -- to some of your peers, but you need to decide how much they matter for your needs. In this section, we describe the major features and why they might matter to you.

What is a visual IDE?

To appear in this review, each tool had to support the basic visual creation of user interfaces -- that is, provide the ability to select a visual component from a palette and place it on your user interface. Some people refer to such tool as visual development environments (VDEs). The tool used to visually design the interface is known by various names, including designer, form designer, visual composition editor, visual editor, screen painter, screen editor, form painter, and GUI designer. In this article, we refer to them as GUI designers.

Developers need to place the components, and to modify their appearance, other attributes, and events. Ideally, visual IDEs let you quickly drag and drop components, and easily change the things that frequently need changing. If you have to wait a lot, this process can drain a substantial amount of time on a complex interface.

Many tools use the drag-and-drop paradigm, while others have you click on the component, then click on the destination. The amount of effort is almost the same for both, but most people prefer drag and drop. SuperCede and Cosmo Code use drag and drop; the rest use click and click, though Visual Café supports both methods for most purposes. VisualAge lets you set a "sticky" option so that once a component is picked you can keep placing instances by clicking in each destination.

How often your applications will use layout managers has an impact on your tool decision. With all tools except Java WorkShop's, all placement can be done free-form (with no layout manager). Only JBuilder, VisualAge, and Java Workshop let you visually place and move objects within a layout manager, so a lot of the complexity of working with the layout manager is hidden.

With Cosmo Code, SuperCede, and Visual Café, you need to understand the meaning of these properties so you can appropriately set the constraints, since this is the only way you can place and size objects correctly in a layout manager. But of course, if you want to freely place objects you can simply change the layout to "none."

JBuilder, VisualAge, Cosmo Code, SuperCede, and Visual Café all allow you to select multiple objects to copy or cut. Only JBuilder, VisualAge, and Visual Café let you change properties on multiple objects. Although VisualAge does not let you change layout constraints on multiple objects in this manner, it does have a number of tools to help you layout and resize multiple objects.

The visual programming paradigm

Full-fledged visual programming can involve more than what most Visual IDEs offer. Beyond the fundamental capability to visually place objects, the tools we've reviewed vary greatly in their visual programming features. To help you appreciate these distinctions -- and decide how important such distinctions are to you -- let's review what visual programming means.

Next Computer, in its NextStep development tools, helped popularize a key tenet of visual programming: the idea that a good deal of programming tasks can be made simpler by doing them graphically. Visual programming deals effectively with not only the placement of visual components, but the connections between them, as well as the connections between non-visual components.

Because there isn't a way to effectively express all programming idioms, many tools choose not to support much of this aspect of visual programming. JBuilder, SuperCede, and Java WorkShop do not allow much visual programming, although Java Studio (Sun's Java app builder for non-programmers) does. Sun plans to include and more tightly integrate Visual Studio with the next release of Java WorkShop. This should result in a powerful tool for both experienced programmers and non-programmers.

Cosmo Code, Visual Café, and VisualAge for Java all support visual programming at various levels. Also, Sun's Java Studio provides some visual programming capabilities that can work with beans. Although Java Studio was not included in the last JavaWorld comparative review of integrated development environments, it was described and reviewed in separate JavaWorld articles. (For details about Java Studio, see Resources below.) Java Studio 1.0 is a noble first attempt to enable visual programming, but it currently is a separate tool from Java WorkShop and it's rather limited compared to IBM's support for visual programming. This is because Studio uses specially defined connections of a bean, whereas IBM supports all interfaces of each bean.

Raising the "bar" of visual programming

Cosmo Code, VisualAge for Java, and Visual Café (and Java Studio -- but not Java WorkShop itself) also are unique among reviewed tools in that they can define interactions with non-visual components. The best visual programming tools set themselves apart from the others in terms of flexibility. This includes the tools' ability to edit interactions that already exist, use data from more than one object to go into another object, and deal with complex data*. For example, with any of these four tools that can define interactions with non-visual components, you can make a button-push cause a value from a text field to go into a list field. But only VisualAge for Java lets you graphically use the list value as a parameter to a (non-graphical) bean's method, to come back with values with which to populate the list field.

You need to decide how important visual wiring and interaction are for you. For the most part, these features are useful only when you need to call one method on a particular class. They don't help much, for example, when you want to have many buttons call the same method, or when you want an action on one object to take data from another object and act upon a third object. Even for these more complex interactions, however, the visual-programming capability does give you a head start, providing code that you can manually tweak.

Native compilation

Applications written in Java (or other languages) can be fully compiled (to native code) to improve performance, feature richness, quality, and security. We saw this trend happen with Visual Basic, and after years of delay it's finally starting to happen with Perl.

Applications should be compiled when they:

  • Require higher performance than the Java VM and JITs can deliver. Full Java compilers, such as those offered by Symantec and SuperCede, typically provide performance levels not possible with interpreters or JITs. (The other four tools reviewed lack native compilers.)

  • Contain proprietary content, and therefore need better protection from reverse engineering. Java is easy to decompile to source. Products that obfuscate code do not fully protect against such decompilation, and using obfuscators has a variety of drawbacks. These drawbacks include the extra step you must go through in your production process, the effort you must go through to verify that your obfuscator doesn't do any harm, and the fact that debuggers won't work properly on production code which has been obfuscated.

  • Would not benefit from, and might even cause harm to, the "compile once, run everywhere" model. This includes critical software, such as financial applications, machine control functions, wireless communications, and security software, that must be tested before being allowed to run on unknown platforms. Distributing software as bytecodes indicates your code is caveat emptor code -- "It should run on your platform, but I haven't verified it." Designers of every program needs to ask themselves, Do I want this code running on a platform that is substantially different than any it has been tested on? and Do I trust that the program will behave properly, even if the JDK or third-party class libraries are updated? If you answer no to either question, you may wish to consider native-compiled versions for each platform as one way to ensure your code won't be run where it shouldn't.

  • Must operate in severe target memory constraints. The full JDK 1.1 class libraries weigh in at more than 10 megabytes, not including the underlying support from the OS (another 1 to 10 megabytes) or the browser (which typically may require 8 or more megabytes of RAM when running on a standard desktop computer). Sun indicates that the PersonalJava class libraries will be only 2 megabytes, but many applications will not run because, as a subset of Java, PersonalJava will lack some libraries. In addition to PersonalJava, applications may be written for Java Card, EmbeddedJava, or the full JDK. The only way to ensure that bytecode applications will run is to have support for the full JDK. Compiled applications can include the needed libraries, or you can use the Symantec runtime library for compiled Java, which is only about 2.5 megabytes and supports all JDK 1.1 classes and methods.

Symantec has managed to make the binary version of the class libraries much smaller than the normal JDK. Instead of needing a 9-megabyte classes.zip file, a compiled Java application needs only those dynamic load libraries (DLLs) that actually are used in the application. (The JDK's full set of DLLs accounts for about 4 of its 9 megabytes.)

In the June review, we pointed out SuperCede's ability to compile Java to a native executable. Since then, Visual Café has added this feature. Cosmo Code has some compilation ability with its Java to MIPS translator. Others vendors are considering native compilation for future releases of their products.

Major features

Major featuresBorland JBuilder 1.0IBM VisualAge for Java 1.0 ProCosmo Software Cosmo Code 2.5 ProfessionalSun Java WorkShop 2.0SuperCede Inc. SuperCede 2.0 ProfessionalSymantec Visual Café Pro Dev Edition 2.1
CM, test, and profiling toolsNoNo (Enterprise edition has CM)NoCM interface, built-in profiler and basic test frameworkIntegrates with Versions 2.0 and VTuneTesting, CM, VTune
Visual programming (interactions)No. Does have non-graphical Interaction Wizard.Best: Can visually create/edit interactions between all components. Can selectively show interactions.Better: Can visually create/edit interactions between all components.No. Studio product has limited visual interaction, even with non-visual components.No.Good: Can visually create (but not edit or visually show) interactions between all components.
Printed documentationGood. Programmer's Guide includes tutorials (210+ pages), task-oriented User's Guide (220+ pages)Good. User's Guide (200+ pages), Programmers' Guide (190+ pages)Inadequate. Getting Started booklet (17 pages)Light, tutorial-level: Exploring Java WorkShop (108 pages)Comprehensive User's Guide (275 pages) and a tutorial-oriented First Look (70 pages)Extensive, task-oriented (400+ pages) User's Guide, Getting Started (200+ pages) and Visual Page (140+ pages) docs also well done.
Database supportYesOnly in EnterpriseYesLimited, more in EnterpriseData aware controls for any JDBC sourceLimited, more in Enterprise
Online documentationVery good on Borland's added classes, but not context-sensitiveNot context sensitive. Basic help & MindQ tutorialsVery basicYes, but slowBasic help & MindQ tutorialsBasic
HTML Page generationYesYesYesYesYesYes, also includes Visual Page
Reverse engineeringYesNoNoNoNoYes
Ability to add your own objects to PaletteYesYesYesYesYes, beans or ActiveXYes
ActiveX supportedNoIn Web-Runner productNoNoYesNo
Additional Java class libsTop 100 beansNot included, but listed on WebRogue Wave JWidgets, JTools, JDBTools and JChartYesKL Group BWT, Shafir JCT, Stingray Objective Grid and Objective BlendYes
JDBC supportYesYesYesYesYesYes
Native methodsJNIJNIJNIJNIJNI, direct calling, C/C++ in sourceJNI

Tools that go both ways?

Each of these tools can generate code from the visual representation. At a minimum, this includes all the code required to place the object on the screen. For the purposes of this article, reverse engineering is the ability to go from a programmatic representation to a visual one. Of the tools reviewed, only Visual Café and JBuilder have this ability, and neither can handle all legal Java code.

Reverse engineering can be important for two reasons: better integration of manual programming, and importing Java projects. Let's cover those in more detail so that you can decide how important this feature is for you.

Integration of manual programming

There are bound to be some limits in the graphical programming paradigm. It might be a lack of support for all objects or methods, as was the case in Microsoft's Visual J++ 1.1 in our June 1997 review. Or, it may that you want your application to dynamically generate the screen, such as a graphics program, or generate database forms and reports on the fly.

In any case, there is a recognized need to go in and write code. Each tool provides some way for you to do manual programming without interfering with the code that it generates. Most tools have well-marked areas of code that the user must not edit. In addition to the designated sections that are OK to edit, you are completely free to edit any file that you add.

IBM VisualAge for Java has two positive aspects in this regard. First, it helps you build non-graphical code with its bean "maker" (basically a wizard). These beans then can be integrated and used in the visual programming paradigm. Second, most code that is off limits is relegated to separate files. The only small glitch is that VisualAge creates some files with headers stating that you cannot modify them, when in fact you can -- and often must -- do so.

Note also that although JBuilder and Visual Café allow reverse engineering, they cannot handle all manual changes successfully. JBuilder and Visual Café are most useful only when you create the code within the respective vendor's tool, or manually write the code using the respective tool's particular conventions. For example, neither tool can handle using a variable as a parameter to setColumns(). If there are problems in parsing the code, neither tool is especially helpful in describing what you did that the tool didn't like: Visual Café's messages are not always meaningful, and JBuilder provides no messages at all. On Visual Café the visual representation isn't updated until you fix the code. On JBuilder, it may be updated incorrectly.

Importing Java projects

You probably have code that needs to be imported into your Java tool. This could be code you started creating with other tools, code you pulled off of the Internet, or code from a project that you inherited. Any true Java IDE must have an easy way to add files to your project. In most cases, these files will have to remain as part of the program that you can edit only manually; you can't visually maintain such pre-existing Java code.

What is an "open architecture"?

Each of these IDE tools is a framework from which developers design, test, debug, and deploy their code. In order to make this process effective, each of these tools (designer, debugger, etc.) in the framework needs to be good. A weak tool is a weak link in the chain.

If the framework doesn't include the very best of tools for all steps in the process, it can still be a good framework -- as long as it allows you to use your own alternative tools. Borland C++ has offered an open architecture since at least 1992. This makes it easy to plug in your own tools for translating files, such as code or test generators. Of the tools in this review, none are completely open architectures. Borland and IBM, however, both offer APIs to partners who wish to create add-in tools, and the other IDEs can probably make similar arrangements.

You could use an outside tool even with an IDE that doesn't have an open architecture, but it would be inconvenient. For example, to use an outside editor, you would need to close the editor within the IDE, start your alternative editor, and then navigate to and open the file. Then, when you finished your edits, you might need to reload the file into the IDE of the framework in order to set breakpoints, compile, and run. VisualAge for Java, further complicates matters because it stores the source in a database rather than in standard files -- which means you must export the files from the database, run your tools, and then import the files back into the database.

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.

Click image for expanded view

VisualAge has the best support for visual programming.

It allows you to interact with non-visual objects (see

arrows pointing up on right side of screen), and more

than one object. In this example, a change in any input

field calls a method that we defined on the applet. Notice

the DOS application running in the task bar; this is the

help server that must be running to use VisualAge's help.


Although new to Java development, VisualAge for Java is clearly a mature tool with features that both IT developers and part-time Java programmers can appreciate. It possesses several key features: support for connection to legacy mainframe applications with CICS, extensive support for visual programming, convenient bean creation, decent rapid application development (RAD) support, and worry-free ("fileless") file-handling.

With some IDEs, if you make changes and save a generated file to the wrong name, you may never get the file into the project. With most IDEs there is also the danger of picking a file name or directory that will conflict with the way the tool works. But VisualAge for Java doesn't store your source files in individual files; it stores them in a database. If you need to get to the files, you can export them. This does make it a bit less convenient to work with outside tools like configuration management software, but many developers will consider the trade-off worthwhile.

VisualAge for Java provides the most support for visual programming. IBM allows you to define interactions visually with all JavaBeans, even non-visual beans. VisualAge, like Cosmo Code, allows you to edit existing interactions, but it has several more features. For one thing, interactions can be more complex: VisualAge can combine data from more than one object, and go to more than one object. Also, because there can be a lot of interactions, the screen can get rather complex with all the lines on the screen representing these interactions. VisualAge for Java distinguishes itself again in this arena with its ability to show only certain kinds of connections by applying several filters. Most other Java tools allow you to show only all connections or none.

Because there can be a lot of interactions, the screen can get rather complex with all the lines on the screen representing these interactions. VisualAge for Java distinguishes itself again in this arena with its ability to show only certain kinds of connections by applying several filters. Most other Java tools allow you to show only all connections or none.

VisualAge's GUI designer (like those of JBuilder 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 JBuilder and Visual Café) lets you select multiple objects upon which to perform operations, including copy, cut, and changing of properties.

One unique feature of VisualAge's GUI designer is that it allows you to set a "sticky" option so that you can repeatedly place the same kind of object. Another unique feature of this editor is that it allows you to change the type of a bean after it is placed. Like all visual products, VisualAge has a property editor. This one has a mode to show or hide "expert" properties, although this usually adds only such banal fields as "enabled" (which turns a control on or off).

Creating JNI interface to C++ functions is facilitated by a wizard called the C++ Access Builder. The enterprise version of VisualAge for Java offers wizards to create beans to access databases, perform remote method invocation (RMI), and interface with IBM's CICS (Customer Information Control System, pronounced "kicks").


The downside of VisualAge's fileless approach is that it makes it difficult to integrate with outside tools. This can be a minor annoyance if you don't like the editor or other tools of VisualAge, but it's a major problem if you need profilers, testing tools, or multi-user configuration management. You can still use external tools, of course, but you will have to export files from the framework, and then import them if the external tool makes any changes. IBM is going to publish its framework APIs to open up the IDE through IBM's Object Connection program. Vendors of tools that want to work with VisualAge for Java can find out more by going to the tool's Web page (http://www.software.ibm.com/ad/vajava) and clicking on Business Partners.

VisualAge for Java is not compliant with JDK 1.1 in one sense: It does not support inner classes. This means that you cannot define a class within the scope of another class. You can work around this problem by defining all classes at the package level, or by importing bytecodes. This problem will be fixed in version 2.0, scheduled for release this summer. Registered customers of VisualAge for Java Enterprise 1.0 and 1.01 will receive a version 2.0 update automatically.

For developers doing commercial development, the single-user repository capability of VisualAge for Java may be insufficient for managing your configurations. The professional edition cannot do multi-user configuration management (CM). Also, a good CM tool needs to do more than versioning of individual files, it needs to remember which version of each file and build option is used to create a particular release. IBM's own Team Connection is a good example. Because of VisualAge's fileless nature, it is difficult to work with configuration management tools. If you need multi-user CM, you must get the enterprise version of VisualAge, which now includes team-oriented configuration management.

The entry-level version of VisualAge is available for free download. It is supposed to be the same as the professional version, but limited to the creation of 100 beans. In reality, the entry-level version is also missing all help documentation. What is available in this version is "hover help," which is IBM's version of what Microsoft calls "tool tips," and some documentation on PDF files that is without a table of contents, searchable content, thumbnails, or hyperlinks. How bad is this? Imagine having to look things up in a book that required you to search one sequential page at a time! Our advice is, if you are past the evaluation stage, just buy the professional edition. A hundred bucks is cheap for this tool and its documentation.

Like most tools (except Visual Café), VisualAge's debugger will work only in its own VM, so you cannot use it to find problems that happen only in the application's user environment. (For example, a problem may occur only when an app is running inside a particular version of a particular browser on a particular operating system and CPU.) Also, remote debugging is supported only when the target is an IBM Java VM on an AS/400.

IBM's help is not context sensitive, even to the point that it doesn't know what part of the tool you are using. In order to access help, you must be running a help server.

SUBHEAD_BREAK: Sun Java WorkShop 2.0 http://www.sun.com/software/Developer-products/java

Java WorkShop 2.0 is a huge improvement over version 1.0, providing better performance, usability, and features. The tool still has a long way to go in order to be competitive, however, and the other Java tools prove to be rapidly moving targets.

Click image for expanded view

Java WorkShop's GUI designer does not operate in an

intuitive manner, but once you get used to it you'll

find it quick for building the layout. WorkShop hides

the complexity of layout managers better than most

visual tools, but there isn't any connection or

interaction wizard. Not only does Java WorkShop provide

no assistance for writing events, it complicates the

process by the use of groups and "shadow" classes.


Java WorkShop was the first of these six reviewed tools to support JDK 1.1, and WorkShop has continued to include the latest release of the JDK and JFC. (Not surprising, considering both WorkShop and Java itself come from Sun Microsystems.)

Java WorkShop integrates with SCCS, RCS, and PVCS configuration management (CM) tools. It also comes with a profiling tool built-in, although its tool does not provide the specific advice offered by VTune, Intel Corp.'s performance monitoring and tuning tool.

Java WorkShop includes a multimedia tutorial to teach you how to use the product, and (like most tools we reviewed) a project wizard to help begin projects .

Once you are accustomed to it, Java WorkShop's GUI designer may be the fastest in creating the GUI of your product, especially if you are going to be using a layout manager. With the tool you will not need to understand layout constraints in order to deal with complex layouts like GridBag. You can move the objects simply by dragging, and you can make them span grid cells simply by dragging their handles.

Java WorkShop is the only tool that we reviewed that is available for Solaris (for SPARC as well as Intel computers), Hewlett-Packard Co.'s HP-UX, and SCO Unix.

Sun also now offers a separate tool called Java Studio for creating applications without programming. Java Studio uses the visual programming paradigm to allow you to create applications, applets, or beans, by using existing beans and connecting them. You can use Java WorkShop to create interesting beans, then export them to Java Studio. This review article concentrates on Java WorkShop, but where noted, comments in this article also apply to Java Studio. At this time, Sun offers a discount if you purchase both tools together. (For details about Java Studio, see Resources below.)


Java WorkShop is written in Java, but it is not a good example of portability. When tested on Windows, many portability issues surface that were left unresolved, despite both the use of the Java language and the presumed skill of the tool's creators. These problems make the tool less convenient than it should be. Problems included truncated prompts, inappropriate default locations for projects, and non-standard (even self-inconsistent) adherence to key conventions. Reading user documentation that includes instructions for all platforms is not much fun. It is a lot like multilingual instructions, but here it's even harder to know what you can skip.

Selecting an object in the GUI designer of Java WorkShop is difficult: You have to move the cursor over the object, watching for when the cursor changes. Only then are you on a handle. WorkShop's GUI designer also isn't compliant with Windows style. (Java Studio has this problem too, and non-programmers might be even more frustrated.) When you start to create a GUI, Java WorkShop creates a panel with a GridBag layout. Inserting rows or columns is not done with the insert key, or a right-click pulldown menu, or any other menu, or any other place that you might have guessed.

Java WorkShop and VisualAge for Java are the only tools we've seen that isolate the generated code into a separate files. You can modify the other files. To us, this seems a lot cleaner than having designated areas of a file that shouldn't be modified.

Unfortunately, Java WorkShop can't print files -- a shortcoming we find unacceptable. If a tool wants to be our framework, it needs to facilitate all the common tasks.

Although Java WorkShop 2.0 is much faster than its predecessors, the entire framework is still rather slow. Tasks like reading large help files into a browser and conducting searches take too long, and the wait is all the more frustrating because it is unclear what WorkShop is doing while you wait. (No icons change; you just see a message in the status bar and the slow-turning animation in the corner of the browser.) The slowness is due in large part to the browser's lack of random access -- a weakness that really shows when using help files.

For example, in order to find documentation on the MainHelper class, we brought up the help contents, and then searched for MainHelper. After about 10 seconds, this search returned one hit, in the "Index of all Fields and Methods" help file. When we clicked on this entry, the browser began to load the file, and we received a cryptic status message indicating that it was going to the spot in the file containing the keyword (MainHelper). However, despite the fact the file resides locally and is less than one half of a megabyte, Java WorkShop never seems to finish loading the file and getting to the keyword. After five minutes of watching the elevator bar get smaller (indicating that the file was still loading), we finally gave up and killed the help process -- which also killed Java WorkShop itself. After several failed attempts at accessing the same file with WorkShop, we tried an alternative approach: With Netscape Navigator we brought this file up in just a few seconds, and in just few more seconds searched and found the keyword in many places in the file.

In the next release of Java WorkShop, Sun plans to integrate Studio. What we don't know yet is whether Studio will increase its support of visual programming, or remain a bit behind VisualAge.

SUBHEAD_BREAK: SuperCede Inc. SuperCede Professional 2.0 http://www.supercede.com

It is clear that SuperCede did more than create a tool; it directly addressed in version 2.0 two of the main complaints about Java: speed and legacy code support.

Click image for expanded view

Floating palettes and other small separate windows make

SuperCede quite usable even in low resolutions (800x600

or less). Notice that edit and debug operations are on

the screen while the applet is running, so you don't have

to bring up different windows to make changes and try

them out.


In last year's review, SuperCede was the only tool with a native compiler. Now Visual Café also offers a compiler, but only SuperCede's compiler will work for all JDK 1.1-based programs and class libraries. This is because SuperCede compiles any bytecode file, whereas Visual Café can compile only most Java source files.

SuperCede also provides the best integration with C/C++ code because it supports JNI as well as direct calling of C/C++ functions. It also includes a C/C++ compiler and debug support. SuperCede manages to provide all this support for other paradigms while being fully JDK 1.1-compliant. You can use C++ code easily within SuperCede thanks to its shared-object model. An additional benefit of this is that it is easy to derive and use C++ classes from classes implemented in Java. SuperCede is the only tool in this review that supports ActiveX; it thus lets you directly use thousands of software components that already exist for Windows.

SuperCede is the tool with the most RAD-oriented features. It goes beyond the incremental compilers of IBM VisualAge for Java because it can reflect some changes in code without restarting the program. It works like this: When you run your program you can make changes to it without stopping the program; most changes will take effect when you press the Update button.

SuperCede and Visual Café can detect that a change was made to an active function and give you the option to restart from the beginning, restart from the changed function, or resume. SuperCede goes further in that it can detect that a change to an inactive function (such as init) resulted in a change to global data. With SuperCede, you are presented with information detailing what was affected (global data, active methods or both) and given the restart options.

SuperCede also is unique in that it includes a Visual Basic-to-Java source conversion. (Note, though, that we have not tested this feature.)

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

For database programming, SuperCede includes both JDBC APIs and Java Data Objects (JDO). JDO is SuperCede's implementation of Microsoft's ActiveX Data Objects. SuperCede claims this makes it more convenient to deal with a database, by allowing you to do most operations without writing any SQL code. What we find is that this isn't always less complex: you are writing with objects that basically are like embedded SQL. That is, you write SQL statements as a parameter to a method call on the database object.

The combination of a compiler, easy access to native code, the Visual Basic translator, and support for both JavaBeans and ActiveX makes SuperCede the best tool for organizations with legacy code. It is rare to find a tool that effectively serves IT needs while at the same time making us down-in-the-trenches programmers happy with such good RAD support.

Perhaps the most amazing thing about SuperCede is that for now it is available for free. You can download the standard edition (not the professional edition reviewed here) for free from SuperCede's Web site, or order a CD for only 0. SuperCede plans to continue this offer at least until mid-April.


In the code generated by the GUI designer, the placement and labelling of objects is hidden in a persistent object-store file (specifically a Java serialized object file), so placement and labelling is difficult for the developer to programmatically change. Although the resulting Java code is legal, it cannot be reverse engineered by other products (like JBuilder and Visual Café) into a visual representation. Like most tools, SuperCede does not offer reverse engineering.

The packaging and literature say that Starbase Versions are included, but during installation Versions asks for a serial number and lock code (which you can leave blank for the evaluation version). The user does get a full version of Starbase Versions. However, due to a miscommunication between SuperCede and Starbase, the necessary serial number and key is not in the box. SuperCede thought Starbase was going to put this information on its insert (in the partners catalog), as it did with version 1.2. If your box does not have this insert, send a note to sctech@supercede.com to get the serial number and key.

SuperCede's GUI designer doesn't provide a visual way to define interactions (events of one object acting upon another, as in VisualAge, Visual Café, and Cosmo Code). The GUI designer doesn't provide a way to visually place non-active GUI objects like lines, circles, and other geometric forms.

SuperCede's GUI designer also does not allow you to change properties of multiple objects. (JBuilder, VisualAge, and Visual Café offer this feature.)

Help is incomplete, with no information on interactions, wiring, and many other issues. The Java API help is a duplication of Sun's standard documentation, with no detailed explanation or examples.

SUBHEAD_BREAK: Symantec Visual Café Professional Developer's Edition 2.1 http://www.symantec.com/domain/cafe/deved/features.html#b

Visual Café has a rich feature set -- and a memory appetite to match.

Click image for expanded view

Visual Café has the only debugger of the reviewed

tools that supports the major VMs (Microsoft, Netscape,

and Symantec's own). The debugger, which shows a lot of

runtime information at all times, makes it easy to add

variable "watches." Notice that placing your cursor over

a variable will show its value (like a tool tip, if the

variable is in-scope). Visual Café also boasts an

expression evaluator, but it is not as powerful as the

scrapbook in VisualAge for Java.


Of the tools that have gone through a prior generation, Visual Café is perhaps the least changed -- but we mean that in a good way. The prior version already was mature and highly capable. The biggest improvements in the new version are the documentation, the support for JDK 1.1, incremental compile/debug, and the compiler, which allows you to create native applications.

Of the reviewed tools, Visual Café has the only debugger that works on Symantec's JVM, Netscape's JVM, and Microsoft's JVM. This is a great feature for developers because many software bugs in your Java code might be reproducible only in a particular VM.

Visual Café and JBuilder are the only two-way tools in this review. That is, they can reproduce the visual representation of your GUI code, as long as certain rules are obeyed.

When we last reviewed Visual Café, we considered it the best tool for rapid application development (RAD). Now Symantec has added incremental compile/debug capability to Visual Café, and in a very mature way. The problem with incremental debug is that some changes typically will have no effect unless the program is restarted. As you debug your code, you can make changes. When you stop or resume program execution, Visual Café recompiles and gives you the option to restart the program.

Visual Café automatically saves the file when you compile or resume debug after making a change. It also can automatically save the file periodically while you are editing, and it automatically backs up files when you save them.

Native applications created with Visual Café have many advantages. Besides the obvious issue of speed, Symantec has managed to make the binary version of the class libraries much smaller than the normal JDK. Instead of needing a 9-megabyte classes.zip file, a compiled Java application needs only the dynamic load libraries (DLLs) that are actually used in the application. Using all of the DLLs would require about 4 megabytes.

Visual Café has a lot of features for working with the source files, such as global search and replace. Its file-compare tool would be a lot more useful if it had some options, such as the ability to ignore lines that differ only in trailing spaces. (In the reviewed version, if you bring up a file in the editor and save it to a new name the tool will spot many differences between the saved file and the original file. This is apparently because Visual Café's editor options can affect how spaces and tabs are handled, and the default settings are different than when the samples were created.)

The Visual Café Professional Developer's Edition also comes with Visual Page (an HTML authoring tool), Netscape Communicator, and the Netscape Communicator patch to run JDK 1.1. We aren't going to give you a complete review of Visual Page, but it seems like a decent program (although it does some things that not all browsers will like, such as providing end-paragraph tags (</P>). Also, Visual Page always wants to force the author's choice of fonts, rather than allowing the browser defaults. We've found the JDK 1.1 patch necessary where Netscape freezes on a system upon starting Java.

From the original Café, through this latest release of Visual Café, the area most improved is documentation. Visual Café now excels both in printed and online documentation. The problem with the documentation of most tools is that it is simply a screen-by-screen breakdown of the components of the tool. This would be fine if you wanted to memorize the tool. But when you want to get things done, you need a manual that is task-oriented, in which you don't have to know what part of the tool performs a particular function. Visual Café's extensive User Guide (more than 400 pages) is an excellent example of the right way to do documentation. Getting Started offers an extensive introduction, covering installation and creating your first applet as well as describing a couple of debug scenarios, the other online and printed documentation, and where to get more information and support. The Visual Page User Guide (more than 140 pages) is also well done, bringing the total printed documentation to about 750 pages.

Visual Café's visual editor does assist you in defining interactions between components, even non-visual components. However, it does not assist you in visually changing these interactions; you'll need to edit them in source code. And it does not show interactions visually on the screen (such as the "wires" of Cosmo Code and VisualAge for Java).

Visual Café is the only tool reviewed that is available for the Macintosh.

Although all the tools have their own Web sites with future information, Symantec goes further by providing newsgroups on its server.


Most problems with Visual Café are minor or easily fixable system-configuration issues. The two biggest problems are occasional crashes and its tendency to hog memory. Most crashes are caused by errors in the configuration: Usually either CLASSPATH points to the wrong libraries, the system doesn't have enough virtual memory, or multiple versions of certain DLLs (like javai.dll) exist. Admittedly, we encountered some of these problems because we've been using so many other IDEs that we had four copies of javai.dll on our review system. However, there are some sequences of use (such as changing the display order of a panel in a flow layout, and then compiling) that cause a crash. Symantec has acknowledged these problems in its newsgroups and is working on solving the problems.

Make sure you have at least 100 megabytes of virtual memory to assure Visual Café will run without crashing. Also, if you run with less than 64 megabytes of actual RAM on Windows 95 (NT requires even more memory), the tool will be slow.

The online help is better than most, but it still needs improvement, particularly on components that Symantec supplied. For example, when you display help for a pressed-on button for a value in the PropertyList, you can get help on inane things like Font.size but not for other attributes that aren't so obvious. (For example: What does Value signify for a ListSpinner? This component is supposed to list text items, but Value appears as an integer.)

Finally, one experienced developer told us that Visual Café's editor doesn't provide enough muted colors for viewing your source code. It seems silly, but if you spend 12 hours a day writing code, you can get a headache if the source code windows are glaringly bright or excessively dark. Visual Café's only muted color is gray.

SUBHEAD_BREAK: Select links to related documents

Reviewed products' home pages

Carl Dichter is a senior technical marketing engineer at Intel Corp. He has been an engineer for 17 years as an employee of Intel, Motorola, and various small companies. He's also contracted for AT&T, GE, and Honeywell. He has been writing articles for seven years and is the co-author (with Mark Pease) of the book Software Engineering with Perl.