Which Java visual development environment is best for you?

If you’re one of those macho developers who likes nothing more than a command line and a text editor, stop reading this review. This article focuses on the Java development tools that cater to the rest of us: visual integrated development environments.

In this review, we focus on Java development tools available on PCs running Microsoft Windows 95 or NT, because the majority of Java developers use such machines. Collectively, the five tools in this review boast hundreds of thousands of users on Windows. Many of these tools are, or soon will be, available on at least one other platform (the Mac or a Unix flavor such as Solaris). (Non-Windows developers take heart: JavaWorld plans a follow-up to our August 1996 review of Mac IDEs, as well as occasional reviews of new tools for other platforms.)

To qualify for this review, tools needed to be visual IDEs for Java. That is, the tools needed to have a graphical (dialog) editor, a code editor, a compiler, a project management and build controller (“builder”), and a debugger — all integrated to work well together and produce code in Java.

With any comparative review of multiple development tools, the reviewers and editors face the insurmountable challenge of including the latest release of each of the top tools on the market. This is a rapidly moving target in any case, and especially tough with the hyper-evolving Java tools market. This review was no exception: The lineup of products and version numbers changed several times during the multi-month review, and as we publish this, updates of these products are being released. Furthermore, the first release of new tools, like IBM’s Visual Age for Java, Borland’s JBuilder and Metrowerks’ CodeWarrior, are being shipped. Yet if we waited a few weeks or a few months to conduct the review, the same problem would occur. Tools vendors (thankfully) refuse to sit still, making it all but impossible to schedule a review such as this to satisfy every contender’s wishes. Impassioned pleas such as “Just wait for version 2.0 to ship next month!” and “But we’re about to release our new development tool!” won’t cease next month — or next year. Therefore, we pushed ahead.

We looked at the leading vendors’ products and found that the following five fully released Java tools each provided a visual development environment on Windows 95/NT (as of April 1, 1997):

• Asymetrix SuperCede Java Edition 1.0
• SunSoft Java WorkShop 1.0
• Microsoft Visual J++ Professional 1.1
• Symantec Visual Café 1.0
• Visix Vibe DE 1.0

All of the tools reviewed are based on JavaSoft JDK 1.02 (except Visix Vibe, which uses its own libraries); some vendors are now offering JDK 1.1-based updates to their tools. (Check the vendors’ Web sites for the latest update information.) Bear in mind that these updates are not tested in this article, and we don’t know how strongly the tools support the new functionality. For example, JDK 1.1 includes JavaBeans, but the updates may not yet include a wizard to help you create your own Beans.

We selected and evaluated these tools using the criteria described in the Review criteria section below. To help developers reading this review consider longer-term issues, we’ve supplemented this comparison with some details about the features expected in forthcoming versions of the products reviewed — as well as a discussion of the major products that are not included in the review. See our sidebar that details “Java developer products not reviewed.”

Review criteria

Each of the five tools has taken an entirely different approach to supporting Java. As a result, each might be appropriate for certain situations. You need to determine which features matter most to you. With this information in hand, you’ll be able to use this comparative review to learn the details about each reviewed product so you can make an informed choice. This review has a section devoted to each tool. Each tool-specific section contains notes about the tool’s approach, and exceptional or missing features in the following subsections:

• Editors (visual screen layout tools as well as code editors)
• • Graphical editor for laying out your dialogs without writing code to put controls and static items like text, lines, circles, and squares on your screen.
  • Full screen text editor for editing code.
• Compiler and Builder (Project manager)
• • At a minimum, they easily add or remove files from a project and understand which files have been updated and need to be rebuilt.
• Debugger
• • At a minimum, we expect a debugger to allow us to place breakpoints, examine and change classes/variables, handle multiple threads, single-step through code, and step into or over functions.
• Libraries
• • We expect all the JDK 1.02 libraries including AWT. Additions or missing classes are noted.

• Documentation/demo/tutorial

  • Good online documentation (including a user’s manual for the tool, and Java language and API references) is expected. A printed manual is now considered optional.
  • All tools have a Web page for support information, product updates, and, in some cases, a free trial version.
• Other Features
• • Anything else exceptionally good or bad about the tool.

We did not benchmark compiler performance in this review. We find that the speed at which the compiler runs is not the big factor in development cycle times. Rather, the key factor is how fast you can make a change, compile, and test to see the effects of that change. These issues are covered in each section’s RAD features discussion.

Many of the tools, when used on their own, are a reasonable solution for learning Java and creating simple applets. For building industrial-strength applications, however, it is important that they integrate well with other tools (like configuration management and testing tools), support sub-projects, and have the ability to build reusable components. The ability to create a fully compiled executable is important if you require high performance, or wish to hide the implementation of your program. You need to establish the importance of these features in order to rank the tools based on their merit in your organization.

Features at a glance

The table below gives you a good idea of the overall capabilities of a tool. Using this table, you should be able to quickly narrow your choices. For example, if you want to run on both Windows and Solaris, you have only two choices: Java WorkShop and Vibe.

For a definition of terms used in the table and elsewhere in this article, see the sidebar Glossary of Terms.

Asymetrix SuperCede Java Edition 1.0

Approach

SuperCede (SC) is the only tool that allows you to use Pure Java to create Java byte code applets or applications and still allow you to create binary executables that run at approximately the same speed as native C/C++ implementations. Asymetrix based the implementation of its Java and C++ classes on the same object model that allows you to easily integrate the two languages.

Editors

The SC editor environment does not have a lot of extra bells and whistles, but it does come with the more advanced common features, such as Java and C++ code color formatting, macro support, and ability to import non-SC applets. However, SC lacks some key features that are useful to large-scale development projects, such as the ability to search for text in all files in a project, nest sub-projects within a project, and integrate with outside tools.

Although the SC environment is designed for RAD development, we did uncover a bug trying to create a layout manager object to the code that would work with controls that were added via the visual builder instead of dynamically created by the code. This takes away a little flexibility, but the tool more than makes up for it with the ability to dynamically make changes in the visual forms and/or code editor and see the effects of the changes instantly.

Compiler and builder

Only two tools, Asymetrix SuperCede and Visix Vibe, can fully compile Java into fast, stand-alone executable programs and libraries (DLLs). The unique advantage of SuperCede (SC) is that it supports Pure Java solutions that let you generate and compile Java code to SuperCede’s highly optimized Java virtual machine (VM). The SuperCede Java VM can be used to compile code on-the-fly or as a Web browser plug-in. The SuperCede VM provides a high-performance Java runtime program that boosts the performance of Java to C++ speeds. Asymetrix claims performance that is 50 times better than interpreted Java and up to 5 times better performance than the best just-in-time (JIT) Compiler and Builders. See https://www.asymetrix.com/products/supercede/news/benchmarks.html for more information on their claims.

Debugger

In addition to standard debugging features, SuperCede has a two additional and powerful features called trace points and action points. Trace points are set like breakpoints, except messages can be output to the debug window instead of stopping execution. This approach helps you avoid adding print statements all over the code to track execution points. Action points let you execute a piece of code each time a specified point is reached, without necessarily halting the execution of the program.

Another cool feature of the SC debugger is the Scratch window, which allows you to enter Java code on the fly and run it in the current scope of the debugging environment.

SC’s applet viewer doesn’t enforce the security rules that a standard browser might, allowing you to bypass these issues during the development phase. For example, an applet can access local files within the applet viewer even though it can’t when it’s running within a Java-compatible browser. For this reason, you should always test applets within their true context — Web pages that represent their actual uses — to make sure everything works as intended.

Libraries

Asymetrix implemented its Java and C++ classes using the same object model that provides seamless integration with C++ to facilitate the creating of Java wrappers for C++ programs or C++ wrappers for Java programs, so that either can call the other. Using SC, you can call C/C++ code directly, or by using the more complicated Java Native Method scheme.

Also, Asymetrix has bundled a number of other libraries with SC. These include Netscape’s Internet Foundation Classes (IFC), ObjectSpace Inc.’s Java Generic Library (JGL), and Object Design Inc.’s ObjectStore Persistent Storage Engine (PSE). (For more details about JGL, see the article “Need a good set of abstract data structures? ObjectSpace’s JGL packs a punch!,” also in this issue of JavaWorld.)

RAD features

SuperCede is well-suited to rapid application development (RAD) because it offers the fast cycles of changing code, applying the changes, and showing the results. Its “Flash Compiler and Builder” technology allows you to make changes to a running program, such as editing the event handlers, and apply the changes with a simple click of the Update button. The program will continue running from where it left off, with the new behavior in place. In SC’s “bounce” demo, for example, you can change the circle into a square, or change its color. When you press Update, the new object continues moving on the screen from the position of the old object.

Documentation/demo/tutorial

SC comes with a full interactive demo that not only demonstrates the different features of the tool, but also covers the Java language itself. SC also comes with a full-blown client/server application that implements a Fantasy Sports Draft. This great example covers many issues, such as handling multiple logins to a server with multiple threads, as well as real-time interaction among multiple threads.

Other features

By the time this article comes out, Asymetrix is scheduled to have released SuperCede Java ActiveX Edition and a version with database support. The company also plans to offer a Visual Basic-to-Java converter. Most Visual Basic programmers depend on a lot of functionality in existing binary objects in the form of ActiveX, VBX, OCX, or OLE controls. Simply converting the Basic to Java won’t do, because these objects are not necessarily written in Basic, and the source may not be available. If this tool works as promised, fully integrated with ActiveX controls, it is possible that any Visual Basic program could be converted to Java — although it wouldn’t be 100% Pure Java.

Asymetrix also has a free upgrade path to the Java Development Kit (JDK) 1.1 with JavaBeans. This upgrade is scheduled to be available in June, and the company claims that it offers the only free upgrade path to JDK 1.1. See https://www.asymetrix.com/pr/sc_upgrade.html for more information.

SunSoft Java WorkShop 1.0

Approach

Java WorkShop (JWS) comes with the HotJava browser, which is actually a Java program itself, and the entire development environment is centered around the browser. This approach has some pros and some cons. Because the development environment is a browser, applets are easy to build and test because they run right within it; however, the performance is relatively poor in comparison to the other tools discussed in this article. Another downside to the browser approach is that it is not well suited for large project development because the browser has limited view space; you need to scroll the browser window to view all of the project information available.

By using the browser as the interface, JWS is inherently familiar and allows for a consistent way to access commands. For example, you can set the “Action” handlers of a Java control (widget) in the same way that you set the browser properties.

Users of other SunSoft tools (such as those offered for Solaris) will be comfortable with the look-and-feel conventions of JWS. However, being a tool written on a cross-platform foundation, it doesn’t take complete advantage of particular platform niceties. This development paradigm is a big switch for Windows developers who are used to the latest tools. Also, although the installation was quick and easy, we did find a bug on the Windows NT 4.0 platform in which it would not add the program to the program group.

Despite being written in Java as a cross-platform tool, JWS is not yet any more portable than most other tools, it currently supports only two platforms: Solaris and Windows. This is because SunSoft had to learn the specific native methods required to implement the debugger for each platform. Also, being written in Java, JWS 1.0 also suffers from JDK 1.02’s lack of a print function, and thus you cannot print from within JWS (no printing out code for review, comments, or other markup). But as Java matures (JDK 1.1 supports printing) and becomes more robust (so that the AWT and/or forthcoming JFC include the APIs necessary for the JWS debugger), JWS will likewise become more robust and run on additional platforms, including HP-UX.

JWS is the one of only two tools (Visix Vibe 1.0 being the other) we reviewed that is available on Solaris, and if you are a Solaris user this detail obviously makes all the difference. For reasons we point out in the following subsections, Windows users probably will want to pick another tool, or wait to see how the 2.0 release (currently in pre-beta and expected to ship in August) shakes out.

Editors

The JWS dialog editor, Visual Java, always uses geometry management. You can’t just freely drag and drop controls wherever you want; instead, you must explicitly place objects in available cells of a visual form to get it where you want it and then manipulate the containing cells properties to implement the appropriate geometry you require.

We did uncover two very annoying bugs while testing the Visual Java editor, both related to viewing forms in either a “Layout” or “Preview” mode. The first one occurs when changing the visual form from “Layout” to “Preview” mode: The Visual Java window is resized back to the standard opening size. This is very irritating if your dialog is larger than the default window size. The second bug occurs when putting a window object in “Preview” mode: JWS automatically puts the window object in the top-left corner and doesn’t give the window focus. This also is irritating because if there is another application in that window space, the window object is instantly hidden — it isn’t brought to the front. Visual Java allows the desktop screen to become cluttered over time because of the numerous dialogs that are spawned throughout the development cycle, and each window wastes a lot of space with oversized controls required to operate the user interface.

Compiler and builder

The JWS byte code Compiler and Builder is the standard for Java compilers. The builder understands project hierarchies maintained by the Portfolio Manager so you can have sub-projects, or projects consisting of other projects. You cannot integrate outside tools into the builder, but in the future SunSoft plans to expose the API of JWS so that you can perform macro-scripting to automate common functions and extend its functionality.

As we mentioned earlier, we originally felt that compile times were not that important in the review of these tools. JWS 1.0 gives us pause to rethink this: It takes about four times longer than the other tools to compile the same source. Fortunately, SunSoft realized this shortcoming and made improving compile time a priority in the upcoming 2.0 release of JWS, due in June. SunSoft reports that the new compiler is up to 15 times faster then the standard Java compiler provided with the JDK.

Debugger

Like Microsoft Visual J++ (VJ++), JWS lets you debug applets within the browser, but because this same browser is used for the applet’s parent Web page and the debugger, JWS won’t let you display them at the same time and work as interactively as VJ++. This is a major hindrance to the RAD paradigm.

The JWS threads inspector allows you to control or inspect any thread. Unfortunately, you can have only one thread inspector on the screen at a time. Therefore, your ability to display data on more than one thread at one time depends on how much you have to expand the trees to get to what you want.

This debugger, like that of Vibe, does not have conditional breakpoints. If you have a problem that doesn’t show up until a certain condition is met (like the thousandth iteration of a loop), you’ll need to write a conditional piece of code in your app, recompile, and put a breakpoint in the added code.

Libraries

Coming from the home of Java, you would hope JWS would have the best support for Java. For now, however, like the other tools in this review, JWS is based on JDK 1.02. It looks like we have to wait until at least June before tools start shipping with JDK 1.1.

RAD features

As noted earlier, changes you make in the dialog editor or in an object’s attributes take effect immediately. You can filter by event and perform various actions without writing code. For example, you can change a button’s “Action Event” to rename a label’s text property and it will immediately take effect in the visual builder window.

As a result of being written in Java and running in the browser, JWS runs a little slow and takes up a lot of the screen real estate — another visual design no-no. If you are editing your code and then decide that you need to make a change to your project, you must switch the browser to the project management section and your code will no longer be displayed. Another example: To rebuild your code after a change, you must go to Build Manager, click the Build button, and then go to the Project Tester. This cumbersome process gets old quick! Also, because the information is so spread out on these screens, you have to keep the browser window rather large.

Documentation/demo/tutorial

The online documentation has some shortcomings: The help doesn’t have a search capability; there is no fast lookup of classes or APIs from the editing window; and the documentation on parameters, exceptions, and return values is very sparse. The tutorials also are lacking: Two very simplistic examples (Blink and Calculator) are used to demonstrate building your “first” apps.

Other features

JWS integrates well with configuration management programs like PVCS, SCCS, and RCS. It also comes with a Portfolio Manager that allows sharing of projects or information on your intranet and allows you to organize things in a hierarchy and create sub-projects.

SunSoft’s next version of JWS (2.0) is now in Developer’s Release and should be ready for final release in June. It is reputed to have a much better tutorial, improved usability, increased robustness, and added features like a profiling tool, a JIT compiler, and conditional breakpoints. JWS ports to MacOS and HP-UX are in progress. Although it is clear that release 2.0 will address many of our concerns, JWS 2.0 will still be missing some of the features of the premiere IDEs (such as Borland’s Turbo Pascal and Turbo C/C++) like one-key API lookups and variable watch windows.

Microsoft Visual J++ Professional 1.1

Approach

In the August 1996 issue of JavaWorld, columnist Bill Blundon said VJ++ would be “the de-facto standard for Java developers on Windows.” We have found no evidence to refute this statement, though a recent JavaWorld reader survey indicates Symantec’s trio (Café, Visual Café, and Visual Café Pro) currently may have more market penetration.

VJ++ has a number of unique features. VJ++’s IDE (Developer’s Studio) can support sub-projects, create cabinet (CAB) files (compressed files containing all of the information necessary to download, install, and register the components you control), and create ActiveX components easily (via ActiveX Wizard).

At 9, VJ++ already is at the low end of the pricing for Java tools. Right now, Microsoft offers a 0 rebate for users who upgrade from a competitive product, making the cost of VJ++ about 9. Whether you want to do serious application development with Pure Java or integrate Java with ActiveX, VJ++ fully empowers you.

Editors

In VJ++ version 1.1, Microsoft has integrated its new Visual Studio environment, which it employs in all of its language tools. Visual Studio has powerful editing features and “macro scripting” that you can use to automate tasks and create your own features. VJ++ does not yet have Intellisense, the feature added in version 5 of Visual Basic that recognizes keywords, variables, classes, and class members, anticipating what you are typing. Too bad. This feature would have been killer — you would almost never need Java API references.

You use the Resource Editor to create your dialogs or other resources, then run the Resource Wizard to create the Java code. The Resource Editor’s palette doesn’t provide all the AWT classes — Layout Managers, for example, are conspicuously absent. If you write Java code to do anything on the screen (such as use these missing classes), keep in mind that the Resource Wizard is a one-way process. Resource Wizard just uses the resource file as an input; added Java code doesn’t show up in the resource.

VJ++ does not allow you to add Java classes to the palette the way Visual Café does. You can, of course, programmatically use the classes you create. If your code has to run in ActiveX environments only, you have another alternative: You can put your new class into an ActiveX control (using the ActiveX Wizard) and then access it from the Resource Editor. Either way, reuse is more convenient in Visual Café.

Compiler and builder

When Microsoft was in process of creating the Java Compiler and Builder, it tested the component with the early class libraries and code examples available on the Internet. Because many of the people performing these tests were new to Java, they had a hard time finding out whether they were dealing with errors in the Compiler and Builder, or errors in the Java code. Each time Microsoft found something that was actually a code error, they added error messages to the Compiler and Builder to describe how to fix the error. As a result, VJ++ has some of the best diagnostic messages of the tools tested.

Debugger

Only VJ++ can run the debugger in the applet’s true context: within the Microsoft Internet Explorer browser. Although Java WorkShop runs within the built-in browser of the IDE, it can not match VJ++s ability to debug Java code while running in a stand-alone production version of one of the top two browsers in the world. With tools that lack this capability, you can’t use the debugger to work out most problems — leaving you only one way to debug an applet within the browser: by using print statements (display messages).

This VJ++ debugger is a first-class program that really knows how to deal with Java byte codes. It is the only product reviewed that can perform byte-code disassembly and byte-code-level stepping and tracing.

Libraries

Perhaps the most notable characteristic of VJ++ is that it isn’t a solitary effort. Microsoft has pulled together a collection of useful tools to make VJ++ a compelling suite. These tools include Aimtech Corp.’s Jamba, Neural Applications Corp.’s E-Mail Wizard, ObjectSpace Inc.’s Java Generic Library, Dimension X’s Liquid Motion (which is now owned by Microsoft, thanks to its recent acquisition of Dimension X), and Bulletproof Corp.’s JDesignProT. Many other tools are available, some free of charge, from the Microsoft Web site.

If you are interested in JDK 1.1 features, such as JavaBeans, Microsoft has the beta release of its Java SDK 2.0 available for download.

RAD features

The only major disadvantage of VJ++ is that it isn’t ideal for rapid application development. When you are in a mode of changing your dialog a lot, the extra step of generating code from the resource file seems extraneous when compared to the interactivity of the other tools. Also, you need to close the browser each time before running changed code; otherwise, you will run the old version.

Then there are the issues mentioned under editors — the resource (graphic) editor doesn’t give you access to all Java AWT controls, the code generation is a one-way process, and you can’t add your own classes to the palette.

Documentation/demo/tutorial

Microsoft has provided an excellent set of online documentation that is integrated into the Developer Studio to provide easy lookup for many of your Java questions. Help also includes pictures of most of the visual controls, based on the available styles of the particular class. In addition to some of the best online documentation, VJ++ includes the book Learn Java Now. For first-time Java programmers, this book provides a very good introduction to the language and leads the reader through the basic steps of writing that first meaningful applet. In addition to introducing Java, it also covers object orientation, animation techniques, multithreading, and VJ++ features, like Applet Wizard. The book’s approach is particularly helpful; it begins by describing techniques in an easy-to-understand manner (including code snippets, sidebars, and tips), then shows you how to apply those techniques in tutorial examples.

Other features

Microsoft also has brought its Cabinet packaging technology to Java, which allows you to bundle all the classes your application needs into a CAB file, compress it, and distribute it with about half the download time. Using Java does not insulate you from versioning issues, so you might want to use CAB files to help solve some configuration management problems. You can use a CAB file to make sure that the appropriate version of components are matched with compatible versions of your program by delivering the program and the needed components together.

Another compelling feature of CAB files is that they can have persistence. This feature allows applets, which normally must be downloaded each time the browser is restarted, to stay (or persist) on your system, saving valuable time.

Microsoft has also tackled the limitations applets must contend with because of security restrictions by offering code signing. If your Java application must access files, or do anything else outside of the Java security “sandbox,” some form of authentication, like code signing, is very important. Otherwise, the user has no way to know if the code can be trusted — it may have been hacked, or it may not have come from a trustworthy vendor. When you sign a CAB file, your user is assured the code came from “the real you,” and that it arrived unmodified. (Note that JavaSoft likewise now supports code signing with JDK 1.1.)

Symantec Visual Café 1.0

In some ways, Visual Café (VC) is at least a second-generation tool because it is heavily based on Symantec’s Café, which itself is up to version 1.51. Rather than simply going after more functionality, however, VC is meant to be an easier-to-use product that automates basic tasks with an intuitive user interface.

Ease of operation and decent tutorials make VC a good tool for getting acquainted with basic Java. Within minutes of installing VC, even non-programmers can create basic Java applets to make Web pages more interesting, or trivial application programs.

In fact, Visual Café is the only tool that has any “visual programming” beyond the layout of the GUI, although this is limited to its ability to define some basic interactions between objects. For example, without coding, you can specify that when a user clicks on a button, an animation object will start or stop running. You can even graphically interact with non-visual components if their behavior has been exposed with the Java Reflection API (or in the future with Beans).

A few bugs hindered our use of VC. At one point, the Dialog Editor Palettes all went blank, and we had to re-install. When we re-installed to a directory other than the one we originally installed to, some new problems cropped up. The most annoying of these problems was that occasionally, the entire IDE would crash when the Restart button was pressed.

Editors

Feature-wise, VC is almost everything you would want from a “100% Pure Java” tool. Being a tool in the spirit of Pure Java, VC doesn’t offer a lot of support for current paradigms like files. For example, although Java supports the FileDialog, Visual Café does not have an icon for it on the palette in the Dialog Editor.

Compiler and builder

Symantec’s JIT (Just-In-Time Compiler and Builder) claims to be the fastest both in compile and runtime in the industry and is now included in JavaSoft’s JDK 1.1 as the Performance Runtime for Windows.

VC project management is among the best. Projects can contain sub-projects, and you can call batch files to perform custom functions, such as call other tools. VC integrates easily with several popular configuration management tools, including SCCS and RCS.

Debugger

VC’s debugger is full-featured, and has remote debug capability — that is, you can actually debug Java that is running in another machine. The debugger is tightly integrated with the Java virtual machine, allowing you enter Java code on the fly and see the result.

Libraries

VC includes about 100 visual components beyond the basic AWT widgets. One valuable feature is that users can add their own objects to the tool palette — a feature exclusive to VC at this time.

RAD features

VC is highly interactive. Code changes often show up immediately on the dialogs, and vice-versa. For users of other visual programming tools like Visual Basic, VC will seem natural with its point-and-click access to objects and their properties. VC’s editor is configurable to act like a variety of different editors. It comes with “personalities” to make it act like Emacs, Norton, and Brief, and you can add your own. Also, the editor is macro-programmable.

Documentation/demo/tutorial

VC includes about 20 examples, such as slide viewers, an e-mail client, fireworks, flames, and other animations. Visual Café Pro (which will run you 99) includes database capabilities and even more examples (about 90). Both Netscape and Informix have decided to sell Visual Café Pro as their recommended Java solution.

The online documentation is good — much better than it was in Café 1.5: classes and methods are fully described, as are their arguments, return values, and exceptions.

Other features

Symantec’s standard Café product, at a price of 9 (including the book Teach Yourself Java in 21 Days), is a lower-end product with a subset of features.

The upcoming version of Visual Café features incremental build, debug and compile, and full support for JDK 1.1 and JavaBeans. (A beta version of this updated software should be available in June for download from Symantec’s Web site.) Symantec also plans to support cabinets in the future with VC.

Visix Vibe DE 1.0

Approach

Almost a decade ago, when cross-platform toolkits first arrived on the scene, they were often viewed as the least common denominator (LCD) between platforms. Visix Software Inc., with its Galaxy tool, was one of the first to break the bounds of LCD and deliver full richness to all platforms. Visix provides (among other things) excellent geometry management, internationalization (English and Japanese resource files are provided; users can add their own), and a PostScript-like drawing model that allows complex transforms on all platforms.

With its Vibe product, Visix brings “the Power of C++” to Java. Visix treats Java as a language that can be used with native code libraries to produce rich applications that run fast on all major platforms.

Vibe’s IDE offers many of the features of Visix Galaxy — a high-powered, cross-platform development system that costs more than 0,000 per desktop. Vibe uses Visix Foundation Classes (VFC), which are based on the cross-platform libraries used in Galaxy. These libraries are quite rich, and are recognized by some experts as the best cross-platform libraries available. Because these libraries are native code, they run fast, and because they are cross-platform, they are available for Windows, MacOS, OS/2, and the most popular flavors of Unix.

The IDE uses a lot of tabbed dialogs and split windows. It allows you to get to different parts of the application quickly and have a lot of relevant information on the screen at the same time.

Editors

Vibe’s editor had the best auto-indenting; you can use one of several different styles of indenting, or you can define your own style.

The dialog editor’s geometry management is powerful, but the metaphor used to represent it (struts, springs, etc.) takes some getting used to.

Compiler and builder

Although it allows you to create Pure Java applications, Vibe is not the ideal for “Pure Java” enthusiasts. It doesn’t support applets, and the AWT widgets are not graphically represented on the palette of the dialog editor. Furthermore, some of the JavaSoft examples will not work because Vibe does not support Java’s Native Method. Therefore, if you want to use native code, other than what is provided in the VFC, you’ll need to put it into an OLE/ActiveX control to get to it.

Like most of the other tools reviewed, Vibe allows sub-projects within projects. All of Vibe’s examples are sub-projects within a project called Example, so you can compile them all with one click. Once you do kick off a large compile job like this, though, you find an inconvenience: You can’t interrupt Vibe’s builder. It won’t stop until it compiles the whole project, unless you kill it from the operating system.

Debugger

Vibe’s debugger, like that of JWS, does not have variable watch windows, conditional breakpoints, trace points, or action points. Unlike JWS, however, this debugger won’t let you change the value of a variable. On the positive side, the debugger is very easy to use and makes good use of screen real estate.

Libraries

Vibe excels in its support of ActiveX by providing a wizard that generates the Java class to encapsulate the control. While developing test applications, we found it easy to use ActiveX components that our system has picked up from applications, or from browsing the Web. Because of Vibe’s support of OLE automation, your Java application can control other applications, such as the browser.

The ActiveX/OLE support in Vibe is not quite the same as the ActiveX support in Visual J++, so if you convert programs between the two, you will have to make some changes to the calling syntax.

RAD features

Changes you make to the layout or attributes, such as changing labels or changing the usage of struts and springs, show up immediately without compiling.

Documentation/demo/tutorial

Approximately 50 examples are included, none of which are the JavaSoft examples. What is unique about these examples is that they look like real applications: many have splash screens and About boxes. Some have advanced features such as drawing graphics outside their client window.

Other features

Vibe also has the distinction of being the lowest-priced tool reviewed. Overall, Vibe is a tool for serious applications (not applets), and a bargain at 9.95.

Visix promises versions of Vibe on Mac, OS/2, AIX, Irix, and Linux. Visix’s ability to effectively produce these releases on schedule will be a powerful argument to support its portability story.

Conclusion

As you can see, each of these tools offers a collection of strengths and weaknesses. After reading this comparative review of five top visual Java IDEs, we hope you’re able to narrow your choices down to the tools that will best satisfy your needs.

Personally, we will normally use Visual Café or SuperCede for most Java projects because they are well-suited to rapid prototyping and RAD. Visual Café is more mature, but SuperCede especially impressed Chris with its ease-of-use in all areas, from visual building to on-the-fly flash compiling. Also, we both appreciate that SuperCede, like Vibe, can make executables. It’s really nice to be able to make Windows (or Solaris) utilities, games, and other programs with Java.

Despite the fact that Visual J++ isn’t very good for RAD, we would use it when we need to make production-quality software. This is because of the interfaces to so many tools, and the ease with which we can use C++ and ActiveX components. (Note that we’re looking forward to the next releases of Java tools, because many will offer both JavaBeans and ActiveX.) We want access to the thousands of controls already available in ActiveX, and we also want to put proprietary code into ActiveX to hide it and to reuse it in other parts of the enterprise (such as on the server). We also like being able to use macro-scripting to automate a lot of tasks in code production/test. (Carl has created similar scripts in MS Office.)

We both like Vibe as an entry-level product, but suggest you turn elsewhere if you want to learn and use the pure Java API (Vibe uses Visix’s own foundation classes) or develop applets.

We encourage you to send in your thoughts and experiences regarding any of these developer tools.