Thousands of applications have been written for Multi-Value-based systems over the last 30 years. The Multi-Value environment has proven to be a very flexible, productive environment for real-world business solutions. These applications embody an enormous amount of experience, which often translates to very robust applications.
Because of its heritage, the Multi-Value environment is still closely associated with a dated “terminal interface” as the main means of interacting with application users. Although other mechanisms, such as ODBC and HTTP, are now available, the majority of Multi-Value applications still use the old character-based PRINT & INPUT for their user interface.
There is an abundance of legacy code that is still being maintained, and that code was designed around the only interface available at the time – the simple character-based interface. Even new applications continue to use the old character-based interface, perhaps because this interface is conceptually simple for developers, and does not require learning new, complex technologies.
The downside to this continued use of this outdated character-based user-interface is twofold. First, application users, now accustomed to the sophisticated user-interface available with Windows and other GUI environments, expect their mainstream application to have similar functionality and flexibility. Users become frustrated with the limited editing features of the common INPUT statement and limited navigational capabilities of many traditional character-based interfaces.
Equally important is the problem of perception. Even if an application is otherwise first-class, if it has an unattractive user interface, it is often perceived as outdated, limited, and difficult to use. The perception problem is especially important when trying to market the application, either commercially, or internally to corporate decision makers. When compared to (possibly less capable) competitive applications employing a modern (Windows-like) user interface, a favorable first (visual) impression may open the door to further consideration, whereas the application with an unattractive user interface is eliminated without a fair evaluation of its underlying capability.
In response to the deficiencies of the traditional character-based interface, developers have taken several approaches to resolve the problem. One approach is to abandon the Multi-Value application code entirely and redevelop the application from the ground up on a different platform (Visual Basic, SQL, Java, etc.) This always requires an increase in development staff because the VB/SQL/Java environment is far more complex. This approach typically requires a large investment in time and money, and the desired result is not always realized.
Another common approach is to adapt the application to use a new mechanism for interacting with the user such as ODBC, HTTP or Web Services. The user-interface component is then developed as a Web page and accessed by the user’s browser, or as a Visual Basic or Java application accessing the Multi-Value application data using ODBC or similar technology. While less resource intensive than a total rewrite, this approach requires a significant development effort.
There are less drastic approaches to resolving the outdated user interface problem. This article explores several alternative solutions. While centered around using AccuTerm as a key component in the solution, many of the techniques discussed apply equally well to real terminals, and other terminal emulators which accurately emulate those real terminals.
Get a face lift
Given the ubiquity of Windows, adopting a “Windows look” is an obvious way to improve the look of any character-based application. The user interface does not necessarily need to work like Windows, but if it looks like Windows, at least the first-impression problem is eliminated.
A real terminal cannot accomplish this task – a terminal emulator (like AccuTerm) is necessary. And the emulator must have the ability to apply the Windows look to ordinary text in an intelligent manner that is easy for developers to take advantage of. AccuTerm accomplishes this by using “Visual Styles”, which adopts the current Windows color scheme and associates various border styles with terminal display attributes (like reverse, dim, underline, etc.) To take advantage of this feature, the application developer needs to use the display attributes in a consistent, intelligent manner. The terminal emulator displays the text using familiar Windows colors and renders the borders transparently. When used properly, specific screen areas (blocks of ordinary text with a common display attribute) appear as if they were text boxes or command buttons.
To take advantage of AccuTerm’s “Visual Styles”, the application may require minor modifications. The extent of the modifications depends on whether the application already utilizes display attributes to highlight screen elements, such as entry fields, labels and command buttons. If display attributes are not currently utilized, the developer must insert the proper terminal commands to display screen elements using appropriate attributes into their code. If the application is written using one of the many available 4GLs, there is usually a way to customize the display characteristics used in the 4GL environment overall. This may be as simple as changing some preferences in a configuration screen or data item.
Besides enabling the use of AccuTerm’s Visual Styles, these simple changes make the application’s interface more visually appealing even when used with ordinary terminals or terminal emulators.
One simple improvement that can be easily added to character-based applications is use of graphics. This, of course, is only possible when using a terminal emulator that supports images, like AccuTerm. Images can be used to make a data entry screen more visually appealing, or to provide useful information on an inquiry screen. For example, an Inventory maintenance screen might show an image of the part, or an order tracking query might show the signature of the receiver.
Use the cursor keys
All commonly used terminals, and emulations of those terminals, provide standard editing and cursor keys. Users familiar with typical Windows programs expect that pressing one of the cursor direction keys will cause the cursor to move in that direction. Or that pressing the Delete key will delete the character under the cursor.
Traditionally, Multi-Value applications have relied on the simple BASIC INPUT statement for the majority of data entry tasks. The only editing supported by the INPUT statement is the Backspace key! Twenty years ago, this may have been the only option, but all modern Multi-Value platforms support single character input allowing the application total control over the input process. Given the advances in processing power, the increased overhead of processing keyboard input on a character-by-character basis is no longer a major concern.
Adopting modern input processing for character-based applications requires the input function to return not only text, but also commands, in a terminal-independent format. The command indicates if a non-text key like a function, cursor or editing key was pressed. Some Multi-Value platforms include utilities that automatically decode control and escape sequences into terminal independent keyboard commands. Alternatively, use AccuSoft’s Smart User Interface routines, or write a custom routine.
Once keyboard text and commands are properly recognized, the application needs to perform actions depending on the command (for example, moving to the next field when the Tab key is pressed). Other improvements should include consistent use of function keys, navigation using Tab, Back Tab, and cursor keys.
Finally, since most terminal emulators include some kind of mouse support, a modern input processor should decode mouse clicks into special keyboard commands, which the application can use for navigation.
Applications written using a 4GL inherit the input processor from the underlying 4GL environment. If the 4GL does not include robust input processing, modernizing the input functions may not be possible without cooperation from the 4GL vendor.
Buttons, lists and windows
Robust character-based applications should not be limited to text entry, but should include other interface elements where appropriate. Consider the traditional “action” prompt line found in many data entry programs. The same function might be handled by incorporating an “action bar” – a row of “command buttons” that perform the desired action when “pressed”. This ties in with mouse input, and is easily used from the keyboard either using cursor keys and the Enter key, or by attaching function key shortcuts to each button.
Consider using scrolling lists for selections, highlighting the selected list item using an attribute (or Visual Style). The AccuSoft Smart User Interface library includes both single-selection and multiple-selection lists, with multi-columns and column headings.
Depending on the terminal or emulator being used, limited “windowing” support may also be available –either using custom functions built into the emulator, or using the native terminal page memory. Typical Wyse terminals often include 2 pages of memory, allowing a main screen to “pop up” a window, such as a message box. The current page is simply copied to the next page. The page is then incremented and the new window is open. To close the window, simply switch to the previous page. The AccuSoft Smart User Interface library has built-in windowing support using AccuTerm’s scripting language when running with AccuTerm. Otherwise page memory is used if the terminal supports it.
Together, adopting an attractive, familiar look and including intelligent input processing for the keyboard and mouse, a character-based application can both appear and function like typical Windows applications.
The majority of new applications being developed utilize some kind of Graphical User Interface. This is typically a Windows interface, but could also be browser-based, or another GUI environment like Mac or X. There are many advantages to adopting a Graphical User Interface for a Multi-Value application. The application will have an interface that is consistent with other Windows applications, so it will be more familiar to new users. New users will be able to learn the application more quickly because the user interface operates in a consistent and expected manner, and casual users may be able to use the application with little or no training. And when the first impression is critical to making the “sale”, the GUI look puts the Multi-Value application on equal footing with the competition, at least when it comes to that critical first look.
AccuTerm’s GUI Development Environment provides the development tools and runtime environment to create GUIs for Multi-Value applications. AccuTerm GUI consists of a design tool which lets developers design GUI forms for their application using a friendly WYSIWYG designer. AccuTerm acts as the communication link between the host application and the GUI runtime engine (a component of AccuTerm). A library of Multi-Value BASIC subroutines act as the interface between the application and the GUI. Finally, the designer is integrated with a simple code generator, which generates skeleton BASIC code for the application’s user interface, with stub subroutines for all of the events that require handling.
Adapting an existing Multi-Value application to use AccuTerm GUI is not as simple as the other modernization techniques discussed above, but the results are much more dramatic. In order to convert from character-based to true GUI, the user interface and business rules must be separated. Then the user interface layer can be replaced by new code which implements the GUI. The GUI environment is inherently event-driven, meaning that the application responds to events, not keystrokes. Typical events are click, validate, activate, etc.) And with a properly designed application, the order of events should not be constrained (the user should be allowed to click on any field and the application should accommodate). Multi-Value applications using AccuTerm GUI look and work exactly like other Windows applications.
More than a few Multi-Value applications suffer from obsolete, ineffective and frustrating user interfaces. In order to compete in the marketplace with applications developed on other platforms, a Multi-Value application’s user interface may need to be modernized. This includes visual enhancements so that the applications appearance is consistent with typical Windows applications. This is especially important when a quick glance at a trade show is the only impression a prospect may get of the application. Functional improvements in input processing are often required, to ensure that the application behaves in a logical, expected manner. Finally, incorporating a true GUI for the application yields a Multi-Value application that looks and acts exactly like other Windows applications. Any of these enhancements can be effectively used to extend the lifetime of the Multi-Value application.
AccuTerm provides the tools needed to modernize the user interface of most Multi-Value applications. Some modifications are relatively simple. Others are more difficult, but produce more spectacular results. If you have an application that suffers from any of these deficiencies, the time to modernize is now!
Return to Technical Articles