Building platform-neutral Java: Which tool is best?

Index

• Introduction
• How they rank — an overview
• Rationale and test methodology
• Sun Java Workshop 2.0
• Borland JBuilder 1.0
• VisualAge for Java Enterprise Version 1.0
• Symantec Visual Cafe for Java Database Development Edition 2.0.
• Feature Chart

Introduction

Platform neutrality is the raison d’ etre of Java, which is what makes it perfect for network-centric computing. If you are developing Java applications in anticipation of having your programs run on everything from Network Computers to Unix workstations, you should work as if the lord of platform neutrality hovered over your shoulder like a micro-managing boss.

Unfortunately, you’re likely using Windows as your development platform. And many Windows-based development tools hinder rather than help developers create platform-neutral applications.

No, this is not the result of a covert plot by Microsoft to co-opt Java. It is more likely that when vendors designed their Java development tools, some of them may have underestimated the importance of Java’s platform-neutral features.

So which tool is the best one to use to create platform-neutral applications? When it comes to Java byte-code compatibility across Java virtual machines (JVMs), it is difficult to say — the Java Development Kit (JDK) is still a rapidly moving target. But it is not so difficult to determine which tools best exploit the platform-neutral features of Java, particularly when it comes to visual development.

And that leads us to our comparison of four powerful Java development tools. We examined the following products to find out how well they lend themselves to visual development of platform-neutral applications: Sun Java Workshop 2.0, Borland JBuilder Professional 1.0, IBM Visual Age for Java 1.0 Enterprise Edition, and Symantec Visual Cafe for Java Database Development Edition 2.0. We also evaluated the visual programming features of each product, and the breadth of the default palette of visual components.

How they rank — an overview

We graded the products from A to F in the following categories:

• Ease of creating a form based on the gridbag. (We also list the time it took to create a test form.)
• Maintainability of the form.
• Visual programming capabilities.
• Breadth of default component palette.

Java Workshop 2.0 is the hands-down winner when it comes to giving you the visual tools necessary to create an attractive, platform-neutral user interface based on a gridbag layout. This is because Java Workshop is the only tool that builds its visual designer around the gridbag layout. This makes Java Workshop 2.0 somewhat inflexible at times, but as an all-purpose tool, it can’t be beat.

If you want both ease and flexibility of visual layout, JBuilder is the best choice. JBuilder lets you design a layout using absolute coordinates and then convert it to a gridbag without many consequences. It then makes the management of that gridbag layout fairly easy.

Visual Age for Java and Visual Cafe for Java are the goats when it comes to visual layout. If you want to use a gridbag layout with these products, it’s all done with trial-and-error setting of gridbag constraint variables.

Visual Age for Java is light years beyond the other products when it comes to visual programming. There’s almost nothing you can’t do with a mouse and the Visual Age Visual Composition Editor. But it’s a bear to learn. Visual Cafe for Java, on the other hand, will do most of what Visual Age offers in the way of visual programming and make it much easier to get there.

Java Workshop doesn’t go nearly as far as Visual Cafe when it comes to visual programming. There are some neat tricks you can do, but you’re still better off writing your code by hand. Don’t bother trying to do any visual programming at all with JBuilder. Borland should have left out its lame visual programming wizard until it could have provided something more than the embarrassment that ships with the product.

Without creating a massive application, it would be hard to pick a winner between JBuilder and Visual Cafe for Java when it comes to the breadth of the default component palettes they provide. We especially appreciate things like the timer control (for triggering events) on the Visual Cafe palette. JBuilder includes some nice chart controls, too. Visual Age is leaner, but includes a broad range of useful Java classes. Java Workshop is the stingiest of the products when it comes to palettes.

We don’t enumerate every control these products offer (you can expand the palettes as you wish, anyway), but we do include some images of the default palettes so you can get an idea of how many controls are available.

Rationale and methodology

Aside from idiosyncrasies of JVMs, the problems of platform neutrality most often surface in a tool’s approach to visual Java GUI design. Windows-based tools tend to perpetuate the What You See Is What You Get (WYSIWYG) approach to visual development. With WYSIWYG design, you drop a button at a particular location on a form and that’s exactly where you can expect the button to appear when you run the application.

It is a familiar environment for Windows developers. But this approach will almost always generate applications that have display problems on platforms other than the one on which the application was developed. That unplanned-for platform may display the button with a different degree of 3D shading — shading that obscures the button’s label text — or it may automatically enlarge the button to display the text, causing the button to overlap an adjacent visual control.

It’s in the gridbag

Java provides something called the

layout manager

to address exactly this problem. A layout manager resizes and rearranges visual controls to adapt an application’s user interface to the current platform.

Java includes a number of default layout managers, including the card layout, grid layout, border layout, flow layout, and gridbag layout. Each one of these layouts can be useful at one time or another, depending on the type of interface you’re trying to design. Of these layouts, card, flow, and border are probably the easiest to use; however, the grid layout is also fairly simple. You can also set the layout to NULL, which defaults back to a WYSIWYG coordinate-based design. Or if you wish, you can program your own layout managers.

Of the layout managers that ship with Java, the gridbag layout tends to get the most use because it is the most flexible; however, many programmers find it the most difficult to master. The gridbag layout consists of a grid of cells, but the arrangement of components within those cells doesn’t have to conform to a rigid X,Y coordinate system.

You can drop a component into a single cell or have a component span several cells.

You then weight components within a gridbag layout to control where the visual components will tend to align themselves, or to determine their behavior when the user expands or contracts the window. You can weight components so that they will be more likely to remain in their current position when their surroundings change.

The weights can also determine whether your components take up more or less horizontal or vertical space when the window is adjusted. This technique is useful when you want a list box or spreadsheet component to expand to take up all available space, but you want your buttons to remain basically the same size.

These settings are called gridbag constraints. Each component that is placed within a gridbag gets its own set of gridbag constraints, which determine that component’s behavior in the layout.

The neutral zone

As difficult as it is to master, the gridbag layout is the best layout “out of the box” for designing application screens that are both platform neutral and attractive. So we chose the gridbag as our baseline for our tests. We designed various forms in each product using the gridbag layout, and rearranged these forms, switching between layout types in order to exercise how well each product allows the developer to maintain and modify existing designs.

We created a moderately complex form (twelve components of various types) and tweaked the gridbag settings until the form took on the desired appearance. The form had to remain attractive when resized or run under a different platform (we used both Windows NT and Linux).

Once you finished a form, you have a pretty good feel for the gridbag constraint settings necessary to make the next form take on the desired appearance. This seeming benefit actually presents a trap for testing purposes; what we learned about the gridbag settings from one product would make the next product seem easier to use.

To combat this dilemma, we arranged and rearranged the components differently each time, and then cycled back through the products twice to give each one three chances. Once we were comfortable with the product, we recorded the time it took to create a visually appealing form (as opposed to a usable, but un-tuned layout of components). We then evaluated the difficulty in revising that form.

There is more to a visual designer, however, than the arranging of components. Some products allow you to program the behavior of your application visually. We tested this capability for each of the products, as well. Finally, developers are always keen to have a variety of components from which to choose. So we rated each product according to the depth of its default set of visual components. Fortunately, most tools make it possible to add to the component palette, so a weak palette isn’t usually a deal-breaker for Java development environments.

It is important to note that we compared these tools primarily from the perspective of visual applications design. In so doing, we compared only a narrow portion of each product’s strengths and weaknesses. Consequently, we give no bottom-line score for these products. Please see our Feature chart for more details about those features not tested in this comparison.

Java Workshop 2.0

Ease of form creation

Java Workshop is a unique blend of brilliance and folly. When it comes to ease of creating a platform-neutral gridbag layout, Java Workshop 2.0 fulfills the mission far better than any competing Java development environment. But its finesse is often offset by awkward and annoying, if harmless, design decisions.

The gridbag layout-based visual designer takes some getting used to, but it is well worth the effort. The difficulty in learning this tool isn’t as much the fault of Java Workshop as it is a consequence of moving from a traditional WYSIWYG design environment to one where platform neutrality reigns supreme.

Once you’ve mastered the approach, however, design is a breeze. You can drop components and size them across grid cells very easily. You manipulate gridbag constraints settings (such as weights and fill-factors) by clicking on sections outside the grid. If at any time you want to check how the form will look during runtime, you can make an instantaneous switch to preview mode. You can then resize and manipulate the preview form to see how your design reacts to such changes.

There are a few minor goofs in the design. For example, you have to pull down a combo box to switch between design and preview mode when laying out a form. This requires two clicks for a one-click operation. The one-click alternatives (a button, a checkbox, two radio buttons, a custom on/off switch) outnumber this approach by such a wide margin, you get the impression Sun had to go out of its way to be annoying.

Even something as simple as moving a component from one spot to another proved more difficult that necessary. You have to click and drag from a very specific spot in a cell, and that spot isn’t always directly on the component itself.

You aren’t restricted to using a gridbag layout for every piece of your application, but every visual object in Java Workshop ends up within a gridbag layout sooner or later.

For example, you can create a flow layout panel. But you can’t populate it directly by dropping components on it from the palette. You must open up a settings dialog for that flow layout panel, and then insert a number of items. These items are — you guessed it — gridbag layout panels. You then populate each gridbag layout panel with one or more components.

In the end, you get a panel that appears to be populated only with components, but each component has its own gridbag. We could find nothing problematic in this approach (in fact, it’s possible thi approach will speed up development), but the idea took some getting used to.

Maintainability of form

Although you can add a single row or column to the working grid, you can’t delete just a single row or column. When you click on the grid, the intersection between row and column, including both the row and the column, are selected, so when you press the delete key, you delete both.

If you ever find yourself in a position where you must delete just a single row, you must add a column, select the intersection between the row targeted for destruction and the new column, and then delete both. While this approach isn’t particularly difficult, it will go down in history as one of those stupid interface tricks that should never have been necessary.

Java Workshop may be outclassed by the competition in many significant ways, and it is filled with more forehead-slappers (“what the heck were they thinking?”) than any other product, but there’s no getting away from the elegance of the way Java Workshop insulates you from the nasty details of the gridbag layout. No other product even comes close.

Visual programming

The visual programming features of Java Workshop 2.0 are very rudimentary. For example, you can specify a list of operations that will take place when you click a button, but unless the operation is something very basic (such as “hide the listbox”), you have to write the code yourself.

You can stack and reorder the operations. You can even specify filters for actions that trigger operations. For example, when you define an operation visually, you can specify that a particular operation take place only when the GUI button is pressed while the Shift key is being held down.

The template code generated by Java Workshop is very heavily commented, which proves quite useful.

Java Workshop 2.0 is itself written in Java. As if to testify to the immaturity of Java, we experienced a number of null-pointer exceptions while using this product. And, as if to testify to the robustness of the language, none of these errors ever interrupted our work. We simply dismissed the error dialog and continued.

Breadth of default palette

Java Workshop wins the anorexia award for having one of the leanest default palettes of visual components. You get everything you need for most applications, but precious little more.

JBuilder 1.0

Ease of form creation

JBuilder takes a unique approach to providing you with the tools you need to build a platform-neutral GUI. On the surface, JBuilder is just like Visual Cafe or Visual Age for Java. It uses something called an XYLayout by default. This feature lets you place components on the form in WYSIWYG fashion.

But that is where the similarities end. JBuilder departs from the other WYSIWYG designers by creating a connection between its WYSIWYG design and the gridbag layout. JBuilder lets you populate a form with components using XYLayout and then switch to a gridbag layout without losing most of your intended design — something that just doesn’t happen with Visual Cafe and Visual Age for Java. When you switch from a NULL layout to gridbag using either of these products, the components will go flying into different locations and take on various default sizes.

JBuilder is generally quite good at estimating the kind of gridbag constraints it will take to make the form look the way you created it via WYSIWYG, but the translation it does is never perfect. Count on fiddling with the gridbag constraints to get the form just right, especially with regard to how it will behave when you resize the window.

Maintainability of form

Fortunately, JBuilder makes it fairly easy to tune the gridbag constraints. You can pop up a gridbag constraints dialog for any given component. Better still, if you right-click on a component, you can set certain gridbag constraint parameters, such as vertical and horizontal weights and fills, or go directly to the gridbag constraints properties dialog box. And although it’s not nearly as clear and easy to move and resize components on a live gridbag layout form as it is with Java Workshop, you can do it in JBuilder.

If you plan to design your forms using the XYLayout-to-gridbag technique, we have a bit of advice: Plan ahead. It isn’t always easy to add a control to a form once you’ve tuned the gridbag layout of an existing form. Not only do you have to adjust the gridbag constraints for the new control, you may have to tune the constraints for all the surrounding controls.

In some cases, it’s easier to switch back to XYLayout to add a component or two. But every time you switch from gridbag to XYLayout, JBuilder will forget all the fine-tuning you did to the gridbag constraints when you had the form in that mode. So you may be in for a lot of tedious re-tweaking no matter what you do.

This is the one place where the restrictive nature of Java Workshop’s gridbag-only approach proves to be an advantage. While you can get into a little trouble with Java Workshop, the ability to add extra arbitrary rows and columns to a gridbag layout makes it fairly easy to add controls without severely disturbing the effects of your previous work.

Visual programming

JBuilder provides an Interaction Wizard as a visual programming tool. The idea here is to be able to automate simple interactions between components, for instance “Set the label to read ‘blue’ when you press this button.”

Unfortunately, the Interaction Wizard is all but useless. It is far from intuitive and lacks the flexibility an advanced programmer needs. We tried to use it to generate code to place text from an edit control into a choice list when a button is pressed, but the Interaction Wizard doesn’t handle more than two controls. We weren’t giving up so easily. We tried to use the Wizard to add a static item to the list when a button is pressed. No dice. The Interaction Wizard only understands four methods when it comes to list boxes, and adding an item isn’t one of them.

You can place the cursor on a class within your code, click the right mouse button, and select “Browse symbol at cursor” to jump to the class browser. While this is useful, we prefer the approach used by Visual Cafe — sending you to the class library reference. To its credit, the Borland class library reference is often quite good (sometimes more useful than the reference included with Visual Cafe), even if you have to search it manually.

JBuilder surprised us when it squished the application panel down to a mini-square when we reloaded the project (this bug only occurred once during testing). Fortunately, all we had to do was stretch out the panel to approximately its original size and all the components fell right back into place (this is, after all, one of the nice things about using the gridbag layout manager).

JBuilder occasionally refused to load. It would get as far as painting the initial menu and toolbar and then hang. When this happened, we could kill the application and successfully restart it.

Breadth of default palette

Borland JBuilder comes with one of the most extensive default palettes of components.

Visual Age for Java Enterprise Version 1.0

Ease of form creation

IBM Visual Age for Java is somewhat of an enigma when it comes to visual design. It tempts you into thinking that you can arrange components on a gridbag layout visually. But we learned the truth: When you first drop a few components onto a gridbag layout, they are arranged almost at random, which results in a visual mess. However, when you drag a component around the form, a temporary set of grid lines appear. The grid was marginally useful for arranging the order of components, but we couldn’t see any consistent relationship between the way the grid occasionally appears and what we could actually accomplish with it.

We concluded that the best way to lay out a form using the gridbag is to simply drop components on the form and let them land where they may, and then change the gridbag constraints settings for each component. The form reflects the changes you make to the gridbag constraints, so you see the results as you adjust settings in the constraints dialog box.

Like JBuilder, Visual Age for Java lumps the gridbag constraints settings into a single dialog box. Oddly, you can’t resize this window, so you must scroll to see all the gridbag constraints.

Maintainability of form

Although we based our results on the gridbag, we couldn’t help but notice that Visual Age for Java handled other layouts with mixed results. We could move components around on the grid layout, but the tool didn’t give us any choices for grid constraints — it simply presented us with a blank dialog. We were, however, able to visually compose and modify a border layout fairly easily.

To maintain a gridbag form, which is after all the layout we’re most concerned with, you must edit the constraints settings as you make changes.

Visual programming

Visual Age for Java’s Visual Composition editor is the hands-down champion for visual programming. You can use it to create and add very complex behavior to your application without typing a single line of code. The one caveat is that you must learn to think upside down and sideways to use the Visual Composition editor. (Put it this way: People who find the Reverse Polish Notation of an HP calculator easy to handle will probably feel quite comfortable with the Visual Age designer.)

To help you understand what we mean, we’ll work through an example. Imagine that you have a form with three components — a text field, a button, and a list box. You want your program to take the text from a text field and add it to a list at the click of a button. You accomplish this by making various visual connections between components on the form.

First, you right-click on the button on your form. Up pops a context-sensitive menu. Select “Connect” from this menu and then “ActionPerformed” from the submenu that appears. The “ActionPerformed” in this case is the default action for this button — that is, someone clicks on it. At this point, a stretchy line now extends from the button to your mouse pointer. You are expected to “connect” this line (the line now represents the button-click action) to another component.

Here’s where the logic of the visual editor can be confusing. If you think procedurally, the task goes like this.

1. Click button.
2. Get text from text field.
3. Add text as a new item in the list box.

You might be thinking that you should connect the button action to the text field because the next step is to retrieve the text. Nope. You must click the target object (the list box) instead. According to the Visual Composition editor, it is the list box that ultimately receives the effect of the clicked button. It doesn’t care about the text field just yet.

At this point, you should see an arrow connecting the button to the list box. To finish the job, you right-click on the text field. Select “Connect” from the menu, and then select “text” from the submenu. Once again, you have a stretchy line extending from the text field to your mouse pointer, and you’re expected to connect it somewhere.

But where? The button or the list box? Surprise — it’s neither. You connect the line from the text field to the arrow that connects the button to the list box. The result should look something like the figure below.

If you think the above procedure is confusing, imagine trying to retrace your logic by examining a complex form with arrows pointing in every which direction. But as awkward as it sounds, it not only works, it works remarkably well. If you can bend your mind enough to grasp the concepts, it becomes “insanely” easy to wire together interactions between components.

You can create multiple connections between objects, too. And you can visually control the order in which the actions are taken, regardless of the order in which you defined them. In the figure below, you’ll see a form where a click of the button fires the following three consecutive actions:

1. The contents of the text field are added to the list box.
2. The text field is cleared.
3. Focus is returned to the text field.

The following illustration shows what the final application looks like.

Breadth of default palette

IBM is a bit stingy when it comes to delivering a default set of controls, but you get plenty to work with in the Enterprise version. It is, however, very easy to create your own controls and add them to the palette. In addition, Visual Age ships with a lot of optional Java classes that prove useful.

We also appreciate the object factory and generic objects on the palette. These items are essential for complex visual programming tasks. Here’s why. In the first figure of “To-Do list” example, you may have notices a puzzle-piece shaped component called Object1. You can set this object to be almost whatever you want. In our example program, we set it to be an empty Java String object.

Why? As we described in that example, when the user clicks the button, the program adds the text in the text field to the list box. It then sets the contents of the text field to Object1. Because Object1 is an empty string, this action clears the text field.

Visual Cafe for Java Database Development Edition 2.0

Ease of form creation

Symantec Visual Cafe for Java, whether the Professional Edition or the Database Development Edition, is an extremely strong product that has no trouble holding its own against the competition when taken as a whole. Unfortunately, its visual design and programming capabilities — the features we’ve tested here — are its weakest points.

Don’t bother beautifying a form by laying out components in absolute coordinates if there’s a chance you’ll want to convert it to a gridbag layout. The components will all rearrange and resize themselves in ways you neither want nor expect.

Like Visual Age for Java, Visual Cafe for Java doesn’t let you arrange a gridbag layout by visually placing components. You have to drop the components onto the form without regard to where they appear, and then adjust the gridbag constraints for each component manually. Also like Visual Age for Java, the changes you make to the settings are immediately reflected on the form, so at least you get visual feedback to manual changes.

Unlike Visual Age for Java and JBuilder, the gridbag constraints settings appear within the overall component properties window. This isn’t usually a problem, but we found ourselves hunting for various settings more often than with the other products.

Maintainability of form

Whenever you make a change to a gridbag-based form, you need to edit the various gridbag constraints for the components to adapt to your changes. Again, the level of inconvenience is about the same as with Visual Age for Java.

We couldn’t move components around on a form when using the grid layout; however, we found that if we changed the order the components appeared in the project window we could rearrange them on the form. Like Visual Age for Java, we could arrange components directly on the form when using the border layout. But the result was deceiving. Visual Age for Java assigns proper constraints to the components when you arrange them visually on a border layout. Visual Cafe does not. It simply places them at absolute coordinates.

Visual programming

Visual Cafe has an interaction wizard similar to Borland’s JBuilder, but without the limitations. The interaction wizard isn’t as sophisticated or extensible a method of visual coding as in Visual Age for Java, but you can do a lot in Visual Cafe without reaching for the keyboard. And Visual Cafe’s visual programming approach has the merit of being much less difficult to learn than Visual Age for Java.

You access the interaction wizard by right-clicking on a component and selecting the appropriate choice from the menu. We visually programmed our “To-Do list” example with Visual Cafe for Java with ease. As you create interactions via the wizard, Visual Cafe writes the appropriate code.

You can create multiple interactions for any given control. But, unlike the way Visual Age for Java keeps every option visual, you must edit the code it creates manually if you want to rearrange the order in which the actions are taken.

You can select a component from a drop-down list box in the source code editor, and then select an event or method from another drop-down list box. This process takes you right to the code for the method or for handling that event.

If you place the cursor over a class keyword in your code (such as a class definition like GridBagLayout) and press the help (F1) key, Visual Cafe will display the class definition along with the list of methods and properties. From there, you can get to areas of the help system that tell you how to use the class and its methods.

One of the most annoying things we experienced with Visual Cafe is that it often starts up for no apparent reason (we’re not sure, but there may be some connection between these spontaneous launches and actions we take with Netscape Communicator). We suspect this may have less to do with Visual Cafe and more to do with the many side-effects you can experience when you install too many programs under Windows NT.

Breadth of default palette

Visual Cafe for Java has one of the most impressive default palettes of components around.

Feature chart

Nicholas Petreley is editor-in-chief of NC World and columnist
for InfoWorld and NT World Japan.

Source: www.infoworld.com