Sybase's PowerJ and IBM's VisualAge

One of the most frequently asked questions about Java is: "Is it good enough for developing mission-critical enterprise applications?" If you ask Microsoft, the answer is "certainly not." (See the licensing agreement that comes with any Microsoft product these days.) If you ask hard-core Java enthusiasts, the answer is "of course." If you ask Joe Developer, you'll probably find that he's optimistic that he will develop mission-critical applications in Java someday, but not just yet.

This indicates that there is still a Java problem. The problem with Java today isn't the language itself. Everything about Java is built for creating efficient, safe, distributed applications. Thus, the problem must lie either within the virtual machines that run Java, or in the development environments. Java Virtual Machines have become much faster lately-to the point where, with a just-in-time compiler, they're quick enough for most distributed applications, as long as the hardware on which they run is modern. This leaves development environments as the cause of the Java concern.

I'd like to propose that the lack of serious and mature RAD tools for enterprise Sun Java (as opposed to Microsoft Java) development has been the main factor behind what I call the Java question. The Java question is not unlike the Linux question. In both cases, a superior technology to Microsoft's solution is being adopted by the corporate world, but adoption is considered a risky move and is proceeding slowly. The question is: Is it ready for wide-scale enterprise use? The answer is: "I don't care how good it is, show me how it will make my job easier, then tell me I don't have to learn or give up anything." The second releases of Sybase's PowerJ and IBM's VisualAge for Java have the potential to provide a solution to the Java problem for skeptical C++ programmers. Both of these tools are mature development environments, sporting features on par with the best non-Java development environments, while still providing "comfort features" for beginners, such as drag-and-drop programming.

PowerJ 2.5

PowerJ is more than a Java development environment-it's a complete enterprise Java web application environment. Included with PowerJ Enterprise is PowerSite (Sybase's web development tool), a development version of PowerDynamo (Sybase's web application server), a development version of Jaguar CTS (Sybase's transaction server), and PowerDesigner AppModeler (a database modeling and generation tool).

PowerJ is a flexible tool. It supports future releases of the JDK (simply plug them in), Enterprise Java Beans, ActiveX components, CORBA, Swing, Microsoft's SDK for Java 1.5 and 2.0, JDBC, IIOP and DCOM, and RMI.

PowerJ has lower-level drag-and-drop features than most of the Java tools I've worked with. At the heart of PowerJ's drag-and-drop functionality is the Reference Card. The Reference Card screen is accessed through the Help menu and displays information, gathered using introspection, about the available Java Beans and their methods and properties. After creating an interface for your applet or application in the GUI design window, you can either open the code window to manually write code, or you can right-click on a component to select an event. Selecting an event brings up the code window with the cursor inside a skeleton of the event handler routine. You can drag components from the interface onto the code window. The Reference Card then appears, displaying information about the component you're working with. You can use the Reference Card to choose the method or property you want, then set parameters by filling in blanks in the parameter wizard. PowerJ generates the necessary code and inserts it into the code window at the point where you initially dragged the component.

This visual programming may be confusing at first for Java programmers accustomed to more graphically oriented tools. PowerJ gives no clues in the interface window about the connections between components. You must either remember what you've done already, or browse through the code. For experienced developers, drawing lines between components in the interface window may not be the most efficient way to program, but I'm used to seeing more than just the interface in the interface design window.

Besides its drag-and-drop abilities, PowerJ's code editor includes find and replace using pattern matching, unlimited undo, color syntax highlighting, auto indenting, and debugging control. The editor has two modes: the "big editor" and the "small editor." The big editor mode is the default mode, and shows all of the code associated with the current form. The small editor mode only shows the code for a single event handler. You can set breakpoints in the editor by double-clicking on the icon at the beginning of a line or by right-clicking and selecting the Toggle Breakpoint command. The breakpoints are represented by red stop signs in your code, or you can view and modify all of your program's breakpoints in the breakpoint dialog box.

PowerJ comes with sophisticated debugging features including the Call Stack window and commands; the Locals window, which displays all the local variables defined in the currently executing function; the Watches window, which displays the current value of all the watch expressions; the Assembly window, which displays an assembly language version of executable code in your program (if you're using Microsoft's Virtual Machine); the Registers window, which displays the contents of the Java interpreter's virtual registers at the time execution was suspended; the Threads window; and the Memory window.

If you're new to Java and tend to rely on drag-and-drop tools, PowerJ might not be the ideal tool for you. Dragging components from the interface to the code window requires a good deal of resizing windows and moving windows around so the right ones are visible, which becomes tiresome. For more experienced developers, though, PowerJ features the right mix of a full-featured code editor, good documentation and debugging tools, and a flexible, expandable, and customizable workspace.

VisualAge for Java 2.0, Enterprise Edition

VisualAge for Java is a RAD tool for developing Enterprise Java applets, Beans, and applications. But it's not for the weak computer. It's a resource hog. It occupies an enormous amount of disk space, and felt sluggish on my 300MHz Pentium II with 128MB RAM. If you feel your computer is up to the task, though, VisualAge is a powerful tool.

VisualAge for Java's most unique feature is its built-in repository, where all of your project's files are saved. For beginning Java developers, there is no need to worry about where to save files and no chance of breaking a project through accidental overwriting or file misplacement. The built-in repository also provides version control features, and is ideal for team development.

VisualAge for Java's Visual Composition Editor is the main work area. It lets you place, arrange, and connect visual and nonvisual Java Beans. To connect Beans, you draw lines between graphical representations of the Beans, then specify events and actions. You can size and align tools for a precise layout of your project's interface components. Much better than most development environments' interface layout tools, the Visual Composition Editor lets you align, distribute, and make objects the same width or height by selecting multiple components and clicking on the appropriate button in the toolbar.

You can make connections between components visually or you can use the Event-To-Code window to code event handlers. The Event-to-Code window is a code editor in which you can write methods for events selected in the Visual Composition Editor. After you've finished writing an event handler, it is shown in the Visual Composition Editor along with its connections to other components.

The Visual Composition Editor features unlimited undo from the last time you opened it. Because VisualAge automatically opens the project you were working on when you last quit the program, I expected that I could undo or redo changes made during prior work sessions. But, alas, this is not possible. A running list of everything done to a project since its creation would be a nice feature; it would seem natural, given that projects are already stored in a database. Considering the vastness of VisualAge and the system resources it consumes, this would be good insurance against the possibility that you might be forced to restart your system at some point.

VisualAge for Java's debugger has all the standard features, but it's not as comprehensive as PowerJ's debugger. It lets you set conditional breakpoint, step through the code, and view and modify variables.

You can use the Workbench window to manage VisualAge for Java projects. The Workbench displays a hierarchical view of all the available projects, packages, classes, and interfaces. You can use it to view your project's code and structure, add elements to your project, and create new projects.

For team development environments, VisualAge lets you define groups and assign ownership from the project level down to the class level. For example, the project manager has control and is the only one able to create new versions of the project. The team leader might have ownership of the packages, and the programmers would have ownership of the classes in those packages. When a class is complete, the programmers check it into the package, then the team lead checks in the package, and the project lead versions the project-creating a new baseline for the project and synchronizing the code. VisualAge's Repository Explorer lets designated developers administer VisualAge clients. Using the Repository Explorer, these developers can add, edit, and delete users and groups. The main purpose of the Repository Explorer is to browse through projects, editions of projects, packages, and types. You can search the repository for certain elements (constructors, fields, text, or methods, for example), within a specified scope (workspace, project, or package), and by use (whether you're looking for a string in a reference, declaration, or both).

For accessing enterprise data, VisualAge for Java's Enterprise Edition provides Access Builders. Access Builders generate Java Beans that you can use in the Visual Composition Editor to connect data to your user interface. You can use the standard Data Access Builder to connect to relational data sources through JDBC. The Data Access Builder SmartGuide is basically a wizard that walks you through creating a schema mapping (a set of definitions for all attributes matching all the columns in your database table, view, or SQL statement). You can then view and customize this generated schema mapping. When you are finished, Data Access Builder will create a data access Java Bean and a basic GUI interface for it.

The other Access Builders that come with VisualAge for Java's Enterprise Edition are: RMI Access Builder, for creating distributed applications using RMI; C++ Access Builder, which lets your Java applets, Beans, or applications access C++ libraries; Access Builder for SAP R/3, which you can use to create Java applications, Java Beans, and applets that access an SAP system; IDL Development Environment, for creating CORBA-compliant applications; and Persistence Builder, which provides persistence support for object models.

VisualAge also includes a servlet builder. Servlets are server-side Java applications that dynamically create HTML pages in response to HTTP requests. Using server-side Java applications to create web applications is currently Java's most common use on the Internet.

Because VisualAge doesn't use your computer's file system, you have to use the export wizard when you want to use VisualAge code outside of the environment. The export wizard lets you export the source, class files, and resources to a directory, or you can export to a Java Archive (JAR) file. VisualAge can also create an HTML file for opening exported applets. You can bring directories, JAR files, or repositories from the file system into VisualAge for Java's repository by using the Import command.

VisualAge for Java has improved a great deal since version 1.0. With VisualAge's team development features, its ability to easily connect to a variety of enterprise data sources, and its well thought out interface, it's clear that IBM has the technology and the will to bring Java to the masses of mission-critical projects.

PowerJ and VisualAge for Java both support the latest Java standards and offer plenty of help for Java newcomers as well as for relative newcomers to new Java technologies (for example, Swing, RMI, and Enterprise Java Beans). For those shops contemplating embarking on their first Java project, both products are based on familiar and well-respected development environments from two of the heavyweights in enterprise development. PowerJ's debugging features and full-featured code editor, as well as the Sybase web development and database tools which are bundled with it, make it an ideal tool for developers with at least some Java experience and for web developers. VisualAge's more graphically oriented environment, although not easy to learn, certainly isolates beginners from the code better than PowerJ. VisualAge's team development features, including the repository and built-in source control make it ideal for team development. VisualAge's Data Access Builders make it the perfect tool for creating Java interfaces to legacy data. Now that these tools have matured to their second versions, the time is right for skeptical organizations to make the move from evaluating the possibility of Java development to actually reaping the rewards of the improved reusability, decreased time to market, and cross-platform deployment that Java offers.