Product ReviewA Close-to-Perfect IDEVisualCafé 4.0

• By Tad Kershner
• April 12, 2000

Version Reviewed: 4.0 Current Version: 4.0
CUP RATING SYSTEM: 5 Outstanding 4 Very Good 3 Acceptable 2 Has Potential 1 Poor

YOU PROBABLY SPEND more time in your IDE than either your house or your car; so, it's easily one of the most important investments you'll ever make as a software developer. In a market with many good candidates, the choice of an IDE is a largely personal decision, and it ultimately depends on how well a particular tool suits your individual work habits. Fortunately, the list of good IDEs for Java developers is a strong one, but whatever your preferences, VisualCafé should top that list.

Getting Started
VisualCafé gets an A+ for its documentation, which is well-organized and cleanly laid out. Its step by step instructions are easy for a novice to follow and for an experienced user to scan. Everything is explained without being condescending, and the text is complemented by numerous screen shots.

The product's wide variety of tools and options is almost bewildering at first glance. Indeed, in the beginning it took me several minutes even to figure out how to pull up a simple source-code window. Fortunately, the interface is designed for usability; between it and the manuals, users can expect to climb readily what would normally be a fairly steep learning curve.

One minor annoyance is that everything in VisualCafé revolves around Projects; you can do almost nothing without one. You can open a source-code window without a Project, but you'll find yourself searching in vain for the compile command. (It's under the Project menu, which doesn't even appear until you have a Project.)

Editing
VisualCafé includes all the expected features of a true programmer's editor. It provides smart indenting while you type, and you can indent or un-indent entire blocks if you add a new control structure (such as a try/catch) around them. The balance delimiters command is useful not only for checking proper brackets and parenthesis, but because it highlights the entire area in question, it's a quick way to select blocks for a move or copy.

One outstanding editing feature is the product's ability to use key (or menu) commands to navigate within the source code to the first, last, current, previous, or next compile errors. This is a huge timesaver—especially on large projects where navigating between classes to fix new method signatures can be an enormously complex process.

If you've never used code completion before, this feature will soon be on your must-have list. Type in a few characters and pause, and VisualCafé will provide you with a pop-up window of member variables, class names, method signatures, or imports—whichever is appropriate for the given context. The list scrolls as you type, or you can just use the arrow keys. You'll find that it is a huge productivity boost because you won't have to keep looking up exact method signatures or class names. As you develop, VisualCafé continually adds to its dictionaries, so you'll get full-featured code completion on your own code or that of your team. This feature alone makes the argument for full-featured IDEs in general, and VisualCafé in particular.

Window Management
When you work with VisualCafé, you work with windows—windows that provide options for editing, viewing, and controlling almost everything. To make the most of this feature of the product, you're going to want to develop a strategy for organizing your screen so that you aren't swamped by all these (mostly useful) windows. Fortunately, a lot of work has been put into designing the product's interface, and that effort comes through in terms of usability, power, and control. Working with the product left me at times feeling as though I was in the cockpit of an F16, but even the most complex of its controls is ultimately straightforward to use once you've spent a little time feeling your way around.

As seductive as pointing and clicking are, real speed lies in keeping your hands on the keyboard. Key commands are always welcome, and VisualCafé provides lots of them for quick, mouseless navigation between windows. The window key commands are also useful for finding windows that have gotten buried.

The Expert Edition has two modes of organizing windows: Single- and Multiple-Document Interface (SDI and MDI, respectively). Someone somewhere might like MDI, but I personally find it to be one of the most annoying "features" I've seen anywhere. With SDI, your windows float as you expect, but under MDI, many (but not all) windows become dockable. My windows snapped into at least five different shapes and sizes as I moved them around with docking on. Even more annoying, all docked windows are permanently in front, hogging a fair chunk of screen real estate from more important windows. When you really care about a window (such as maybe your source code!), it politely slides (and even maximizes) behind the docked windows. Thankfully, both docking and MDI can be turned off (although you have to restart the app to totally kill MDI).

Workspaces
As you move through different stages in the development cycle, you'll focus on different things in different windows, which usually makes for a lot of window shuffling. Fortunately, VisualCafé provides "workspaces" so that you can save different window configurations and move between them at will. You can set up different workspaces for different tasks—such as a Rapid Application Development (RAD) workspace with Component, Property List, and Design windows, and a leaner workspace for straight development with lots of room for code. Edit and Debug workspaces come predefined. Changes that you make to your current workspace are automatically saved; so, if you're planning to make a new one, be sure to create it first and then move the windows. Switching workspaces is easy to do from a pull-down on the main toolbar and is a truly convenient enhancement.

Javadoc
VisualCafé provides several tools to streamline the javadoc process. The javadoc editor lets you scroll through classes and methods, adding javadoc in spacious dialogue box elements. Unfortunately, it also adds @param tags to everything and then proceeds to warn you if you leave them blank.

A truly useful and convenient tool is the ability to generate javadocs from within the project, which saves having to reset the classpath, among other things. If you like to have nicely formatted, easy to read javadocs, this will save you many a save-generate-tweak-resave-regenerate cycle. Since javadoc is built right into the IDE, it's easy to incorporate it into the development cycle instead of leaving it as an additional pain at the end that we all too often never quite get around to.

One minor annoyance is that VisualCafé wants to recompile every time you regenerate javadocs, which is odd since you'll often want to be javadocing before files are in a buildable state. You can, of course, ignore the compiler messages, but it's an unnecessary performance hit, especially on a slower machine.

RAD: Beyond Prototyping
Visual development tools such as form designers and component libraries have been traditionally confined to RAD Prototyping, but with VisualCafé, these tools are so rich and readily usable that they'll quickly prove invaluable in other areas. Development projects of any size, and even everyday maintenance, frequently call for building small utilities to handle everything from truncating logfiles to automated testing. While these utilities are usually written as quick scripts with hard-coded parameters, VisualCafé's RAD tools make it easy to take them to a new level of sophistication, turning them into GUI-driven utilities the whole team can use.

VisualCafé's form designer follows the traditional model: drag-and-drop to add or move components, modify properties in the properties window, and add interactions with the interaction wizard. Having had bad experiences in the past, many developers still find it a little unnerving to hand over generations of their code to something else. As code generators go, VisualCafé does it right, and you'll soon find yourself won over by having the complexities of GUI component interactions automated so that you can focus on more important coding. Unlike some applications that store generated elements in proprietary (or at least uneditable) formats, with VisualCafé, it's all there in source. The form designer updates in real-time, so that changes made to the source are immediately reflected in the designer window and vice versa. The form designer itself employs a real JVM so that what you see is really what you get, not an approximation prone to nasty gotchas in later deployment.

The component library includes all of the AWT elements, as well as Swing components and two tabs for the Expert Edition's Database components. Adding other components from third-party libraries is simple, and the number of libraries to choose from continues to increase as java gains popularity.

When working with the form designer, be sure to set the layout of the main container (Window, Frame, etc.) appropriately before you add other components: Changing it afterwards will throw all components into a big pile in the center, and is not undoable. As with most GUI designers, the default layout is "none"; so, it's all too easy for the unwary novice to get caught up in pixel-alignment problems that won't translate to other platforms.

The interaction wizard does an admirable job of setting up event-handling structures, and presents all the different types of events in a clean table so you don't have to scramble for your Java reference every time. Ultimately, of course, you'll add and refine code, but the RAD environment automates most of the tedious tasks.

Debugging
Nothing kills development momentum or developer morale like a bug that refuses all efforts at analysis. Especially in complex object systems, bugs can be buried many layers deep, and it's often difficult to follow all execution paths on paper. The debugger helps you to watch your code while it runs, to see what's actually happening and isolate problems. Your IDE can easily pay for itself with gained productivity in a few debugging sessions.

VisualCafé includes a full-featured debugger, complete with conditional breakpoints, call and thread stack windows, a watch window for both values and expressions, and my personal favorites: step out and value tips. The Expert Edition adds incremental debugging for applets inside a browser and even remote debugging.

If you've used a debugger before, VisualCafé's will have all the familiar features, and you'll wonder how you got along without the new ones. Breakpoints are vital to the debugging process because they allow you to skip forward and examine only the parts of the code that you're particularly interested in. Conditional breakpoints take it one step further and allow breakpoints to occur only if a certain condition(s) is met: such as on the 51st iteration of a loop, or if a method call returns true. Watch out for side effects, however: Mutators are allowed and by typing "i=3" instead of "i==3" you can cause bugs in the debugging process!

If you've ever been going happily along the "Step Into" path only to get stuck in a Java base class or further down the call stack than you wanted to be, you'll appreciate the companion ability to "Step Out." This command does just what it says; allowing you to return to the point just after the current method was called (unless a breakpoint is encountered first).

You can set up any variables or expressions that you want in the "watch" window; as long as they are in scope, the debugger will continually update their values there. VisualCafé also provides "value tips" for observing on the fly. Hovering the cursor over an in-scope variable in source code while debugging brings up the familiar tool tip with the given variable's value.

Conclusion
I've only touched on all that this product has to offer. VisualCafé has been a pack leader since the early days of Java. Now, at Version 4.0, it has a maturity and solidity that are second to none and make it a pleasure to use on a rigorous day-to-day basis. With all its features, this is close to a perfect IDE. They make them different, but they don't make them any better.