Feedback Search Top Backward

Under the Scope

Written by Brad Scharf




Welcome to the utility review column. This is a new column that will review freeware, shareware and commercially available applications intended to aid the development process and initially will be targeted towards beginning OS/2 programmers.

The column will feature one or two utilities each month. I will try and let the reader know in advance which tools will be featured. Also, there will be an index at the end of every column that will include program names and descriptions, which issue of EDM/2 featured the program review and in future issues I will try and let the reader know where the utilities can be found and at what cost.

If you have any comments or suggestions regarding this column please let me know. If the column is to be a success it will be through the feedback of its readers. Likewise, if you know of a utility that would be beneficial to other programmers please mention it and I'll do what I can to ensure that readers are made aware of it.

This Issue

After a few false starts I managed to find a tool that (as far as I know) doesn't have a new version due by the time you read this!.

I feel like confessing something so here I go ... I'm lazy. Yup, really lazy. I don't like to do more than I need to and when I do do something I believe it should be as easy as possible. This applies to learning programming and actually building a project as much as anything else. This being the case, you can only imagine my excitement when I came across an application development tool called Guidelines. In fact, I was so excited I've decided to do this review over several issues which will be broken down as follows:

Part 1 A general overview.
Part 2 A closer look at the development environment and review of the same.
Part 3 An introduction to and review of the language.
Part 4 Build a simple project (probably the standard "Hello World" with one or two extras but this remains to be decided) and a more-in-depth summary than will appear in this issue.

While all this is taking place I will also review some other utilities (that is after all, the purpose of this column). Depending on what we look at will determine if the 4 parts to the Guidelines review will appear consecutively or not. If not, there won't be more than a one-issue pause between sections and it's quite likely that some of the four parts will be published in conjunction with another review. As well, each section will receive a rating independent of the others, with an overall rating at the end.

By the way, if you have any comments or suggestions about this multi-part format please let me know, as this is only the first of many reviews that I would like to present in this manner.

Guidelines 3.1j Base Pack

Part 1: A General Overview

Guidelines is an application development package with cross- platform capabilities and supports a variety of popular compilers for OS/2 and MS-Windows 3.1.

Right from the start it's apparent that this program has something special to offer. A straight-forward installation program lets you select installation directories, creates the desktop folders and objects and optionally modifies CONFIG.SYS paths.

The Guidelines 3.1 interface is easy to use and it's easy to look at. The user is not overwhelmed with tool palettes and menus, the menus themselves are well organized and intuitive and options are not so deep as to make options difficult to find.

Much of the work to build a project has been taken care of for you with Guidelines. Frame windows, dialog windows and menu items are created by menu selection. Controls are added by selecting from either the menu or tool palette. Likewise for presentation parameters and window behavior, etc. In fact, almost everything is accomplished by pointing and clicking. Double clicking the left mouse button on a window or control brings up the 'details' dialog for that particular item. Single clicking with the right button takes you to the 'action module' for that item and once there you can add modify the code for that same item. Even a fair bit of code can be added in via mouse selection by right- clicking where you want the code to be placed and then selecting the code template you require from a series of list boxes that become more specific as you go deeper. Simply modifying the templates to your specific needs is all that's required.

As mentioned in the introduction, Guidelines supports a number of compilers for OS/2. These include IBM C++ v.2.01, Borland C++ v1.00 and Watcom C++ v9.5 and 10.0. In addition, several compilers are supported for the creation of MS- Windows 3.1 applications if you are bent that way.

Compiler switches are pre-configured by Guidelines for each compiler, depending on whether or not you wish to include debug information in your files. Compiler, linker and other program switches (make, rc, implib etc.) may also be added or removed, depending on your preferences. Paths are also pre-configured and can be modified on a case-by-case basis, or you may choose to use environment settings from CONFIG.SYS. It is also possible to add compilers to the list but it is not known if support for additional compilers must be built into the Guidelines libraries for code to be properly generated for other compilers.

Guidelines is not only easy to use, but allows creation of programs that make full use of the OS/2 environment. Your can write multi-threaded programs, use CUA '91 controls, create client/server and database apps, support DDE, SOM, create EXEs or DLLs and quite a bit more. Not all of this functionality is included with the Base Pack that we're looking at here and must be purchased separately as modules. For example, if you wish to create containers or notebooks from within Guidelines you'll need the PDK. If you wish to use Guidelines to create WPS programs you'll need the SOM extensions, client/server apps require the Client/Server extensions etc. However, the Base Pack itself will permit the creation of simple yet functional programs and if you need to do something that the Base Pack doesn't allow you can always write the code in C++ and add it to the project as either an internal module or as an external file. After all, when you build your project with Guidelines you'll actually be using your own compiler anyhow so any code that your compiler will accept as input should be valid.

If you are already an accomplished PM programmer you may not actually benefit from a tool such as this. In fact, if if you are you'll notice decreased productivity until you gain an understanding of the language. Guidelines uses a proprietary language called JOT. The language itself is not too complicated but there will still be the inevitable learning curve. The most benefit from this tool will probably be derived from people like myself whose knowledge of C++ is not great and whose understanding of PM programming isn't much better. We have here a situation where, in order to become proficient, a lot of new concepts must be learned and now we have a tool that eases that task of gaining that proficiency.


Guidelines is obviously not the only tool available to ease the task of creating PM programs, and certainly isn't the cheapest when you consider that the PDK alone costs almost $600 (US), requires an OS/2 compiler and still won't allow you to add the functionality (using JOT alone) that you could with a compiler and C or C++ unless you purchase the extension packages.

On the up-side, once you know the language you have the ability to create an application for multiple platforms from one environment. You can change compilers without worrying about the peculiarities of the brand. There are no run-time libraries to distributed, thus no run-time royalties. The development process is fast and simple and for inexperienced C or C++ programmers the JOT language should allow the creation of PM programs much faster than writing a PM program in C/C++.

Overall, this is an outstanding package (from a beginners point of view). It is easy to use, the language is easy to learn, it isolates beginning programmers from much of the complexity of PM programming and allows even new PM programmers to create functional programs in a short period of time.