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 2
Page 2 of 6

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.

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