VisualAge C++ 3.5 for Windows

VisualAge C++ for Windows is a product I could not wait to get my hands on.

So what's the big deal? Parts, cross-platform system object model (SOM)

support, and visual programming.

The core of the VisualAge development product line is a technology called

Parts. Parts are visual components that you build during application

development. What sets Parts apart from other popular forms of visual

components (such as ActiveX controls) is that you don't have to use an SDK to

construct them. What's more, Parts created during the course of building one

project are automatically usable on the next.

VisualAge C++ for Windows also ships with a limited subset of the SOMObjects

2.1 toolkit. It includes the core product, Distributed SOM support, and the

metaclass framework. A downside is that this version of SOM is out of date

(version 3.0 is the latest release). Still, SOM 2.1 is an excellent object

request broker product with broad platform support. I hope to see a VisualAge

C++ upgrade offering SOM 3.0 support.

VisualAge Programming

VisualAge C++ is composed of four main components: the WorkFrame, Visual

Builder, Data Access Builder, and the integrated editor. These tools can all be

used independently but are most effective when used in a specific sequence. The

WorkFrame tool is the center of the VisualAge C++ product. It serves as the

integrated development environment that organizes complete applications into

project hierarchies and links your project elements to the three other main

VisualAge components.

Projects are the core of the WorkFrame environment. Projects group all the

objects you need to build a single program. They are also the mechanism for

creating Parts. Parts are incomplete application components that you can create

as part of an application and later reuse in another application. Physically, a

project is a collection of components and source code arranged in a directory

tree.

The project metaphor was easy to get used to when the application was

simple. However, when I wanted to include an existing Part in another project,

I was easily confused. It takes a lot of manual effort to stitch together a

project that uses existing components. You have to know locations, file names,

the right tool, and the right time in a specific sequence to add a component to

a project. Some of this confusion is clearly due to the learning curve.

Starting a new project is easy. You start WorkFrame, choose Create New

Project, and a wizard called Project Smarts starts up. Project Smarts prompts

you for project type and location information, as well as specialized

information depending on the project type you selected. It supports 14 basic

project types, ranging from a "Hello World" program in plain old C or C++ to

distributed components using direct-to-SOM capabilities.

I chose the Visual Data Access project type because it let me test the new

ODBC support in the Database Access Builder. The Project Smarts wizard created

a WorkFrame 3.5 project window consisting of a simple file list coupled with a

project control toolbar and tool-specific menus. This window contained a

README.TXT file plus three other files. One of the files turned out to be a

subproject that is reserved for creating database access components.

I didn't know how to proceed from this point. First I tried to compile a

skeletal project, but the compile status window indicated that I had not

created enough of the project to proceed with a build. Next I tried to edit

each of the files displayed in the project window, but that didn't get me

anywhere. Eventually, after poking around, I decided to examine the README.TXT

file in the WorkFrame project window. This was the right thing to do.

The README.TXT file turns out to be a detailed set of project-specific

instructions that you must follow and is created in every project Project

Smarts generates. It contains instructions on how to proceed, and its contents

are based on the selections you make while working with the wizard.

The file directed me to work with the subproject first. This project starts

out empty, but you use it to access the Data Access Builder. It's a little

tricky creating the Part that wraps the database tables you want to work with,

but since these are supposed to be reusable, a little extra effort balances

out. After generating the classes for the Part, you exit the Data Access

Builder. This leaves you back in the empty subproject window, which was less

than comforting at first. This emptiness is resolved after the project is

compiled.

Next, I moved to the Visual Builder. I had to specify the name of each

visual component and standard subcomponent of my application. This lack of

integration is frustrating. As I had previously generated the project, I

expected the wizard to have this information already. This rough edge is

unfortunate because Visual Builder and its Composition Editor are the real

power behind VisualAge C++.

From here, the instructions tell you to load two files into Visual Builder

and import the data access library that was created in the subproject.

The Fun Begins

Once you are in the Composition Editor, programming becomes entirely visual.

The Composition Editor lets you combine components. The README.TXT file

instructed me to select a Part named Sample, which turned out to be a data

lookup application framework constructed from other Parts. This building block

approach is exciting--you add various Parts to the Composition Editor screen

and then connect them to each other or to other connections. Eventually you

have an assembly of connected Parts that you can save for later reuse as Parts

themselves.

Connections between Parts are made visually by accessing the pop-up context

menus that are attached to all Visual Builder Parts. Each Part has a context

menu item titled "Connect." Selecting this menu item causes a submenu to appear

next to the original context menu. This connection menu displays the attributes

that are available for making connections.

As soon as you select an attribute, your mouse pointer turns into a spider

shape with a silk extending from the spider to the Part you just connected to.

To connect the selected Part to another one, you simply move the spider over

the top of the Part to be connected and click. This displays the connection

menu belonging to this part, from which you select the appropriate attribute. I

find that in most cases, connecting to the attribute named "this" is often all

that is required to make a connection. The "this" attribute refers to the part

itself, and lets you think about program connections quite naturally.

Finishing up the database lookup application involves adding the Parts

created in the subproject to the Composition Editor screen, then connecting

those Parts to the sample program framework. The instructions in the README.TXT

file tell you what to do, although I found the terminology a little confusing.

Some careful reading is also required to make the connections, but if you read

what appears on the screen in response to the printed instructions, it begins

to make sense.

Hurry Up and Wait

The code generation was quite fast, although only 10 files were created

during this step. The real waiting began when I instructed the Visual Builder

to compile the project. Despite the claims of being a high-speed optimizing

compiler, I found the compile times arduous: this simple application took more

than 10 minutes.

During my first compile cycle, the build status window reported a syntax

error. I double-clicked on the error message and was brought to the offending

line. The error message tipped me off to a spot where I had mistyped a class

name in the Composition Editor. I went back to it and fixed the problem, saved,

and recompiled. Five minutes later, the same error message indicated an error

on the same line. Apparently you have to regenerate your code after making

changes in the Composition Editor. This points out a flaw in the product:

having to regenerate code implies that you are not expected to manually edit

generated files. I looked at the files themselves and found the code to be

quite understandable, but I saw no trace of the typical "add your code here"

comment blocks.

Finally, after another lengthy recompile cycle, I had a working executable.

Having had the opportunity to watch several compiles, I noted that VisualAge

C++ skips compiling up-to-date program elements but spends a lot of time

regenerating makefiles and doing dependency checks. This is abnormal

performance for my test machine, with its 32MB of memory and dual 32-bit PCI

disk channels. Lengthy compiles take the C++ crowd back to the days of

overnight batch processing for some projects, and compiler speed is an

important productivity factor.

A Diamond in the Rough

VisualAge C++ has all of the earmarks of a good tool that was rushed out the

door a wee bit early. The core of the product is first-rate. The visual

programming and Parts metaphor is exciting. In all of my weeks of testing

various sample programs and exploring the online tutorial and reference

material, I experienced only one memory fault condition.

The address book test program I've described here yielded a reusable data

access part that made creating a separate data maintenance tool a snap. SOM

support under all the widely used Windows platforms opens the door to a host of

integration solutions. Support for both OLE and OpenDoc compound documents and

cross-platform program portability features are hallmarks of a truly versatile

tool.

Not unnoticed are improvements to the product line, like ODBC database

access support, easy-to-find direct-to-SOM, and the ability to generate either

C++ parts code or CORBA IDL interface definitions. Still, a few really rough

edges tarnish the product. The most serious is Project Smarts; this tool isn't

finished. The steps that are documented in the customized README.TXT

instruction files should have been fully automated actions performed by the

wizard.

Another serious blemish is the incomplete installation program that leaves

the sample programs unusable. The README.TXT file on the CD-ROM explains that

the samples are only properly installed if the "typical" option is selected

during the initial setup. In my book, the 365MB hit on your hard drive is a

good reason not to install that much data and instead choose a lighter-weight

option. Disabling the sample programs and requiring a lengthy manual patch

isn't acceptable. The sample programs are an essential part of the product

learning curve. Finally, my vote for most-annoying feature goes to the

installation logic that trashed my healthy ODBC driver setup and left me unable

to use my databases.

Pros and Cons

PROS:

1. The Parts technology increases productivity and reuse at the same time by

   simplifying C++ development.

2. IBM System Object Model (SOM) 2.1 for Windows and the direct-to-SOM code

   generation bring a CORBA-compliant ORB to Windows 3.1, Windows, 95 and Windows

   NT.

3. The VisualAge C++ product line is available on MVS, AIX, OS/400, OS/2, and

   all Windows platforms.

CONS:

1. The Project Smarts wizard generates partial project skeletons that require

   the programmer to complete the project setup and initial coding steps.

2. The installation program neglects to configure the sample and tutorial

   applications and damages existing ODBC configurations under Windows NT.

3. The online documentation is voluminous but poorly organized. It is

   difficult for someone new to the product to figure out where to start.

Company Information

IBM Corp.

1150 Eglinton Ave. E.

North York, Ontario

M3C 1H7 Canada

Tel: (800) 426-2255

Web: http://www.software.hosting.ibm.com/ad/cset/windows/vacwin.html

Price: $489, or $339 for competitive upgrade from another Windows

compiler

Software Requirements: Windows 95 or Windows NT 3.51

Hardware Requirements: 486 or higher, 20MB RAM, 400MB disk space

recommended

Technical Support: 60 days free telephone support

Money-Back Policy: 30-day guarantee