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 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
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
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
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
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"
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
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
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.
RATING: * * *
|The Rate Sheet|
- The Parts technology increases productivity and reuse at the same time by
simplifying C++ development.
- 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
- The VisualAge C++ product line is available on MVS, AIX, OS/400, OS/2, and
all Windows platforms.
- The Project Smarts wizard generates partial project skeletons that require
the programmer to complete the project setup and initial coding steps.
- The installation program neglects to configure the sample and tutorial
applications and damages existing ODBC configurations under Windows NT.
- The online documentation is voluminous but poorly organized. It is
difficult for someone new to the product to figure out where to start.
1150 Eglinton Ave. E.
North York, Ontario
M3C 1H7 Canada
Tel: (800) 426-2255
Price: $489, or $339 for competitive upgrade from another Windows
Software Requirements: Windows 95 or Windows NT 3.51
Hardware Requirements: 486 or higher, 20MB RAM, 400MB disk space
Technical Support: 60 days free telephone support
Money-Back Policy: 30-day guarantee