Review of Faces
Shawn M. Gordon
S.M.Gordon & Associates


Perhaps some of you will remember a review that I did of a product called Frontender! about 1 1/2 years ago. It was version 1.0, and it was being done by Zebra Software. Well there has been a lot of changes since then, first off it is now called Faces, second it is being sold and distributed by API International (either formerly or still Holland House), and finally, it is up to version 4.

This new version is so far beyond what I originally looked at that it is really a whole new product, hence the new review. It is still being coded and maintained by the same gentleman that brought us 1.0 of Frontender! however, and he is doing a damn fine job.

For those of you who don’t know what the heck I am talking about, a little explanation is required. Faces is a product that runs on your IBM compatible PC under Microsoft Windows. By making use of your connection to the HP 3000 it offer’s the simplest, fastest capability for building Client/Server applications I have ever seen. There is absolutely no coding involved to make this work, you can even have the product generate the screen for you under many circumstances, so you could literally turn an existing application into a Client/Server application in about 5 minutes.

So this is the system I was using to run the software. A 25Mhz 486 with 12 Meg of RAM, a 320 Meg HD, 2Meg Paradise Super VGA and Windows 3.1. I tested the interface across a direct connect and a 2400 modem connection to an HP 3000 Series 37 with MPE V Platform 1P. I was using Reflection for Windows version 4.0 from WRQ as the terminal emulator interface. The product requires that you have Reflection for Windows version 4.0 or later. Whenever I mention Reflection I am referring to the WRQ product Reflection for Windows, version 4.0 or later.


First let’s talk about some of the specifics of what Faces will do. The fastest and easiest way to use the program is as what is called a ‘screen scraper’. What this does is match up the fields in your Windows C/S application with the fields in the applic
ation running on the HP. This could be a block mode or character mode application. So what happens is data is passed back and forth between the two applications. You can even spice up your Windows application with pictures and graphics and such. This doesn’t really cause any extra overhead on the server, but it also doesn’t satisfy one of the axioms of Client/Server, and that is to offload the screen interface to the Client.

A second method that is available brings a truer conformance to Client/Server. This allows you to write scripts that you can attach to Faces Objects (more on those later) that will perform various PPL (Process to Process Link) functions for you. This includes such things as Image data base functions. It makes use of a scripting language that is ‘very’ similar to that found in WRQ Reflection, and it gives you a high-level interface to their PPL. I have used the WRQ PPL and the functions found in the Faces scripting language is MUCH easier to use.

First let’s run through some of the options for doing ‘screen scraping’, we will make use of several utilities that are supplied. The product seems to keep coming with more and more little goodies and tools to make it easier to use. Figure 1 shows an example of the Program Manager group that Faces creates. We are going to run the program Faces 4.0, figure 2 has an example of the screen.

Now figure 3 has an example of the host based View application that I am running. We are going to select the option ‘Auto Front End’ from the Faces tool bar. This will give us four different options for creating a front end, build from emulator, build from forms file, build from record layout, and build from database. We are going to build from emulator. One thing worth mentioning here is that all through Faces, whenever you have a screen that requires input you will get a brief description of what the field needs in the message area when the mouse pointer moves over it.

We now get an option screen that allows us to specify various things like ‘generate enter key’, ‘generate function keys’, screen dimensions, etc.. So we now click on ‘OK’ and about 10 seconds later we have an application that we can run and use. Figure 4 shows the default screen that Faces built for us based on the currently executing application on the host. At this point you can use the program, or you could move fields around, change font’s, change labels, add pictures, etc.. This is how simple it is to put together an application without doing hardly any work. I had to move the fields up a bit to get them to fit in the snapshot, so if there is anything out of alignment it is due to my moving them around.

You can also manually make connections between a Faces screen and a host based application. This is pretty simple if the screen positions are basically static and not a scrolling display. You can also work against scrolling displays however, it’s just not quit as easy.

So how do you build a screen? As you saw from figure 2, we have essentially a blank screen and a tool bar. The tool bar contains all the objects that you will need to build your screen. You can place buttons, labels, entry fields, combo boxes or lists (these are selection lists), radio buttons (on/off type objects), graphics and gauges. What is neat with the combo list boxes, is that you can just do a file selection pick list to specify where it’s going to get it’s data from. Even when you are in design mode you can peruse the real contents of the list, move and size the control, change properties, etc…, all with the real data showing so you can see how it is going to look as you do it.

There are tools that are supplied to modify attributes and locations of objects as a group instead of having to do it one at a time. Some of the tools supplied are reminiscent of some of the Sheridan utilities for Visual Basic. At this point it is very easy to select and place objects. Each object can have it’s attributes changed, or have other events attached to them such as Procedures or Script files, which you can create for your own purposes.

This seems as good a time as any to cover scripting. The scripting language currently has 140 commands that allow you to manipulate front-end objects, databases, flat files, host computer systems, and a Reflection terminal emulator. The language is based quite a bit on the Reflection scripting language, which is pretty easy to use. There do seem to be a couple of critical differences that might trip you up if you are used to the Reflection scripting language. First, the variables are called FV# where # is up to two digits up to a value of 99 that is the variable name, in Reflection it is just V#. To de-reference a variable in Faces you use the tilde ~ character, in Reflection it is the dollar sign $.

What is nice is the ability to manipulate the objects on your screen via the script, as well as accessing a lot of PC data and functions very easily. What is probably the best part is the Image data base access functions, here is a short example of a script dialog that would start up PPL in Reflection, open an image data base, grab a record, and then close it. The upper case stuff are script commands, the lower case stuff is the parameters.

NOT_READY (sets the status window indicator)
OPEN_IMAGE_DB basename password mode
DBGET setname mode list argument FV1 (last parm is variable to hold data returned)
DBUNLOADBUFFER screen FV1 bufferlayout
DBCLOSE ” ” mode
READY (sets that status window indicator)

Believe me, this is MUCH easier than doing a PPL connection with Visual Basic.

You also have full access to Windows DDE (Dynamic Data Exchange) from the scripting language, this means you can fire up and feed data to pretty much any Windows application you care to. I know I have used this functionality to get data out of a report on the HP and feed it into an MS Excel spreadsheet, it’s pretty exciting the first time you get it to work.

One of the neat features in the Script Editor is the ability to have it build an SQL command for you and then stuff it in the script. You get a pop-up window that will guide you through selecting a data base, table, and formulating your query against a column in the table. This is great stuff, and a good way to learn some SQL syntax if you aren’t familiar with it.

An important note is that a script can’t call a script, but it can call a function, which can return back to the script. Their isn’t a lot of difference between the two other than what I just mentioned, and how you block off the code. That probably covers scripting enough to give you an idea of what is possible. There is a front end called ‘MPE’ that is a very good example of working against a non-screen environment, and using scripts to read and interpret data that is just flowing past on the server, I suggest taking a look at it. As a matter of fact, it would make a great tutorial for the product, maybe I can get API to add it.

I have to talk about the DBQuery utility that is also included. This handy little program will allow you to access and manipulate a bunch of different data base types. It includes MS Access, dBase, Foxpro, Paradox, Btrieve, and any ODBC compliant data base. This will give you pick lists for selecting the data base structure, the table in the data base, the items in the data base, and you can then easily pick fields and join tables for building queries. After going through this, you can then have it show you the SQL command that is going to be issued. It will then build a little default screen with the record layout that you selected and you can then perform standard operations such as add, delete, find, scan forward and backward, it even has the correct logic to let you know when you hit the end or beginning of the records that qualify. The program is actually pretty darn fast as well, which really impressed me, I have heard some horror stories on the performance of ODBC connections.

This is really a wonderful little add-on, especially for the format types that are offered that don’t have a very robust environment. It is also nice to be able to have a single environment for building queries to various data base types.

There are some more utilities for reading the contents of a Schema file, or a VPlus Formspec file and then assisting you in generating an application, but I think you are starting to get the idea of everything that is possible inside this product. They have really gone out of their way to make it as painless as possible to build an application with a minimum amount of work.

Usability (also installation)

The product use’s the standard MS Windows installation procedure. This went smoothly enough as I didn’t encounter any problems. While you probably still can’t just load it and use it without at least going through the manual a little bit, it is much easier to use than the original version of the software.


Since you are working with a product under MS Windows, and it is talking to other products (WRQ Reflection) you can sometimes get some of those nasty little Windows errors for some really odd-ball un-reproducable reasons. The Faces product seemed to be very solid and reliable, just remember what environment you are working in, and that every once in a while you might have a problem due to the still relative flakiness of Windows. Always remember to save your work whenever you have done anything significant.


There are actually two different programs that can run your Faces application, one is the design environment, and the other is the Run Time module. The Run Time module executes MUCH faster than the design module, I don’t know why this is the case, but they also make a point of it in the manual. At least it’s not the other way around. Actually with any reasonably configured PC your performance won’t be to bad.

I have to make a general point about Client/Server and performance at this point. I have looked at a lot of Client/Server applications and development environments and they are all slow, some are slower than others, but none of them can be considered fast. Faces isn’t really any exception to this either, the actual work of doing Client/Server is just slow, there are things you can do to improve it, but that will obviously take more time and effort. Depending on what you want to use Faces for this may or not be a problem, I just wouldn’t recommend it for a data entry application.

Supportability (including Doc)

During this review I only had to make use of support on a couple of occasions. I always got a hold of someone immediately, and I always got an answer. While the documentation has greatly expanded since the early days, and contains a lot of information it still leaves a bit to be desired in it’s completeness. I would have liked to have seen a couple of more tutorials covering some of the more esoteric aspects of the product, because I doubt you will ever get into them by looking at the manual. I would also have liked to have seen the tutorials explain things a little more clearly. I presented these complaints to API and they seemed very open to my suggestions. Since I had a pretty early version of the doc, I would hope that at least some of my suggestions make it into the manual shortly.

What is very nice, is a full implementation of the Windows Hypertext help facility. I have used this in other products to the exclusion of ever looking at the manual.


I want to take this opportunity to talk a little about Client/Server in general. I have noticed a trend at many companies where some executive that isn’t involved in the computer department, but does have a say over what they do, will read some article in Computerworld or some other magazine, about Open Systems with UNIX, and Client/Server. They will then unilaterally decide to throw out the HP 3000 and replace it with the current buzzwords. I have yet to see a company where this was cost effective or successfully implemented. They almost never do a real world test of what it is they want to do to see if it will be viable. Faces gives you an opportunity to actually develop some Client/Server applications with very little investment in time or money and see how effective the philosophy is going to be. Faces isn’t tied to the HP 3000 as a server either, so the work you do won’t necessarily be all for naught. That said, here is my summary on the product.

I am continually blown away at what is being done with this product. It is so fast and easy to put together a screen scraper Client/Server front end it’s not even funny. All the utilities for reading FORMSPEC files and SCHEMA files, as well as being able to generate screens from a running application, just make this so easy to use.

The full implementation of MS Windows help also makes this a very robust product. Generating a ‘help’ system is a very tedious process, and I appreciate the work that must have gone into it.

I have only two complaints really, one is the documentation that I mentioned earlier, and they can do something about that. The other they can’t do anything about sadly. If you have ever worked with MS Visual Basic for Windows you know how difficult it is to get a grasp of the entire scope of the program, what executes when and where. Faces suffers from this same malaise. It is very difficult to go through a moderately complex front end that you aren’t familiar with, and figure out what is going to happen when and where. I would like to see an option that would print out some sort of comprehensive report that showed events and what happens, and the scripts (including the contents of the script) that are attached. I also presented this idea to API so it is possible this will also show up shortly.

Even with those complaints I think this is a fine product. If you have any interest at all in jumping into the Client/Server hype I would suggest taking a look at Faces. It will allow you to prototype and test your ideas with the minimum time and learning curve. The ability for it to make use of ODBC to access just about any type of PC or RDBMS data base (ImageSQL with ODBC is currently in beta), really make it more than just a front end tool, it gives you the ability to put together your own MS Windows based applications for your own purposes.

At-a-Glance box

Faces for Windows from API International.
P.O.Box 91027
Austin TX 78709
Phone (512) 280-4391 xt 231
FAX (512) 280-0309

You can write, call, or FAX for a demo or to order a copy. Product is priced at $995 for one designer copy and one run time copy. Multi-copy discounts and site licensing is also available.