Introducing Host Access Transformation Services

This book provides the information you need to understand the IBM® Host Access Transformation Services (HATS) product, install HATS Toolkit, and use it to develop simple applications. After you have familiarized yourself with the concepts in this book and used HATS, you can find more advanced information in the HATS User's and Administrator's Guide, the HATS Web Application Programmer's Guide, the HATS Rich Client Platform Programmer's Guide, the HATS Advanced Macro Guide, and Developing WebFacing Applications.

What is HATS?

With HATS, you can create Web applications and rich client applications that provide an easy-to-use graphical user interface (GUI) for your 3270 applications running on IBM System z® platforms and your 5250 applications running on IBM i operating system platforms. HATS applications can access 5250 applications without requiring Online Transaction Processing (OLTP) capacity. In this book, these character-based 3270 and 5250 applications are referred to as host applications. You can also create service-oriented architecture (SOA) assets using Web services that provide standard programming interfaces to business logic and transactions contained within host applications. Data from video terminal (VT) emulation screens can also be accessed.

HATS applications can be given a modern appearance. HATS Web applications can be developed with an interface that matches your company's Web or portal pages, and your users can access them through their Web browsers. HATS Web applications can also be developed to provide access from mobile devices such as cellular phones, data collection terminals, and personal digital assistants (PDAs).

HATS rich client applications can be developed to run in an Eclipse Rich Client Platform (RCP) implementation, in Lotus Notes®, or in the Lotus® Expeditor Client to provide native client applications targeted for a user's desktop. For more information about the Eclipse RCP environment see http://www.eclipse.org/home/categories/rcp.php. For more information about Lotus Notes, visit IBM Knowledge Center at http://www.ibm.com/support/knowledgecenter/SSKTMJ_8.5.3. For more information about the Lotus Expeditor Client, visit IBM Knowledge Center at http://www.ibm.com/support/knowledgecenter/SSVHEW_6.2.0.

Note:
Throughout this document, configuration settings that apply only to HATS Web applications and EJB applications unless otherwise noted, are marked with  Web-only . Configuration settings that apply only to HATS rich client platform applications are marked with  RCP-only .

HATS has two components:

The following figure shows the stages of development, deployment, and runtime for a HATS Web application. If the application is a portlet, the stages are similar except that the portlet is installed and run on a WebSphere Portal system.

  1. The developer uses the HATS Toolkit to develop and test a HATS Web application.
  2. When ready, the developer deploys the HATS application by exporting it as a Java™ EE application and installing and running it on a WebSphere Application Server system.
  3. Using a Web browser, the user accesses the HATS application.
  4. The HATS runtime connects to the target host system through either a Telnet or a WebFacing server.
  5. As the user interacts with the host through the HATS application, the HATS runtime transforms host screens to a GUI.
Figure 1. HATS Web application
HATS Web application

The following figure shows the stages of development, deployment, and runtime for a HATS rich client application.

  1. The developer uses the HATS Toolkit to develop and test a HATS rich client application.
  2. When ready, the developer exports the HATS application as an Eclipse feature, creates an update site containing the application feature, and uploads it to a Web server for deployment.
    Note:
    Different methods can be used for deploying HATS rich client applications. For example, Lotus Expeditor Server can be used to centrally manage the software deployed to Lotus Expeditor Client systems. For more information see the HATS User's and Administrator's Guide.
  3. The user, running a rich client platform, downloads and installs the HATS application feature from the update site.
  4. The user starts and accesses the HATS application using the rich client platform environment.
  5. The HATS runtime connects to the target host system through either a Telnet or a WebFacing server.
  6. As the user interacts with the host through the HATS application, the HATS runtime transforms host screens to a GUI.
Figure 2. HATS rich client application
HATS rich client application

A HATS 3270 example

Imagine you need to create a GUI for a 3270 host application. With HATS you have a choice of providing the GUI using a Web application (including portlets) or a rich client application. For more information about the use of HATS portlets and rich client applications, including advantages, considerations, and limitations, see the WebSphere Portal and HATS chapter and the Developing and deploying rich client applications chapter in the HATS User's and Administrator's Guide.

The following figure shows a screen from the host application:

Figure 3. A host terminal screen
A host terminal screen

If you decide to create a Web application that provides the GUI, you use a wizard to create a simple HATS Web project. You give your project a name and specify the host machine where the host application runs. You take all the defaults and add no customization. After just a few minutes, you use the preview function to see the host screen transformed to this:

Figure 4. A default Web transformation
A default Web transformation

As you can see, HATS has added a banner across the top of the screen and a navigation area on the left, but has made minimal changes to the original host screen. This Web page may not yet be what you want to show to your users. Now you do some customizations. You change your template. After each modification you make, you preview the screen to evaluate your changes. Soon your page looks like this:

Figure 5. A customized Web transformation
A customized Web transformation

After a very short time, you have transformed the host screen into an attractive Web page that provides all the function of the host screen and more, and is accessible through a Web browser. You decided to switch to a template more suited to your business. You hid unnecessary information, and created a table to display only required input fields. You provided a drop-down list of valid values for an input field and use of a calendar widget for another input field. Finally, you changed the size and location of some of the text and provided navigation buttons.

If instead of creating a Web application, you decide to create an application that runs on a rich client platform, you also perform basically the same steps. You use a wizard to create a simple HATS rich client project. You give your project a name and specify the host machine where the host application runs. You take all the defaults and add no customization. After just a few minutes, you use the preview function to see the host screen transformed to this:

Figure 6. A default rich client transformation
A default rich client transformation

As you can see, HATS has added a banner down the left side of the page, but has made minimal changes to the original host screen. This GUI may not yet be what you want to show to your users. Now you do some customizations. You change your template. After each modification you make, you preview the screen to evaluate your changes. Soon your transformation looks like this:

Figure 7. A customized rich client transformation
A customized rich client transformation

After a very short time, you have transformed the host screen into an attractive GUI that provides all the function of the host screen and more, and is accessible using a rich client application. You decided to switch to a template more suited to your business. You hid unnecessary information, and display only required input fields. You provided a drop-down list of valid values for an input field, changed the size and location of some of the text, and provided navigation buttons.

Whether creating a Web application or a rich client application, you might decide that this is enough customization, but with HATS you can add much more. For example, you can:

How to add these and other types of customization is discussed in the remainder of this book and in the HATS User's and Administrator's Guide.

A HATS 5250 example

Imagine you need to create a GUI for a 5250 host application. With HATS you have a choice of providing the GUI using a Web application or a rich client application. For more information about the use of HATS portlets and rich client applications, including advantages, considerations, and limitations, see the WebSphere Portal and HATS chapter and the Rich client platform and HATS chapter in the HATS User's and Administrator's Guide.

The following figure shows a screen from the host application:

Figure 8. A host terminal screen
A host terminal screen

If you need to create a Web application that provides the GUI, you use a wizard to create a simple HATS Web project. You give your project a name and specify the host machine where the host application runs. You take all the defaults and add no customization. After just a few minutes, you use the preview function to see the host screen transformed to this:

Figure 9. A default Web transformation
A default Web transformation

As you can see, HATS has added a banner across the top of the screen and a navigation area on the left, but has made minimal changes to the original host screen. This Web page is not yet what you want to show to your users. Now you do some customization. After each change you make, you preview the screen to evaluate your changes. Soon your page looks like this:

Figure 10. A customized Web transformation
A customized Web transformation

After a very short time, you have transformed the host screen into an attractive Web page that provides all the function of the host screen and more, and is accessible through a Web browser. You decided to switch to a template more suited to your business. You hid unnecessary information and display only required input fields. You inserted some data on the screen to aid the user in constructing correct search conditions, provided a drop-down list of valid values for an input field, changed the size and location of some of the text, and provided navigation buttons.

If instead of creating a Web application, you need to create an application that runs on a rich client platform, you perform basically the same steps. You use a wizard to create a simple HATS rich client project. You give your project a name and specify the host machine where the host application runs. You take all the defaults and add no customization. After just a few minutes, you use the preview function to see the host screen transformed to this:

Figure 11. A default rich client transformation
A default rich client transformation

As you can see, HATS has added a banner down the left side of the page, but has made minimal changes to the original host screen. This GUI is not yet what you want to show to your users. Now you do some customization. After each change you make, you preview the screen to evaluate your changes. Soon your transformation looks like this:

Figure 12. A customized rich client transformation
A customized rich client transformation

After a very short time, you have transformed the host screen into an attractive GUI that provides all the function of the host screen and more, and is accessible using a rich client application. You decided to switch to a template more suited to your business. You hid unnecessary information and display only required input fields. You inserted some data on the screen to aid the user in constructing correct search conditions, provided a drop-down list of valid values for an input field, changed the size and location of some of the text, and provided navigation buttons.

Whether creating a Web application or a rich client application, you might decide that this is enough customization, but with HATS you can add much more. For example, you can:

How to add these and other types of customization is discussed in the remainder of this book and in the HATS User's and Administrator's Guide.

What's new in HATS

New supported environments

Application development and runtime environments

HATS V9.5 extends the supported application development environment to Rational SDP V9.5. New HATS runtime environments include WebSphere Application Server V8.5.5 and Eclipse V4.4.

HATS V9.5 does not support Rational SDP V9.0 or WebSphere Application Server V6.1.

Note:
For the current list of prerequisites, see Prerequisites.

For up-to-date support considerations, see "IBM Host Access Transformation Services 9.5 - Known issues and workarounds" at http://www-01.ibm.com/support/docview.wss?uid=swg27046998.

Support for IBM Bluemix Server

With HATS V9.5, you can create, run, and debug HATS applications on the IBM Bluemix Server. This enables easy integration of HATS applications into a hosted cloud environment on IBM Bluemix.

Support for Dojo AMD

HATS projects are Dojo Asynchronous Module Definition (AMD) format compliant.

HATS toolkit usability enhancements

With the HATS Visual Macro Editor, you can now add trace actions, custom screen recognition, conditional screen descriptors, and set the recognition limit and pause time. Other enhancements include the ability to add custom screen recognition classes through the user interface, the inclusion of cursor positioning in screen captures, the ability to set string attributes when creating a screen customization, and showing if the "uselogic" attribute is enabled.

TLS v1.1 and v1.2 connectivity

HATS V9.5 includes the ability to choose the Java Secure Socket Extensions (JSSE) for secure connections. This will result in HATS trying the highest level of secure connection first, TLS 1.2, then TLS 1.1, and then TLS 1.0 connectivity.

Support for the latest Struts framework

HATS has ability to use Struts 2.3.16.3 to build web pages based on Integration Objects. WebFacing web projects now use Struts 2.3.16.3.

Removal of Java Visual Editor support for RCP

Java Visual Editor support for rich client application is removed from HATS V9.5. You cannot use the visual editor to edit rich client transformations and templates.

Removal of IBM Portlet API support

The support of IBM Portlet API is removed from HATS V9.5.

Coexistence

HATS V6, V7.0, V7.1, V7.5, V8.0, V8.5, V9.0, and V9.5 can coexist, within their own individually supported Rational SDP offerings, on the same development system with HATS V9.5. It is also possible for HATS V9.5 to be installed multiple times on the same system. If you have multiple supported Rational SDP offerings installed on your system, HATS V9.5 can be installed into each of them.

Migration

If you are a Host Publisher V4, HATS V5, V6, V7.0, V7.1, V7.5, V8.0, V8.5, V9.0, or V9.5 user, you can migrate your projects to HATS V9.5.

HATS V4 LE, HATS V5 LE, and HATS V4 projects cannot be migrated directly to HATS V8.0, V8.5, or V9.5. To migrate these projects you must first migrate them to an interim release of HATS, for example, V5, V6, V7, V7.1, or V7.5, and then migrate them from the interim release to HATS V8.0, V8.5, V9.0, or V9.5. See the documentation for your previous release of HATS for information about migrating HATS projects.

For more information about migrating to HATS V9.5, see the HATS User's and Administrator's Guide

Serviceability

IBM Support Assistant

The IBM Support Assistant (ISA) can help you simplify software support, reduce support costs, and improve your ability to resolve software problems in-house quickly. ISA is a free local software serviceability workbench that helps you resolve questions and problems with IBM software products. For more information see the ISA Web site at http://www.ibm.com/software/support/isa/.

HATS provides a plug-in for ISA V4.x. The HATS plug-in provides links to the HATS Knowledge Center, home page, support site, education assistant site, and other sites. You can search these sites for information that may help you resolve a problem. For information about how to install the HATS plug-in, see the section, Use the IBM Support Assistant, in HATS Troubleshooting.

Roles and skills

A number of different people, each with different roles within your organization, can be users of HATS. Depending on the role, skills ranging from a beginning user to an advanced developer may be required. The following roles and skills are involved in HATS application development, deployment, administration, and usage:

Casual Web developer

A user of the HATS Toolkit. The developer creates and edits a HATS Web application using Rational SDP and the HATS perspective.

Skills expected:
Creating a default application may require minimal HTML, JSP, and cascading style sheet (CSS) skills. Editing transformations and templates may require minimal to advanced HTML, JSP, CSS, and JavaScript skills.

Advanced Web developer

A HATS Toolkit user who is already familiar with Rational SDP and advanced topics such as servlets, EJBs, Struts, JSF, and Web services. The developer creates and edits a HATS Web application using Rational SDP and the HATS perspective. The developer also creates business objects (Integration Objects) based on HATS macros, and integrates these with other back-end systems.

Skills expected:
Highly skilled in HTML, JSP, CSS, JavaScript, and Java EE application environments.

Casual rich client developer

A user of the HATS Toolkit. The developer creates and edits a HATS rich client application using Rational SDP and the HATS perspective.

Skills expected:
Creating a default application may require minimal Java skills. Editing transformations and templates requires skills using the Java Editor and minimal to advanced Java skills.

Advanced rich client developer

A HATS Toolkit user who is already familiar with Rational SDP and advanced topics such as SWT widgets and Eclipse plug-ins. While creating and editing a HATS rich client application using Rational SDP and the HATS perspective, the developer might create custom components and widgets, integrate business logic, and create custom perspectives.

Skills expected:
Highly skilled in Java, SWT, and Eclipse plug-in development.

User

HATS has two types of users. The browser-based user and the rich client-based user of a HATS application. The browser-based user invokes the application, either through a direct URL request to the application or through a portal, and uses the resulting host session to work with a host application. The rich client-based user clicks an icon that will establish a host session.

Skills expected:
Web browser or rich client platform common usage is all that is required.

HATS administrator

The person who administers HATS Web applications including portlets. This may be the same person as the WebSphere Application Server administrator or the WebSphere Portal administrator. This person has the ability to monitor the number of HATS sessions and manually stop connections in error cases. Currently, this role only exists for the HATS Web application and portlet environments.

Skills expected:
Web browser common usage along with HATS problem determination skills.

WebSphere administrator

The person who administers WebSphere Application Server. The WebSphere administrator is responsible for deploying HATS applications that have been packaged as .ear files and transferred to the production system. This role exists for the HATS Web application environment.

Skills expected:
Web browser common usage along with HATS and WebSphere Application Server problem determination skills.

Rich client administrator

The person responsible for installing, provisioning, and deploying HATS rich client applications.

Skills expected:
Skills with maintaining update sites along with rich client platform and HATS problem determination skills.

WebFacing developer

The user of the IBM WebFacing Tool for IBM i feature. Using Rational SDP and the WebFacing perspective, the WebFacing developer creates and edits a WebFacing application to convert IBM i data description specification (DDS) display file source members into a Web-based user interface for 5250 programs.

Skills expected:
Creating an application requires knowledge of the location of the DDS source required by the 5250 program; customizing the Web interface may require HTML, JSP, CSS, and JavaScript skills.

Independent software vendors

Independent software developers use the HATS Toolkit to create custom applications that are resold to other customers.

Accessibility

Accessibility features help a user who has a physical disability, such as restricted mobility, limited vision, or other special needs, to use software products successfully. As a set of plug-ins of Rational SDP, HATS takes advantage of the accessibility capabilities provided by Rational SDP. These are the major accessibility capabilities in Rational SDP:

Accessibility when using HATS

Keep the following in mind when using HATS:

Notes:
  1. HATS supports accessibility for Web applications only when using Internet Explorer.
  2. HATS supports accessibility for rich client applications in both the application and transformation views.

Keyboard shortcuts

Ctrl + F9
When a region of the host screen is selected, a new dialog box opens up that displays the selected text.

Where can I find more information about accessibility?

For more information about accessibility, refer to the following Web sites:

Where can I find information about HATS?

The following HATS information is available before you install HATS:

In addition to the information available before installing HATS, the following information is available on the system after installing HATS: