Developing and deploying applications without writing source code

Visual programming is the rage for developing Windows-based applications, as you can tell from the range of visual-oriented development products on the market. You can choose from Visual Basic (VB), Visual C++, and even Visual RPG, to name a few.

Although these products are good tools for developing Windows-based applications, they all have a strong language component. To use them, you must write or modify source code. This is not the case with Oberon Software's Prospero--a graphical development tool for constructing Windows-based applications. With Prospero, you choose and interconnect application building blocks without using source code.

Prospero's breadth is impressive. Prospero applications can accept input from local databases, SQL or Open Database Connectivity (ODBC)-enabled databases, dialogs, flat files, Lotus Notes, Object Linking and Embedding (OLE) services, and Web pages. Similarly, Prospero applications can direct output to those same sources, printers, email, or the Symantec (Delrina) fax interface. Between input and output, Prospero's reformatting and computational tools let you analyze and massage data as it passes through the application.

Prospero is excellent for quickly developing a variety of ad hoc applications. Prospero can, for example, get information into and out of Lotus Notes, generate reports from an ACT! database, perform Microsoft Word mail merges from an ODBC-enabled database, and automatically download and print Web pages. After you learn how to develop Prospero applications, you can use it as a plug-and-play application solution for many common business problems. If you use other visual programming tools such as VB, you'll be pleased to know that Prospero applications can interface with other, external programs.

Prospero Programming 101
Installing Prospero is straightforward with Oberon's setup and installation program. The installation process is sensitive to the Windows environment. So when you install Prospero into a 16-bit Windows environment, you generate 16-bit Prospero applications. If you install Prospero into a 32-bit Windows environment, you generate 32-bit applications that run under Windows 95 or Windows NT. I installed and tested Prospero in an NT environment exclusively.

Despite its visual nature, Prospero is not an intuitive product. I was unable to generate a simple application without spending a fair amount of time studying the printed documentation, reading the online help, and looking at the example programs. If you've worked a lot with application generators or other visual programming tools, you might pick up the Prospero programming constructs quicker. (I admit I'm not an application programmer.) I spent a day of hands-on interaction and research picking up on the programming mindset (paradigm, if you prefer) and producing a simple working program. More extensive documentation and online help would have hastened my ascent of the learning curve.

To create a Prospero application, you select application building blocks, define the properties of each block, and interconnect them. Prospero comes with several building blocks for dialogs, database input and output, flat file input and output, variable manipulation, loop and decision control, and more. Oberon is constantly developing new building blocks.

A building block's properties control its behavior. For example, the properties of a dialog define its appearance (size, layout, graphics, etc.), content (fields, buttons, check boxes, etc.), and usage (input or output). Similarly, a flat file building block's properties define whether it's an input or output operation, what file it involves, where the file name comes from, and the file's field layout.

After you identify the building blocks you want to use, you interconnect the various data input and output sources. For example, to read in a field from a database and display it in a dialog, you must connect the input field in the database building block with the output field in the dialog building block. Prospero's name for these points of interconnection is ports. Connecting all the right ports to get the desired results is the power--and challenge--of Prospero.

After you create and test an application, you compile (deploy in Prospero terms) it into an executable file. Note that the application isn't freestanding; some Prospero dynamic link library (DLL) files accompany the application file. Prospero can, however, automatically copy all necessary files to the location you choose.

My Test Application
I tested Prospero by constructing an application to feed data from a dialog into a flat file. In my first attempt, I created a dialog building block and a flat file building block and interconnected the two blocks' matching input and output fields. Although the application worked, it wrote data to the file regardless of whether I pressed OK or Cancel (Prospero automatically includes both buttons in a dialog building block). This situation wasn't what I expected. I discovered I needed to add a loop building block to properly handle the Cancel button. Screen 1 shows the resulting Prospero application.

As part of the process of selecting and interconnecting building blocks, you must define each building block's properties. Screen 2 shows the properties dialog for the flat file building block. This dialog specifies how the building block operates (i.e., it writes to a file), the name of the file, its field layout, and other file-related information. Prospero has a dialog to define properties for many of its building blocks.

How you define a building block's properties varies from one building block to the next and depends on whether the building block is for input or output. In my example application, I designed the dialog with Prospero's onscreen dialog editor.

The dialog I created had two input fields (TextBox1 and TextBox2), a button, a check box, and a graphic. The application passes the two input fields to the flat file building block but doesn't use the button and check box. I included them just for show.

The final building block in this example--the loop building block--tests whether a user presses Cancel while the application is running. If so, the loop building block also terminates the application.

After putting the building blocks in place, I interconnected the relevant input and output fields. Screen 1 shows the two input fields on the dialog building block (TextBox1 and TextBox2) connected to the two output fields in the flat file building block (Field1 and Field2); this interconnection lets Prospero pass information from one building block to another. I also had to connect the Cancel button field to the Condition field in the loop building block to create a way to terminate the program. Screen 3 shows the results of my example program when run as a deployed application.

Prospero is unquestionably a powerful tool. Its strength lies in its ability to create and deploy small, quick-turnaround applications. So IS professionals who need to quickly respond to end-user requests for new reports or business information views will find Prospero invaluable. Independent consultants looking to extend the functionality of core products such as ACT! or Lotus Notes will also find Prospero appealing.

In contrast, Prospero will probably not be a first choice among developers creating large-scale applications. In more general terms, programmers and nonprogrammers looking to graft new functions or interfaces onto existing information structures will appreciate this product.

Prospero 1.1
Oberon Software * 617-494-0990 or 800-654-1215
Web: http://www.oberon.com
Price: $695