From: owner-visualprog@scribe.cerf.net
Date: Wed, 24 Jul 1996 03:05:24 +0800
To: visualprog@scribe.cerf.net
Subject: No Subject
Message-ID: <199607222332.QAA16327@smtp2.cerf.net>
MIME-Version: 1.0
Content-Type: text/plain



VISUAL PROGRAMMING++

The biweekly newsletter featuring reviews for Windows development products and
Internet/Intranet tools.
VP++ is free to Visual Basic Programmer's Journal subscribers and premier club
members of FTP's Development Exchange web site: http://www.windx.com.

Vol. 1 No. 1
July 12, 1996

Welcome to the premiere issue of Visual Programming++, an e-mail newsletter
providing timely reviews of Windows components, utilities, add-on products and
Internet/Intranet development tools. 
	This premiere issue is being sent to every registered member of The
Development Exchange Web site (DevX). All future issues will be sent as a
service only to paid subscribers of either Visual Basic Programmer's Journal or
DevX's new Premier Club. To subscribe or unsubscribe, follow the instructions at
the end of this document. Every issue will be posted under "Reviews" on DevX.
	VP++ is a part of the totally re-designed DevX Web site. Explore DevX and
you'll see complete archives of articles and code from Visual Basic Programmer's
Journal and Microsoft Interactive Development, plus a database of more than
5,000 Windows development tools updated daily. You'll also see an event calendar
that covers all major trade shows for developers, including details on our
VBITS:Interactive, coming to San Francisco in October. 
	The VP++ charter includes reviewing products for VB, VB Script,
Access/Jet, VC++, Delphi, PowerBuilder, the Microsoft Internet Explorer,
Netscape's Navigator and other tools. Every two weeks subscribers receive
detailed reviews automatically delivered by e-mail.
	Utilities form a theme for this issue. All products are shipping--no beta
software was reviewed. We'll maintain a product review archive on our web site
as we add new editions of VP++. You can search for product information using key
words. For Premiere Club members, we have a bulletin board in the Reviews
section of the Developer's Exchange. You can discuss these reviews or products
there.
	Not only are venders offering demos on web sites, but some reviewers have
posted sample code on web sites as well. I hope you find these reviews useful.
Send questions or comments to editor Frank_Moncrief@MSN.com or
70443.1434@CompuServe.com.

8 PRODUCTS REVIEWED

CONTENTS 
* VBNet 2.01: Automatically converts VB code and forms to VB Script. 
* CodeBank: VB routines you can plug into your own code or share across teams. 
* PowerDoc: Automated documentation generator. 
* IDSMail: OLE server for building email into applications. 
* Total Access Agent: Repair, backup and compacting utility for Access and
VB/Jet databases. 
* DynamiCube 1.31: 32-bit data-bound ActiveX custom control for On-Line
Analytical Processing.
* VB Compress Pro 4.03: Automatically deletes unused or un-referenced code.
* Visual SQL 4.0: Code generator and class library that turns Microsoft Visual
C++ into a client/server development environment.
*Subscribe/Unsubscribe 

------------------------------------------------------------------------

VBNet 2.01 

TVObjects Corporation 
Tel: 609 514-1444 
Fax: 609 514-1004 
http://www.tvobjects.com 
Price: $197 
Runtime: not applicable 
Quick Facts: VBNet 2.01 is a VB4 add-in that uses a wizard to convert VB4 forms
into HTML pages with embedded VB Script code. 

By John Clark Craig 
VBNet is a Visual Basic 4.0 add-in that turns VB4 into an environment for
developing HTML pages with embedded VB Script code. The add-in provides a wizard
that walks you through the automatic steps of converting each of the Visual
Basic forms in your VB 4.0 project into a set of equivalent HTML pages
containing embedded VB Script code that is executed directly by Microsoft's
Internet Explorer 3.0. You can even convert ODBC-compliant client/server
database applications this way. VB Script code is developed right in HTML
pages-there isn't any Integrated Development Environment (IDE) for VBS. Hence,
you can create your app using VB's rich IDE during development (where you can
use the debugger, for example), then you just do the conversion to VB Script
using VBNet. 
	You can do this tedious conversion chore by hand, but believe me, VBNet
simplifies this task quite a bit. While reviewing VBNet, I created a few simple
VB 4.0 applications using the new, restricted VB Script syntax and let VBNet do
its thing to them. I learned a lot about the way VB Script works by studying the
resulting HTML pages created by VBNet, and I realized that even though VB Script
follows a simplified Visual Basic 4.0 syntax, the details of reworking
applications into embedded VB Script code for web pages is more complicated and
exacting than I expected. VBNet handles these details with ease. 
	Here's how it works. You start by developing a working Visual Basic 4.0
application that runs successfully in the Visual Basic development environment,
purposely using the restricted syntax of VB Script. As just one example of this
new syntax, the only variable type allowed in VB Script is the Variant, so
you'll need to edit out the dollar signs from the end of string variable names,
and you'll need to be more explicit in the use of type conversion functions. To
convert existing VB programs, you need to edit variables to conform to VB Script
conventions. (Some helpful documents that cover all the new VB Script syntax
exist on Microsoft's web pages-http://www.microsoft.com/VBScript is the main VB
Script page. There are links to complete documentation, an online tutorial, FAQ
documents, sample VB Script pages, and more).

MAKING THE CONVERSION 
When you're ready to convert your application to HTML pages, you start the VBNet
wizard from VB's Add-In menu. VBNet automatically creates a folder hierarchy
based on your application's name, and populates these folders with the all the
files required for rebuilding the application in the user's browser. VBNet
converts standard buttons, check boxes, text boxes, and many other controls. To
test VBNet for converting third-party controls, I added a Sheridan Software
Tabbed Dialog and it worked. Any controls should be registered on the user's
system. Microsoft provides a set of free downloadable ActiveX controls that are
designed specifically for use with VB Script within IE3. These controls
duplicate the command button, text box, check box, and a few other standard VB4
controls. The set also includes IE Stock Ticker, IE Chart, IE Animated Button
and others. 
	As the conversion proceeds, VBNet generates a report you can view or
print. This report describes any parts of your Visual Basic application that
fail to translate to VB Script, and provides other useful information about the
conversion process. 
	I created an example VB Script application using VBNet that you can
browse at http://home.sprynet.com/sprynet/jccraig using IE3. Be sure to
right-click and select View Source so you can study the actual lines of code
that VBNet created as it converted this simple random-password-generation
application from VB 4.0 to VB Script. Also, TVObjects offers example VB Script
enhanced pages, product information and the latest downloadable updates at its
home pages: http://www.tvobjects.com. 
	You can build powerful ODBC-compliant client/server database applications
for use over the Internet using VBNet and the RemoteData control, available in
the Enterprise edition of VB 4.0. Hence, users can interact with data on your
company's Intranet, for example. You simply add controls to your form that can
be bound to your RemoteData control, get them working in the Visual Basic 4.0
environment, and convert it all using VBNet to enable deployment over the net.
Also, VBNet can generate JavaScript code for database compliant access with
Netscape 2.0. For security reasons, VB Script doesn't allow normal file I/O, but
the remote data capability more than makes up for this limitation. 
	VBNet is a great product. I just wish VBNet had a little tighter
integration with the Visual Basic 4.0 development environment. The syntax
checking for proper VB Script syntax works great, but only during the wizard's
conversion processing. What I'd like to see is immediate feedback as I enter
each line to let me know right away if I'm using a feature of Visual Basic 4.0
that's not allowed in VB Script.

John Clark Craig is the author of more than a dozen books on computer
programming, including The Microsoft Visual Basic 4.0 Developer's Workshop
(Microsoft Press, 1996). Craig lives with his family in Castle Rock, Colorado.
Email: jccraig@sprynet.com; Web: http://home.sprynet.com/sprynet/jccraig

------------------------------------------------------------------------

CodeBank 

Visual Components, Inc. 
Tel: 913 599-6500 
Fax: 913 599-6597 
http://www.visualcomp.com/ 
Sales@visualcomp.com 
Price: $99.00 
Runtime: not applicable 
Quick Facts: CodeBank makes it easy to store, update and manage Visual Basic 4.0
procedures for individual or multi-programmer development teams.

By David McCarter 
CodeBank is a system for storing re-usable code or for sharing routines with
other developers in your group. Sure, you can create massive, generic modules
that can be attached to every project, but this would waste space in your EXE
and bloat memory requirements. Using CodeBank, you can choose only the subs and
functions your project needs and add them to specific modules. While I think
there are a few kinks that need to be ironed out in this first version, it's off
to a great start. 
	CodeBank includes 163 subs and functions (procedures) ready for use in
your projects. The program displays a list of available procedures organized in
categories in an expandable tree box. Categories include graphic effects, text
effects, status bar control and others. Some of the 163 procedures include
rotate text, gradient background and elastic forms. Simply click on a category
and browse the procedures in it. You can also view procedures by procedure name,
type (sub or function) or author. Clicking on a procedure will show a sample of
how the procedure works in a different window. Double clicking on a routine will
bring up the editing window. By default, you can't edit the canned routines in
order to protect the archive. However, you can make copies of routines
(maintaining all dependencies), then edit them and save them with a different
names. A tabbed form contains all the information for the procedures, including
category name, whether it's a sub or function, description, instructions, code,
sample calls, revision history, and links to API calls or other procedures and
forms need for the procedure. 
	I must warn you that the majority of the stock 163 procedures are
graphically oriented. While this is great for those of you looking for ways of
doing really cool graphic tricks in VB without using a VBX or OCX, I would like
more general-use procedures in CodeBank. However, you can purchase CodeBank to
share code among your development team instead of for the canned procedures. 
	As you find procedures needed in your program, click on an Include button
to add them to a new or existing module file created with CodeBank. These
procedures are listed in a window under the module file name. Of course, you can
also remove these procedures. Consider this window your shopping basket. 
	When you are done selecting procedures, all you have to do is click on
the Make Module button and the module is created in just a few seconds.
Impressively, CodeBank automatically adds any required API calls and procedures.
This beats the copy and paste method hands down! Also, a message box informs you
of any forms you need to add to your project. 
	CodeBank offers an Update All Basic Modules feature for efficient
updating. CodeBank keeps a record of all procedures and API calls added to a
module. So if these procedures are modified at a later date, simply use this
feature to update your modules. It's a snap! 

IRONING OUT THE KINKS 
In my experience, CodeBank has a few kinks that need to be ironed out to make it
a more productive, useful tool. I tested 15 of the procedures that came with the
program, including graphic, form, toolbar and file dialog procedures. I found
one routine that didn't work correctly: UnloadAllForms. It crashed VB because it
did not take into account that it can't be called from a form that is already
being unloaded. Also, most of the procedures are poorly documented. The
beginning of the procedures need better commenting on how to use them and which
parameters to choose. And commenting is displayed on one long line, so I had to
scroll to read the entire comment. This is not a standard commenting practice.
The code itself could use better commenting. 
	There were a few other things that bothered me. I could not maximize the
main program window to view more categories and procedures simultaneously. Also,
code is stored in an Access database. I'm not sure of the reason for this
because it's used as a flat database. Access has a reputation for high memory
overhead (the database of 163 procedures is 622K), and for corrupting in my
experience. I think it'd be better to store routines in a flat ASCII file
system. Also, there seems to be no compression, backup or error checking
features in CodeBank for the Access database. 
	CodeBank comes in both 16- and 32-bit versions. It only creates VB4
modules (though you could translate some of the code to VB 3.0). It can also
import other CodeBank files or a specially tagged ASCII file (I did not have any
samples to test this feature). The program comes with sample projects that show
off a majority of the included routines.

David McCarter is editor and publisher of the electronic newsletter Visual Basic
Tips & Tricks. He works at an interactive television and wagering company, and
has his own software publishing/consulting firm. Contact him at
74777.447@compuserve.com.

------------------------------------------------------------------------

PowerDOC for Visual Basic 

Catapult Systems 
Tel: 800 581-7354 
Tel: 512 328-8181 
Fax: 512 328-0854 (fax) 
http://www.launch.com 
PowerDoc@Launch.COM 
Price $79.00 
Runtime: not applicable 
Quick Facts: Powerdoc automatically creates VB documentation using Microsoft
Word. A demo version is available on the web site, which can be upgraded to full
version via registration.

By Craig M. Bobchin 
If you are a typical developer you probably dread the thought of writing
documentation. And if you have to work on a system written by anyone else, you
may be cursing the lack of documentation. If these scenarios sound familiar, you
may want to check out PowerDOC. 
	PowerDOC works with Microsoft Word 6.0c or 7 to automatically create
technical documentation for VB3 or VB4 apps. It handles third-party custom
controls by default. I tested PowerDOC with Sheridan, Crescent, and Apex and
Farpoint custom controls with no problems. You can set options to document a few
types of controls, such as text boxes and labels, or you can document all
properties of every control in your app. Also, PowerDOC creates screen captures
of forms in black and white, 16- or 256-colors. 
	PowerDoc offers an easy installation with plenty of user control as to
where the program installs, including drive, directory, and program group.
However, you must have VB3 or VB4 on your system before PowerDOC will install. 
	The utility is easy to use. Select the project you want to document,
determine the level of detail by selecting which controls, properties, events,
and modules you want to document, set a few other options, such as where you
want the resulting file to be stored and if you want a table of contents and
index, and PowerDOC does the rest.

SELECTING OPTIONS 
PowerDOC offers a 3-tabbed interface that leads you through the steps for
documenting your application. The first tab, Select Application, lets you select
the VB project you want to document. After selecting the project in the normal
Open File dialog, PowerDOC presents a list of forms and modules to be
documented. You can select as many or as few as you want to document. You can
then sort the items by name or type, or keep them in the order they are in the
project. 
	The next tab, Select Output, lets you choose projects, forms, classes,
and modules. Each selection gives you several check boxes showing which portions
of the objects you can document. Pressing the Advanced button on this tab lets
you select which control types and properties you want to document, as well as
how you want any screen captures stored. 
	I documented an entire application with 14 forms and 3 modules. The app
had approximately 100 controls and about 5,000 lines of code. I documented all
controls and objects, and the resulting Word document was 374 pages. You can
customize the scope and size of your documentation by either not documenting the
entire system, or by selecting which pages you want to print. 
	The last tab, Customize Word, lets you customize Word options and
settings, such as generating a table of contents and index, and determining
their style.

MINOR ANNOYANCES 
When you press the Document button, PowerDOC launches VB with your application
loaded. Documenting a VB4 app works fine. However if you try to document a VB3
project using VB4, a message states that you must first save the project in VB4
format before you can run PowerDOC. If you have both VB3 and VB4, you can
specify which version of VB you want to use. 
	The second minor glitch shows up if you already have Word open. In this
case you get a message asking you to close Word and try documenting again. 
	Performance is adequate: it took about 20 minutes on my P90 with 24 MB of
RAM to document my test application. Your time will vary based on the size of
your application, the level of detail you want and the power of your machine. 
	PowerDOC comes with a 30 page manual that assumes you have the knowledge
to install the product. The manual does a good job of explaining the program and
how to use it. The manual covers topics ranging from a step-by-step tutorial to
a trouble shooting guide of frequently asked questions (FAQ). The help file is
similar to the manual in scope and content. 
	Overall, I like PowerDOC. It does what it is supposed to with a minimum
amount of fuss. I expect that most developers can live with the minor annoyances
I described. I say get this program if you need to document your Visual Basic
applications.

Craig Bobchin is president and founder of CMB Systems Design, a microcomputer
consulting firm specializing in application development and training. He has
written more than 150 articles and Powerpoint 4.0 for Windows QuickStart (Que).
Cbobchin@aol.com or 102142,3336@CompuServe.com. 

------------------------------------------------------------------------

IDSMail 2.1 

Intuitive Data Solutions 
Tel: 408 778-1376 
Fax: 408 776-1267 
http://www.kudonet.com/~ids 
ids@kudonet.com 
Price: Standard Edition: $295 (send mail only), Professional Edition: $495 
(send and receive mail) 
Size: 460K (total for all DLLs for all mail systems) 
Runtime: licensing required only when distributing more than 100 copies external
to your company. 
Quick Facts: An OLE Server that supports major E-mail protocols and provides
e-mail services under any version of Windows for any tool that supports OLE
automation. Download sample code: http://www.kudonet.com/~ids/idsmprog.htm. 

By Peter Vogel 
Electronic mail is becoming a necessity rather than an option. IDSMail lets your
apps send and receive mail using any version of Windows across four mail
systems: MAPI, VIM, MHS, and Vines. You can even download a VB program from the
company's website showing how IDSMail makes your mail system accessible from the
Internet (though the package does not support the Internet mail protocols: POP3
and SMTP). 
	If VB's MAPI control satisfies your email requirements, you don't need
IDSMail. However, if you must support multiple types of systems (MAPI, VIM, MHS
and Vines), or you want to extend the mail capabilities of Excel and Access
under Windows 3.1, then I recommend IDSMAIL. 
	IDSMail comes as a 16-bit OLE server, hence it works with any tool that
supports OLE Automation under Windows 3.1 or Windows 95. I had no problems
installing IDSMail on either version of Windows. Ten minutes after starting up
VB4 and copying some code from the help file, I had a mail application running.
The brief Windows help file is the only documentation provided; it seems
complete and I found only a few minor inaccuracies (some VB3 code labeled as
VB4, for instance). The help file and additional sample code can be downloaded
from the IDS website. IDSMail used only 2% to 3% of my system's resources when
running, but while the documentation doesn't indicate it, I found I didn't get
all of those resources back unless I set my program's reference for IDSMail to
Nothing after use. Performance was acceptable even on a 33mz 486 with 16MB of
RAM with Excel 5.0 using the server and Access 2.0 or Word 6.0 loaded.

WEIGHING THE PROS & CONS 
The product has some neat extensions to MAPI: you can specify how many messages
you want to retrieve, prevent attachments from being copied to your disk, build
an array of message headers or text for search purposes, and read messages
without flagging them as having been read. On the other hand, compared to VB's
MAPI controls, you give up some things. These include single methods for
forwarding, copying, and replying to messages, the ability to customize the
address book dialog, and message types. While I found some activities (notably
logging in) simpler, some activities (like reviewing the recipients list) were
more awkward. Obviously, in providing a universal mail server, IDS had to decide
which features they were willing to support across all protocols. Even so, not
all of IDSMail's functionality is available for all mail systems. There are
dozens of properties and methods supported by IDS across different systems, and
sorting through which functions are supported on which systems is beyond the
scope and length of this review. 
	If portability matters to you, you'll want to review the help file's
Implementing Truly Universal Email topic. Most of the recommendations are made
to ensure consistency as you move from one mail system to another. For instance,
IDS suggests that you always use IDSMail's Mail Send dialog, though this means
losing the functionality of the native dialogs provided with VIM and MAPI. IDS
also recommends not using folders because they are not supported under MAPI, and
using PeekOnly is discouraged because it isn't supported by MHS. While these are
all useful tips, their recommendation to not use the NameResolution property is
not a good idea if you might be working with a MAPI compliant system. 
	If you follow the advice to leave NameResolution set to false, you'll
encounter a problem with users whose display names are similar under MAPI. MAPI
considers Jane Smith to be an ambiguous name compared to Jane Smith-Jones, and
it won't send mail to the display name Jane Smith. You can use the ResolveName
action to retrieve Jane Smith's unique mail address to solve this problem with
the MAPI VBX. Unfortunately, IDSMail's ResolveName method just returns the still
ambiguous display name. Setting IDSMail's NameResolution property to True,
however, solves the problem. Because theNameResolution property is ignored under
the other systems IDSMail supports, there seems to be no reason not to leave it
set to True, contrary to IDS's recommendation. Another solution would be to use
each user's unique mail address, but there isn't any way to get those with
IDSMail. 
	I called the company's technical department with a question just before
5:00PM IDS time and left a message. I also sent in a request for support using
the IDSMail server on the company's website. I got a response to my mail request
in a few hours and heard back about my phone request the next business day. 
	Each IDSMail server has a unique license file that provides the objectkey
your program must pass to the server before use. You'll want to make sure that
you have only one license file in circulation no matter how many development
licenses you buy. 
	There's definitely a niche for ISDMail, even if you are only using a MAPI
compliant mail system. If you want to receive mail from within Access 2.0 or
Excel 5.0, or if you want to send a non-Access attachment from within Access
2.0, you should consider IDSMail-the alternative is having to code the MAPI
calls yourself. If you don't use a MAPI compliant system and you want any mail
functions at all, IDSMail will let you mail-enable your applications. 
	Finally, if you may be changing mail systems, IDSMail will save you from
rewriting your code as part of the changeover. While not everyone will need
IDSMail, those who do will be glad to have it.

Peter Vogel is the applications supervisor at Champion Road Machinery and a
Microsoft Certified Solution Developer. Reach him at peter.vogel@odyssey.on.ca 

------------------------------------------------------------------------

Total Access Agent 1.02 

FMS, Inc. 
Tel: 703 356-4700 
Fax: 703 448-3861 
http://www.fmsinc.com 
Price: single copy: $199; five-pack: $599 
Size: 1.7MB 
Runtime: not applicable 
QuickFacts: Total Access Agent is a maintenance scheduling utility for Microsoft
Access/Jet databases. It performs routine tasks such as compacting and repairing
databases, gathering statistics, and archiving tables or whole databases in both
16- and 32-bit versions.

By Don Kiely 
Total Access Agent automates the drudgery of maintaining and archiving Jet
databases. It works with all versions of Jet .MDB database files, so you can use
it with VB and all Access releases. The product is a program scheduler tailored
for easy maintenance of Access databases. It includes several standard,
pre-configured actions: archive a database, archive table data, compact and/or
repair a database, gather statistics about database objects and execute named
macros. It also includes a custom command option that lets you run any command
line. Archiving table data is a nice touch, because macros, forms, reports, and
code can take up a lot of disk space but rarely change, so why back them up
hourly? 
	Total Access Agent consist of three components: the Manager, Monitor, and
Engine. You use the Manager to maintain actions, such as to add and remove
databases, schedule events, and specify network passwords. The Monitor runs
continuously and launches the action at the scheduled time. Finally, the Engine
is the backend that runs everything-it has an OLE interface so you can launch
events programmatically. 
	Total Access Agent can schedule hourly, daily, weekly, and monthly
events. The hourly and daily intervals had all the flexibility I needed, but I
would like to see more options for the weekly and monthly intervals. For
example, you can select the particular days of the week to run an event, but you
can only run monthly events on a particular day of the month, such as the 15th.
It would be useful to run something on the third Thursday of the month or every
other week without creating multiple, duplicate actions. 
	The utility has some slick scheduling features. I was impressed with how
it manages database files. Once you add a particular file to an event, it is
added to a master database list, no matter how many actions use it. That means
that if you change a single database file that is used in 15 Total Access Agent
actions, you only have to change one setting in one place. This is just one
benefit of a well-defined and consistent user interface that belies the work
that went into planning the product. 

DOING THE TESTING 
I set up the program on Windows NT 3.51 and 95 machines connected on an NT
Server network to put Total Access Agent through its paces. I used two large
Access databases for testing and performed just about every available event as
frequently as possible. Once I got everything set up properly, the program
performed flawlessly, repeatedly backing up the databases and gathering
statistics. 
	Some impressive features include automatically emailing a message when an
error occurs, copying whole groups of events so you don't have to recreate them
by hand, and suspending an event so that you don't have to delete and then
recreate it. It even includes a Test button so you can immediately test any
scheduled action to make sure that you've set it up correctly. FMS did a nice
job with these extra touches. 
	The 73-page manual is well-written, concise, clear, and indexed. It has
almost too much detail, but this is a testimony to the quality of product design
rather than a flaw in the manual. The Windows help file contains the same
material as the manual--another nice touch. The documentation is careful to
point out the program's limitations, such as to caution you that Total Access
Agent uses the Jet engine's database repair capabilities, so don't expect
miracles if Access itself can't fix a file. Total Access Agent includes both 16-
and 32-bit versions, so it runs under Windows 3.x, 95, and NT using all Jet
database versions.

WINDOWS NT GOTCHA 
I did encounter a minor problem with Total Access Agent on my Windows NT 3.51
SP4 development machine. Total Access Agent Manager ran fine, as did Monitor,
but I got an OLE error any time the Engine tried to perform an action. Technical
Support via email and phone was helpful and responsive, and we ultimately solved
the problem: the server wasn't registering properly--a typical NT problem. The
product worked great on Windows 95. 
	Besides this small problem with the Windows NT installation, there are a
few minor improvements I'd like to see. There isn't always a list presented to
the user when it would make sense, such as when you enter the name of an
existing macro in the database you want to schedule. It would be easy enough to
get a list of macros; the utility does present a list of tables to archive. If
you change the scheduled events in Manager, you have to remember to either
restart Monitor or click the Refresh Event Schedule button for the changes to
take effect. I'd prefer having an option for the schedule to refresh itself at a
specified interval, because this could easily be overlooked. 
	My first impression on learning about Total Access Agent was, why bother?
Access itself can do all the maintenance chores that Total Access Agent handles,
and a simple program scheduler will run them. But it would take you a long time
to match Total Access Agent's ease of use and elegance. So if you have Access
databases to maintain, I'd definitely suggest you consider Total Access Agent.

Don Kiely is Development Manager for the Arctic Development Council on the North
Slope of Alaska. He programs in VB and writes about it when he isn't chasing
polar bears. He's written several books about VB and VC++, including Visual
Basic 4 Database How-To (co-author) from Waite Group Press and the Ultimate VB 4
Controls Sourcebook from Coriolis Group Books. Reach him at
donkiely@polarnet.com or 72657.475@CompuServe.com.

------------------------------------------------------------------------

DynamiCube 1.31 

Data Dynamics, Ltd. 
Tel: 614 895-3142 
Fax: 614 899-2943 
72672.550@compuserve.com 
http://www.datadynamics.com 
ferhat@coil.com 
Size: 1.2 MB 
Runtime: not applicable 
Price: $499 
Quick Facts: DynamiCube is a 32-bit data-bound ActiveX custom control for
On-Line Analytical Processing (OLAP). Supports VB4 32-bit Professional and
Enterprise Editions, or other 32-bit ActiveX compatible development tools.
Downloadable demo. Requires Windows 95 or Windows NT compatible PC, 3 MB HD, 8
MB RAM (16 recommended). 

By Jeff Borgoff 
With corporate America embracing On-Line Analytical Processing (OLAP), Data
Dynamics, Ltd. has thrown its hat in the ring with DynamiCube, an ActiveX custom
control that allows VB4 developers to build OLAP capability into executive
information systems (EIS) and decision support systems (DSS). DynamiCube
delivers custom n!-multidimensional data analysis capability, where the
dimensions are limited only by system resources. To give you a better idea of
the concept of dimensions, consider this: you want to see your company's total
sales by product, category, country, region, quarter and year. The quarter,
category and product constitute your columns, the region, country and year make
up the rows, and the sum of sales is presented as your data. The result is six
dimensions of data--or 6! 
	A market saturation of first tier OLAP tools with OLE Automation support
may make it difficult for Data Dynamics to position DynamiCube as a enterprise
solution for OLAP. I'm familiar with other OLAP tools, but they're all larger
and more expensive than DynamiCube. I see DynamiCube best suited for
small-business, departmentalized or small commercial-product development where
the fat competitive products aren't suitable due to size and cost. 
	DynamiCube's claim to fame is its small foot-print (less than a megabyte
for distribution), fast processing (assisted by Win32), impressive built-in
print engine with print preview, OLE Automation support and slick presentation
of data with drill-down capability. The product does its number-crunching on the
client-side using the Microsoft Jet engine (DAO and RDO) and ODBC data sources.
This works well enough if your clients have powerful machines, but this could be
a problem with the client-side processing of massive amounts of data that would
be processed faster on a server. DynamiCube also binds to the Visual Basic Data
Control, Remote Data Control or directly to a data source without the Data
Control. As long as clients have adequate resources, DynamiCube retrieves,
crunches and displays huge amounts of data. The vendor recommends a Pentium 100+
MHz processor with 24 to 32 MB RAM for the power user of heavy DynamiCube
applications. Data Dynamics provided me with a formula for virtual memory
consumption of a Cube in action:

((Number of Dimensions * 4 bytes) + ( Number of Data Items * 8 bytes)) * (The
Summarized Number of Records)

For example:

((6 * 4) + ( 2 * 8)) * (10,000) = 3,840,000 bytes consumed.

TESTING PROPERTIES
DynamiCube's interface is developer friendly. The grid-layout properties page is
robust, with an ample amount of customization ability comparable to capabilities
offered by third-party grid controls. The properties page uses drag-and-drop to
setup the data views. 
	Notable property features include the dcConnect, dcConnectType,
dcDatabaseName, dcOptions, dcQueryTimeout and dcRecordSource. These built-in
DynamiCube replacement properties for the VB Data Control allow direct support
for DAO, RDO and ODBC. I tested DynamiCube's connection to a Visual Basic Data
Control compared with a direct connection using DynamiCube's built-in connection
properties, and found performance about the same for each approach. However,
there are a couple of benefits for using the built-in connection properties for
DAO, RDO and ODBC. First, you don't have to deliver the Visual Basic Data
Control with your application; secondly, you don't have to write any code using
DynamiCube's built-in connection properties. 
	DynamiCube's obvious weaknesses are its lack of support for Windows 3.1
(no 16-bit ActiveX version) and no integrated charting. Data Dynamics obviously
chose to go with a 32-bit version because of the added power for processing
large amounts of data, but if your users are running 16-bit systems, you're out
of luck. The single sample project that comes with DynamiCube demonstrates a
charting method using Visual Basic's anemic charting control--not exactly EIS
presentation quality. However, you can export data to Excel using OLE
Automation. 
	The good news is DynamiCube has a few runtime properties that make it
fairly simple to populate any chart control on the market. The sample
application demonstrates all of DynamiCube's features (if you work through
everything). I couldn't find some features in the manual or help file (e.g. the
"PerformanceDlg" method), however PerformanceDlg was demonstrated in the sample
app. I would prefer to have Data Dynamics spell out everything in the
documentation. I encountered some problems using DynamiCube's on-line help file,
such as properties missing from the properties list, and keywords not found
during a context-sensitive search. I had to reference the 90 page manual more
than I usually do for a custom control. Also, the manual has a two-page guided
tour with some documentation errors that prompted me to call the vendor. They
noted the errors and will hopefully make corrections for subsequent releases. 
	If you want to see a cool example of how Data Dynamics' ActiveX
DynamiCube works on the web, download Microsoft Internet Explorer 3 (beta as of
early July) and go to http://www.datadynamics.com. You'll find an excellent
demo. 
	In spite of the documentation shortcomings, if you're looking to add OLAP
capability to departmental or small-business EIS or DSS applications using
client-side processing, DynamiCube is worth a look.

Jeff Borghoff is the founder and President of Avalon Logic, Inc. He is a
Microsoft Certified Professional and Visual Basic Product Specialist. His New
Jersey based firm specializes in the design and development of Microsoft Windows
based client/server systems. Reach him at AVALON_LOGIC@msn.com. 

------------------------------------------------------------------------

VB Compress Pro 4.03 

WhippleWare 
Tel: 617 242-2511 
Fax: 617 241-8496 
BBS: 617 241-9284 
Price: $100 
Runtime: not applicable 
Quick Facts: VB Compress Pro 4.03 automatically deletes unused or un-referenced
code. It generates reports, regenerated code, or both. Supports VB2, VB3, VB4-16
and VB4-32.

By Bill Shadish 
Many VB projects accumulate unused code over time. For example, code is orphaned
when you delete a control on a form and forget to delete any corresponding event
code for that control. VB Compress ferrets out any un-referenced code and
deletes it. I must admit, VB Compress is one of the tools I hoped would make the
treacherous journey from VB3 to VB4 with me. And it has, with release 4.03
offering significant improvements. 
	VB CompressPro 4.03 (VBC4) searches your projects' source files for
un-referenced API calls (declarations), unused variables and constants, unused
subs, functions or property procedures and un-referenced controls or other
external references. Selecting appropriate options configures the utility to
automatically delete unwanted code. 
	This latest release offers improvements over version 3, including: 

* Server mode checks that allow you to compress automation server code. 
* Intelligent checking of public references so that dynamically loaded routines
are preserved. 
* Long file name support for use on Win95. 
* The ability to place C++-like assertions in your VB code to perform actions in
case of unexpected errors. 
* Speed improvement of 30-40%.

	This new release requires less puttering around with options than VBC3
demanded. You can rewrite project code after reviewing a brief informational
screen. Moving between options and reports lets you control the level of detail
to code changes. Also, many options are provided to control which of these
unwanted impurities are actually removed from the final rewritten code.

GENERATING REPORTS
I ran VBC4 against a 5070 line, 12 file, OLE Server project. VBC4 quickly
produced an informational analysis, showing referenced and un-referenced
controls, and references to outside DLLs and EXEs. Also included were missing
external references that show up as unresolved. The utility also produced a list
of file facts, including the oldest file, largest file, file sizes, byte counts
and other types of files. I received a file-by-file analysis featuring the
number of comments, blanks, executable code, variable declarations, form
definitions and in-line counts that make up each file. 
	I analyzed the code, generated a report and produced source code.
Analyzing the 5070 line server took 1 minute, 39 seconds on a 486-33 with 16MB
of RAM (the slowest machine that I could find). 
	The Analysis Report step told me which constants, variables, and routines
(sub, function and property) are un-referenced (that means unused) in my
program. I also received an analysis of external objects I had left
un-referenced. The analysis even included unused labels, such as unused error
handlers. Armed with this information, I analyzed my code manually to see why
variables or routines were un-referenced. This is a great tool for
double-checking your code to see if something was forgotten or unfinished. I let
VBC4 automatically produce an updated version of my code, dropping the
un-referenced items. 
	The VBC4 report also shows any unused API declarations so they can be
deleted as well. API calls take up a fair amount of space within VB, because the
string itself must be allocated, along with enough space to hold and resolve the
parameters passed through the API call. Removing unused declarations can save
quite a bit of memory if you have a large number of un-referenced API
calls--possibly duplicated across several modules. 
	The report is generated as a text file. VBC4 provides a viewer (VBC
Viewer) that formats this file for viewing. You can drill down into further
detail in some areas marked "click-here" to see more information about the items
marked. And you can change report options to produce more or less of a
breakdown. For example, you can select options to show all control events that
have had code written behind them--a rather handy reference guide. You can print
the report from the VBC Viewer, but WhippleWare left out the ability to copy,
cut and paste the information directly from the on-screen report. Hence, you
can't easily export the statistics into other tools, such as Excel.

CODE GENERATION 
VBC4 offers quite a bit of control for handling code generation. For example,
you can change options to have unused files deleted when the code is
regenerated. You can also remove unused control objects from your project (which
means I don't have to remember to remove control objects prior to creating
install disks!). You have the ability to comment out, remove, ignore, mark or
interactively decide how to handle the un-referenced local, private or public
items. These items include constants, variables, type declarations, declarations
or procedures. 
	Lastly, VBC4 loads VB.EXE under its control and runs the VB design
environment. You are able to interrupt the code generation process using a VBC4
toolbar that appears within VB. Using this same toolbar, you can generate a new
.EXE and decide whether to update the VB source files or not. 
	The one glitch I found working with VBC4 was running out of memory while
producing updated code (for code procedures or declaration sections approaching
64K). This type of problem is often due to limitations within VB's editor
itself. 
	In case you couldn't tell by now, I like this product.

Bill Shadish is a principal of Fundamental Objects, Inc., where he works with
ActiveX controls and OLE server technology. He teaches VB programming, and
writes regularly for VBTech and Visual Basic Developer. He co-authored the book
Using OLE In Visual Basic 4, (Pinnacle Publishing, Inc.). Reach him at
bills@fo.com or at http://www.fo.com. 

------------------------------------------------------------------------

Visual SQL 4.0 

Blue Sky Software Corporation 
Tel: 619 459-6365 
Fax: 619 551-2486 
http://www.blue-sky.com/ 
Price: $1899 
QuickFacts: Visual SQL 4.0 is a code generator and class library that turns
Microsoft Visual C++ into a client/server development environment. Supports
32-bit VC++ 4.0, Windows 95 and Windows NT.

By Steve Jackson 
Visual SQL is a code generator and class library that creates 32-bit
client/server database applications using Visual C++ 4.0 and the Microsoft
Foundation Classes. It requires Windows 95 or Windows NT, and comes bundled with
Sybase SQL Anywhere. The main benefit of Visual SQL is that it saves the time
otherwise necessary coding screens and creating code to move data to and from
the edit controls. The developer starts up the Visual SQL application generator
wizard, selects the ODBC data source, tables, and columns needed for the
application, and Visual SQL generates all the Visual C++ code needed for a fully
functioning MFC database application. You can use any database with a 32-bit
ODBC database driver. Visual SQL and the code it creates are fully integrated
into the Visual C++ Developer Studio IDE. No runtime DLL is needed other than
the standard ODBC DLLs. The product includes some useful utility programs and a
repository that can be used optionally to store queries. The repository can be
used in a team environment to share queries among multiple developers. 
	I put the Visual SQL application wizard to the test by creating a
customer order-entry database update program. Creating update screens was
easy--I chose the table and columns, and they appeared on the form. The wizard
created the update screens automatically, with edit controls for each field and
the field name placed as a label above each edit control. I was then able to
visually modify the form by dragging fields around and clicking on labels to
change text. The wizard gives you some choices for how to do database retrieval
and how the screens appear. Database retrieval can be done for an entire table,
for SQL statements you create, or using a query stored in the Visual SQL
Repository. Screens can appear as a data sheet with multiple records per screen
like a spreadsheet, or as a data screen with one record showing at a time. Menu
choices and toolbar buttons are automatically generated with navigation commands
(first, next, and last record) and update commands. The code generated by the
wizard compiled and ran cleanly the first time without any errors or warnings.

SEAMLESS INTEGRATION
I found the code generated with Visual SQL to be well written and well
integrated with the MFC document/view architecture. I have seen other code
generators that require the programmer to stay within the code generator IDE for
all compiles, with limited ability to modify the program code. I was quite
pleased to discover that Visual SQL creates an entire MFC project that can be
compiled and modified with the Visual C++ IDE. I easily set debug breakpoints
and ran the code from the Visual C++ debugger, and was able to modify the code
using Visual C++ class wizards. Using the MFC Class Wizard, I added code to the
undo menu items to cancel database changes made to a record. Oddly, the Visual
SQL wizard generated menu selections for this, but failed to generate any code
behind the menu choices. 
	Looking under the hood, I found that the database operations were carried
out in a Visual SQL class library. This library consists of classes that are
wrappers around standard MFC data access objects (DAO) using dynasets and
snapshots. Because the MFC DAO classes are built on top of the ODBC API, a
developer can add calls directly to the ODBC API if needed. 
	The product comes with a suite of useful utility programs. The Database
Explorer allows the developer to view database table structures, analyze ODBC
connections, and view repository entries. The ODBC Data Source tester and
Configuration tester can be distributed with applications generated by Visual
SQL. These testers verify that ODBC data sources are installed correctly, and
that a user has the right versions of all the required DLLs; this information is
highly useful for debugging an application, and for remote telephone support.
The Visual Query builder presents a graphical interface for creating database
queries and SQL statements, saving the developer time spent looking up column
names and SQL syntax. 
	Installation went smoothly, and the setup program automatically
configured an ODBC data source for the tutorial programs. The documentation is
well written and complete. For example, the documentation includes a detailed
description of all the generated code modules, what each routine does, and how
the modules are named. A few potential improvements I'd like to see in future
releases include: the ability to automatically generate undo code to allow a
user to cancel updates on a data screen, transaction commit point processing, a
report generator and the ability to store labels in the repository instead of
using field names when creating data screens. 
	Blue Sky maintains a web site at http://www.blue-sky.com. Be sure to
include the dash in blue-sky in the web address--if you leave it out you will
find the web site for another company also called Blue Sky!

Steve Jackson develops network-based applications using VB, C, SQL Server,
Oracle and other tools at Loral Aeronutronic in Southern California. Steve is a
Visual Basic Programmer's Journal author and CompuServe section leader:
72040.1640@compuserve.com.

------------------------------------------------------------------------

To subscribe to Visual Programming++, send an e-mail to
visualprog-request@scribe.cerf.net. Include the word "subscribe", space, your
e-mail address in the body of the message. For example, subscribe
yourname@youraddress.com. To cancel your subscription, include the word
"unsubscribe", space, yourmailaddress and send the same request. VP++ is
separate from Hot Links, a brief e-mail sent to registered users of DevX
alerting them to interesting new items on the site, and industry news.

ABOUT FAWCETTE TECHNICAL PUBLICATIONS 
Visual Programming++ is Published by Fawcette Technical Publications. Copyright
(c) 1996 Visual Programming++. All rights reserved. FTP also publishes or
produces: Visual Basic Programmer's Journal, Avatar: http://www.avatarmag.com,
Microsoft Interactive Developer, VBITS conferences, The VBCD, The VBPJ Guide to
VB4, VBPJ CompuServe forum (GO VBPJ). 
Fawcette Technical Publications 
Publisher/President: Jim Fawcette 
209 Hamilton Avenue 
Palo Alto, CA 94301-2500 
USA 
Editorial Offices. Tel: 415-833-7100 
Editorial Offices. Fax: 415-853-0230 
Customer service and subscriptions: 303-541-0610 
Orders: 800-848-5523 or 415-833-7100