Glossary
- action
- A defined task that an application performs
on a managed object as a result of an event, such as a host screen matching
the screen recognition criteria specified for a screen event. A list of actions
is part of the definition of each event.
- ADB
- See application data
buffer.
- administrative console
- The HATS administrative
console is a Web based utility that provides views and functions to manage
licenses and connections, set log and trace settings, view messages and traces,
and perform problem determination for HATS Web applications.
- application
- See HATS application.
- application data buffer
- The format of data that
is returned by the WebFacing Server for consumption by the WebFacing application.
- application event
- A HATS event that is triggered
by state changes in the application's life cycle. Examples of application
events include a user first accessing a HATS application (a Start event),
or an application encountering an unrecognized screen (an Unmatched Screen
event).
- application keypad
- A set of buttons or links representing
HATS application-level functions. (Contrast with host keypad.)
- artifact
- See resource
- background connection
- Any connection defined in
a HATS application other than the default connection. HATS does not transform
screens from background connections. (Contrast with default
connection.)
- bidirectional (bidi)
- Pertaining to scripts such
as Arabic and Hebrew that generally run from right to left, except for numbers,
which run from left to right.
- BMS map
- A screen definition file used with Basic
Mapping Support in CICS(R). A BMS map defines a set of fields which are to be
displayed as a group by a CICS application
- business logic
- Java(TM) code that performs advanced functions,
such as interacting with other applications, databases, or other systems accessible
via Java APIs. Business logic is invoked as an action in an application or
screen event.
- checkin screen
- The screen identifying the host
screen that should be active for a connection to be considered ready to be
returned to the connection pool. If the application is not on the screen
specified by the checkin screen, the connection will be discarded or recycled
in attempt to return the connection to the host screen specified by the checkin
screen. The checkin screen is only meaningful if connection pooling is specified
for a connection.
- component
- A visual element of a host screen, such
as a command line, function key, or selection list. HATS applications transform
host components into widgets.
- connection
- A set of parameters used by HATS, stored
in an .hco file, to connect to a host application. (See also default connection and background connection.)
- connection pool
- A group of host connections that
are maintained in an initialized state, ready to be used without having to
create and initialize them.
- credential mapper
- The component of Web Express
Logon that handles requests for host credentials, which have been previously
authenticated by a network security layer. (See network security
layer.)
- DDS map
- Data Description Specification map. These
maps define the layout and behavior of the presentation space for System i(TM) terminal
applications.
- Debug
- For rich client projects, the same as Run,
and in addition enables you to:
- Use the display terminal to see host screens as they are navigated while
testing your project
- See debug messages in the Rational SDP console
- See changes you make to your project, for example changing the template
or a transformation, without having to restart your application
- Modify and test runtime settings, defined in the runtime-debug.properties
file, without modifying the settings, defined in the runtime.properties file,
that are deployed to the runtime environment
- Step through Java code, such as HATS business logic
- Debug on Server
- For Web projects, the same as Run
on Server, and in addition enables you to:
- Use the display terminal to see host screens as they are navigated while
testing your project
- See debug messages in the Rational SDP console
- See changes you make to your project, for example changing the template
or a transformation, without having to restart your application on the test
server
- Modify and test runtime settings, defined in the runtime-debug.properties
file, without modifying the settings, defined in the runtime.properties file,
that are deployed to the runtime environment
- Step through Java code, such as HATS business logic
- default connection
- The connection on which HATS transforms
and presents host application screens to the user. Also
referred to as transformation connection. (Contrast
with background connection.)
- default rendering
- The method used by HATS to render
parts of the host screen for which no specific transformation is specified.
- deploy
- To
make a HATS application ready for use in a runtime environment. For HATS Web
applications, this includes exporting the HATS project as a J2EE application,
that is, as an .ear file, and installing it on WebSphere(R) Application Server. For HATS rich
client applications, this includes exporting the HATS project as an Eclipse
feature and installing it on individual client systems, either as a stand-alone
Eclipse application or from an update site to an existing Eclipse runtime
environment.
- descriptor
- See screen recognition
criteria.
- developer
- The person who uses HATS Toolkit to develop
applications; also application developer or Web developer. (Contrast with user.)
- Device Runtime Environment (DRE)
- A package containing
other runtime environments, including the J2SE 5.0 runtime, which is required
in order to run HATS rich client applications in Expeditor. The DRE installs
into both the development and tooling environments of Rational(R) Application
Developer and the runtime environment for Expeditor Client.
- display terminal
- A terminal window that displays
host screens you can use while testing and debugging to observe interactions
between a HATS application and a host application at runtime. You can also
interact with the host application using host screens in the terminal window.
- Eclipse
- An open-source initiative that provides
ISVs and other tool developers with a standard platform for developing plug-compatible
application development tools. Eclipse is available for download from http://www.eclipse.org.
- editor
- An application that enables a user to modify
existing data. In HATS Toolkit, editors are used to customize resources that
have been created by wizards.
- Enhanced Non-Programmable Terminal User Interface (ENPTUI)
- Enables an enhanced interface on non-programmable terminals (NPT)
and programmable work stations (PWS) over the 5250 full-screen menu-driven
interface, taking advantage of 5250 display data stream extensions.
- enterprise archive (EAR)
- A specialized Java archive
(JAR) file, defined by the J2EE standard used to deploy J2EE applications
to J2EE application servers. An EAR file contains enterprise beans, a deployment
descriptor, and Web archive (WAR) files for individual Web applications.
(Sun)
- Enterprise JavaBeans(TM) (EJB)
- A component
architecture defined by Sun Microsystems for the development and deployment
of object-oriented, distributed, enterprise-level applications. (Sun)
- event
- A HATS resource that performs a set of actions
based on a certain state being reached. There are two types of HATS events,
application events and screen events.
- Expeditor Client
- A standalone client of the Lotus(R) Expeditor product, installed on a user's machine.
- Expeditor Toolkit
- A toolkit in the Lotus Expeditor
product used to develop applications, which installs into Rational Application
Developer and provides a client test environment. The Expeditor Client does
not need to be installed on the development machine.
- export
- To collect the resources of a HATS project,
along with the necessary executable code, into an application EAR file (for
Web applications) or Eclipse feature (for rich client applications) in preparation
for deploying the application.
- Extensible Markup Language (XML)
- A standard metalanguage
for defining markup languages that was derived from and is a subset of SGML.
- GB18030
- GB18030 is a new Chinese character encoding
standard. GB18030 has 1.6 million valid byte sequences and encodes characters
in sequences of one, two, or four bytes.
- global rule
- A rule defining how the rendering of
specific input fields should be modified based on certain criteria. Global
rules are used in customized screens and screens rendered using default rendering.
Global rules can be defined at the project level or at the screen event level.
- global variable
- A variable used to contain information
for the use of actions. The values of global variables can be extracted from
a host screen or elsewhere, and can be used in templates, transformations,
macros, Integration Objects, or business logic. A global variable can be a
single value or an array, and it can be shared with other HATS applications
sharing the same browser session.
- HATS
- See Host Access Transformation
Services.
- HATS application
- An application that presents a
version of a host application to users, either as a Web-enabled application
deployed to WebSphere Application Server, a portlet deployed to a WebSphere Portal, or as an Eclipse client-side processing plug-in deployed
to an Eclipse rich client platform such as Lotus Expeditor Client. A HATS application
is created in HATS Toolkit from a HATS project and deployed to the applicable
environment. The deployed application might interact with other host or e-business
applications to present combined information to a user.
- HATS EJB project
- A project that contains the HATS
EJB and Integration Objects that other applications can use to get host data.
A HATS EJB project does not present transformed screens from a host application.
- HATS entry servlet
- The servlet that is processed
when a user starts a HATS Web application in a browser.
- HATS project
- A collection of HATS resources (also
called artifacts), created using HATS Toolkit wizards and customized using
HATS Toolkit editors, which can be exported to a HATS application.
- HATS Toolkit
- The component of HATS that runs on Rational SDP and enables you to work with HATS projects to create HATS
applications.
- Host Access Transformation Services (HATS)
- An IBM(R) software
set of tools which provides Web-based access to host-based applications and
data sources.
- host component
- See component.
- host keypad
- A set of buttons or links representing
functions typically available from a host keyboard, such as function keys
or the Enter key. (Contrast with application keypad.)
- host simulation
- Host simulation enables you to
record host simulation trace files that can be saved and then used instead
of a live host connection. The recorded trace files can be played back to
create screen captures, screen events, and screen transformations using the
host terminal function, create and test macros using the host terminal function,
test HATS applications using the Rational SDP local test environment, and,
along with other traces and logs, aid in troubleshooting a failing scenario
in a runtime environment.
- host simulation trace
- Host simulation trace files
record host screens and transactions that can be saved and played back later
instead of using a live host connection. Trace files can be recorded using
the host terminal function or while in the runtime environment.
- host terminal
- A HATS Toolkit tool. A session tied
to a particular HATS connection, which the HATS developer can use to capture
screens, create screen customizations, and record macros.
- HTML
- Hypertext Markup Language.
- HTML widget
- See widget
- Integration Object
- A Java bean that encapsulates an interaction
with a host screen or a series of host screens. Integration Objects are constructed
from macros and can be included in Web services or HATS EJB projects. Integration
Objects cannot be used in rich client platform applications.
- interoperability
- The ability of a computer or program
to work with other computers or programs.
- interoperability runtime
- Common runtime used by
a combined HATS/WebFacing application to provide management of common connection
to the backend host. This runtime decides whether data being returned by the
WebFacing server should be handled by the HATS or WebFacing part of the application.
- Java 2 Platform Enterprise Edition (J2EE)
- An environment for developing and deploying enterprise applications, defined
by Sun Microsystems Inc. The J2EE platform consists of a set of services,
application programming interfaces (APIs), and protocols that provide the
functionality for developing multitiered, Web-based applications.
(Sun)
- JavaServer Faces (JSF)
- A framework for building
Web-based user interfaces in Java. Web developers can build applications
by placing reusable UI components on a page, connecting the components to
an application data source, and wiring client events to server event handlers.
(Sun)
- JavaServer Pages (JSP)
- A server-side scripting
technology that enables Java code to be dynamically embedded within
Web pages (HTML files) and run when the page is served, returning dynamic
content to a client. (Sun)
- JavaServer Pages Standard Tag Library (JSTL)
- A
standard tag library that provides support for common, structural tasks, such
as: iteration and conditionals, processing XML documents, internationalization,
and database access using the Structured Query Language (SQL). (Sun)
- JSF
- See JavaServer Faces.
- JSP
- See JavaServer Pages.
- JSR 168
- The Java Specification Request that defines
a portlet specification to enable interoperability between portlets and portals
and to define a set of APIs for portal computing addressing the areas of aggregation,
personalization, presentation and security.
- JSTL
- See JavaServer Pages
Standard Tag Library.
- keyboard support
- The ability for a developer to
enable a user to use a physical keyboard to interact with the host when the
application is running in a Web browser or rich client environment. The developer
also decides whether to include a host keypad, an application keypad, or both,
in a project. If keypads are included, the developer decides which keys are
included and how those keys and the keypad appear in the client interface.
- keypad support
- The ability for a developer to enable
a user to interact with the host as if the physical keys on a keyboard were
pressed, or to perform tasks related to the application, such as viewing their
print jobs or refreshing the screen. See also application
keypad and host keypad.
- linked HATS/WebFacing project
- A project created
by linking a single HATS Web project with a single WebFacing project for the
purpose of creating an enterprise application that includes a HATS Web application
interoperating with a WebFacing application and sharing a connection to a
5250 backend host.
- macro
- A macro, stored in a .hma file, automates
interactions with the host. It can send commands to the host, enter data into
entry fields, extract data from the host, and be used to navigate screens
on behalf of the user.
- Model 1 Web pages
- A single JSP that contains the
information to be presented to the user, formatting tags that specify how
the information is displayed, and logic that controls the order in which pages
are displayed. (Contrast with Struts Web pages.)
- network security layer
- Software that is responsible
for authenticating users and authorizing them to access network resources,
such as IBM Tivoli(R) Access Manager.
- Operator Information Area (OIA)
- OIA is the area
at the bottom of the host session screen where session indicators and messages
appear. Session indicators show information about the workstation, host system,
and connectivity.
- perspective
- In the Rational SDP workbench, a group of views that
show various aspects of the resources in the workbench. The HATS perspective
is a collection of views and editors that allow a developer to create, edit,
view, and run resources which belong to HATS applications.
- pooling
- See connection pool.
- portal
- An integrated Web site that dynamically
produces a customized list of Web resources, such as links, content, or services,
available to a specific user, based on the access permissions for the particular
user.
- print support
- The ability for a developer to specify
a printer session to be associated with a host session, and enable the user
to view host application print jobs, send them to a printer, or save them
to disk. Print support is available only for the default connection
- Profile
- For rich client projects, the same as Run,
and in addition enables you to locate the operations that require the most
time, and identify actions that are repeated, to eliminate redundancy. You
can use this function for performance analysis, helping you to get a better
understanding of your application.
- Profile on Server
- For Web projects, the same as
Run on Server, and in addition enables you to locate the operations that require
the most time, and identify actions that are repeated, to eliminate redundancy.
You can use this function for performance analysis, helping you to get a better
understanding of your application.
- project
- A collection of HATS resources (also called
artifacts) that are created using HATS Toolkit wizards and customized using
HATS Toolkit editors. These resources are exported as a HATS application.
There are five types of HATS projects; Web, portlet, EJB, rich client, and
for purposes of administering HATS Web (including portlet and EJB) applications,
HATS administrative console projects. See HATS project or HATS EJB project.
- Rational Software Delivery Platform (Rational SDP)
- A family of IBM software products that are based on the Eclipse open-source
platform and provide a consistent set of tools for developing e-business applications.
- rendering set
- A rendering set is configured by
creating a prioritized list of rendering items. Each rendering item defines
a specific region in which a specified host component is recognized and then
rendered using a specified widget.
- resource
- Any of several data structures included
in a HATS project. HATS resources include templates, screen events, transformations,
screen captures, connections, and macros. Other Rational SDP plug-ins sometimes call
these "artifacts."
- rich client
- A plug-in designed to run on
the Eclipse Rich Client Platform in a client environment, and designed to
provide an enhanced user experience by the appearance and behavior native
to the platform on which it is deployed.
- Run
- For rich client projects, a function in Rational SDP that enables you to test your HATS rich client projects
in an Eclipse or Lotus Expeditor Client instance. In this mode you can modify
and test the runtime settings, defined in the runtime.properties file, that
are deployed to the runtime environment. Be aware that any changes made to
the runtime settings while testing in this mode are retained and become effective
when you deploy the HATS application to a runtime environment.
- Run on Server
- For Web projects, a function in Rational SDP that enables you to test your HATS Web and portlet projects
in a WebSphere Application Server or WebSphere Portal instance, as appropriate.
In this mode you can modify and test the runtime settings, defined in the
runtime.properties file, that are deployed to the runtime environment. Be
aware that any changes made to the runtime settings while testing in this
mode are retained and become effective when you deploy the HATS application
to a runtime environment.
- runtime settings
- Log, trace, and problem determination
settings defined in the runtime.properties file that are deployed to the runtime
environment.
- screen capture
- An XML representation of a host
screen, stored in a .hsc file, used to create or customize a screen customization,
screen combination, transformation, or global rule. Screen captures are useful
because they allow you to customize an application even when not connected
to the host.
- screen combination
- A type of HATS screen event
designed to gather output data from consecutive, similar host screens, combine
it, and display it in a single output page. The screen combination definition,
stored in a .evnt file, includes a set of screen recognition criteria for
both the beginning and ending screens to be combined, how to navigate from
screen to screen, and the component and widget to use to recognize and render
the data gathered from each screen.
- screen customization
- A type of screen event designed
to perform a set of actions when a host screen is recognized. A screen customization
definition, stored in a .evnt file, includes a set of criteria for matching
host screens, and actions to be taken when a host screen matches these criteria.
- screen event
- A HATS event that is triggered when
a host screen is recognized by matching specific screen recognition criteria.
There are two types of screen events, screen customizations and screen combinations.
- screen recognition criteria
- A set of criteria that
HATS uses to match one or more screens. When a host displays a screen, HATS
searches to determine whether the current host screen matches any of the screen
recognition criteria defined for any screen event in your project. If HATS
finds a match, the defined actions for the screen event are performed.
Screen recognition criteria are also used in the process of recording a macro;
in this context they are sometimes called descriptors.
- Secure Sockets Layer (SSL)
- A security protocol
that provides communication privacy. SSL enables client/server applications
to communicate in a way that is designed to prevent eavesdropping, tampering,
and message forgery. SSL was developed by Netscape Communications Corp. and
RSA Data Security, Inc.
- source
- The files containing the markup language
that define a HATS project or one of its resources. Also the name of a folder
contained in each HATS project.
- SSL
- See Secure Sockets Layer.
- Standard Widget Toolkit (SWT)
- An Eclipse toolkit
for Java developers that defines a common, portable, user interface API that
uses the native widgets of the underlying operating system.
- Struts Web pages
- Web pages built using the Apache
Software Foundation's Struts open-source framework for creating Java web
applications. This method of building Web pages creates class files that set
values and contain getters and setters, input and output JSPs, and a Web diagram
to display the flow and logic of the Web pages. (Contrast with Model 1 Web pages.)
- SWT
- See Standard Widget
Toolkit.
- system screen
- A System i screen for which DDS maps are not
available. System screen is specific to an application on System i that has
been WebFaced.
- template
- A template, stored in a .jsp file (for
Web projects) or a .java file (for rich client projects), controls the basic
layout and style, such as color and font, of the application. It also defines
the appearance of areas that are common on most of your GUI pages, such as
a banner and a navigation area.
- text replacement
- A HATS function used to transform
text on a host system into images, HTML code, or other text on a HATS screen
transformation,
- theme
- A theme groups a set of common appearance
and behavior characteristics for a project. These attributes can be individually
modified later.
- transfer
- To
copy an application EAR file to the server, typically by FTP.
- transformation
- A transformation stored in a .jsp
file (for Web projects) or a .java file (for rich client projects) defines
how host components should be extracted and displayed using widgets on your
GUI pages.
- transformation connection
- See default connection.
- transformation fragment
- A HATS resource that
contains the content with which to replace all occurrences of a pattern in
any given transformation.
- Unicode
- A universal character encoding standard
that supports the interchange, processing, and display of text that is written
in any of the languages of the modern world. It also supports many classical
and historical texts in a number of languages. The Unicode standard has a
16-bit international character set defined by ISO 10646.
- user
- Any person, organization, process, device,
program, protocol, or system that uses the services of a computing system.
- user list
- A list containing information about accounts
(user IDs) that a HATS application can use to access a host or database. User
lists contain user IDs, passwords, and descriptions for the accounts.
- UTF-8
- Unicode Transformation Format, 8-bit encoding
form, which is designed for ease of use with existing ASCII-based systems.
- Web archive (WAR)
- A compressed file format, defined
by the J2EE standard, for storing all the resources required to install and
run a Web application in a single file.
- Web Express Logon (WEL)
- A HATS feature that enables
users to log onto several hosts using a set of credentials that are authenticated
by a network security layer. (See network security layer.)
- WebFacing feature
- The IBM WebFacing Tool for System
i feature of the HATS Toolkit. The WebFacing feature provides the ability
to convert i5/OS data description specification (DDS) display file source
members into a Web-based user interface for existing 5250 programs.
- WebFaced application
- A Web application produced
by the WebFacing feature of the HATS Toolkit.
- WebSphere
- An IBM brand name that encompasses tools for
developing e-business applications and middleware for running Web applications.
Sometimes used as a short name for WebSphere Application Server, which represents
the runtime half of the WebSphere family of products.
- WebSphere Application Server
- Web application
server software that runs on a Web server and that can be used to deploy,
integrate, run, and manage e-business applications. HATS applications, when
exported and transferred to a server, run as WebSphere Application Server applications.
- WEL
- See Web Express Logon.
- widget
- A reusable user interface component such
as a button, scrollbar, control area, or text edit area, that can receive
input from the keyboard or mouse and can communicate with an application or
with another widget. HATS applications transform host components into widgets.
- wizard
- An active form of help that guides users
through each step of a particular task.
- workbench
- The user interface and integrated development
environment (IDE) in Eclipse-based products such as Rational SDP.
- XML
- See Extensible Markup Language.
Various Java definitions reprinted with permission from SUN
Microsystems, Inc.