Client-Side Features (at the web browser)
High Performance and Full Function at the Client
Users of desktop and java-based terminal emulators are accustomed to fast screen refreshes and keystroking responsiveness. Any web client should meet or exceed the speed of keystroking, screen refreshes and updates from the host application currently experienced by existing users. Any testing of a product for responsiveness must be performed in a real-life network connection, not on the same PC that trial software is installed.
No Plug-in requirements for Java or ActiveX
These approaches were popular before the security of plug-ins became a target of hackers and before the widespread use of devices that run web browsers but do not support the use of Java or ActiveX such as tablets.
Works with both new and old PC’s and browsers
Many workers may still have Windows 7 or an older browser which do not support HTML5 technologies like web sockets and the HTML5 Canvas. If advanced HTML5 features are required for web terminal emulation functionality it can cause problems for these users.
Block Mode for TN3270 and TN5250
Most new HTML Web Terminal Emulator products place the logic at the server and process every keystroke over the network. Any viable replacement for existing TN3270 and TN5250 emulators cannot use this technique as users will immediately notice the lag while performing data entry.
Support for Multiple Languages at the Client
Users of a web terminal emulator should be able to view prompts, labels and messages in their native language, and be able to select that language as a preference.
Full Function Clipboard Support
The Clipboard is very important for users of terminal-based applications as data is copied to and from other desktop applications. Your choice for a web terminal emulator should support both single text strings as well as rectangular blocks for both Copy and Paste. Users will also quickly complain if there isn't support for column detection when pasting multi-row clipboad blocks into Excel.
Desktop and Java clients provide keystroke buffering so that if a user “keys-ahead” during a slow host response, the keys will be processed once the screen session is ready and the keyboard unlocked. A web terminal emulation solution should also support keyboard buffering or users will suffer reduced productivity and increased error rates.
Font Scaling and Resizing
The web terminal emulation solution should resize the fonts used in the client session to match the size of the browser window. When users open the web terminal emulator in a new browser, it should scale and resize to fit the window; when the user resizes the browser, the fonts should resize to match as closely as possible the new window geometry.
Support for both simple and advanced macros
Users are accustomed to being able to record keystrokes, name the recording and play it back. In addition, being able to assign a hot-key to a macro is also a common and desirable feature.
A web terminal emulator’s macro scripting options should also offer advanced functionality beyond simple record-and-playback of keystrokes. This should meet common requirements such as applying a spreadsheet’s contents to a series of data entry screens.
Many organizations have integrated older web-based terminal emulators (based on Java or ActiveX) into their web applications.
The end-user should be able to customize the keyboard actions as well as select the active color scheme for the terminal window. Other customizations include selection of hot-keys for activating named macros; cursor style selection; language for prompts and so on.
Server, Network and Security Features
Efficient use of Server resources
As any web-based terminal emulator will require one or more web servers within the network, each session or block of sessions should impose a low CPU and memory impact to ensure that users will be serviced well without excessive hardware requirements. Especially for Cloud deployment, a CPU-heavy implementation should be avoided, such as one that applies DEFLATE Websocket compression to overcome excessive buffer sizes.
A web terminal emulation solution should not require HTML5 web sockets but should use them if they are compatible across the network from the client PC to the web server. This may include proxy servers, firewalls or PC anti-virus programs that break web sockets. Any use of web sockets should be flexible and revert to traditional AJAX HTTP communications when needed.
HTML-based terminal emulation can be implemented in a wide variety of techniques. A good web terminal emulator utilizes compression and an efficient protocol for updating the terminal session in the web browser. The data flow between the server and the browser should not increase the transmission sizes and if possible, reduce them to maintain response time.
For block mode protocols like TN3270, transmission of keystrokes should only occur when the user presses ENTER or another AID/Function key. Solutions that transmit every keystroke and then refresh the display with the results vastly increase the number of packets flowing in the network and can seriously impact performance.
Compatibility with strong security and multi-factor authentication
A terminal emulation solution should include support for Windows security (Active Directory) as well as any additional authentication technique that an organization may implement as security challenges continue in the industry. Examples include Multi-Factor Authentication solutions and Cloud security and identity solutions such as for Azure Active Directory from Microsoft. Inventu Viewer+ supports Windows Security, Azure Active Directory, Google SignIn and SAML 2.0 (Supported by Okta, SalesForce and others);
Comprehensive and Functional Configuration
To support migration from highly flexible connection definitions provided by products like Host-on-Demand, your Web Terminal Emulator solution should provide the ability to define multiple selection Views and flexible Connection Profiles for multiple hosts as well as multiple terminal emulation definitions. In addition, there should be an ability to map a user's security group membership to visibility of Views and Profiles as part of making access easier as well as more controlled.
I.T. staff should be able to implement server-side macros that utilize the full power of c# or VB.NET to implement integration tasks currently performed using desktop macros written in VBA (Visual Basic for Applications). Inventu Viewer+ supports this functionality so that users can easily run macros to enter spreadsheet data, create documents from screens and so on.
Host Connection behind the firewall
This enables the use of stronger security on access to the mainframe and enables strong TLS/SSL certificates without impacting mainframe performance. An additional layer of authentication can also be implemented as the user is entering the system using HTTP/HTTPS, which is compatible with all the latest authentication techniques.
Support for server clustering
When multiple servers are licensed for a set number of concurrent sessions, if one or more of the servers is down for any reason, the other servers in the cluster should allow connections up to the licensed maximum.
Clustered servers should also support being taken gracefully offline (put in hold state) so that 24x7 operations can run while individual servers are be updated. Whether going with a cluster for ease of maintenance and redundancy or for scaling purposes with thousands of sessions, load balancing should use existing network components such as an F5 BigIP or Microsoft Application Request Routing (ARR), not a proprietary implementation.
Separate license servers add overbearing complexity, particularly if upgrades or maintenance require extensive manual procedures!
Default settings for keyboard actions and color schemes should be customizable at the servers so that new connections will have standardized settings.