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. A BMS map defines a set of fields which
are to be displayed as a group by a CICS application
- business logic
- Java 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 IBM i
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 Java EE
application, that is, as an .ear file, and installing it on WebSphere 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 runtime, which is required to run HATS rich client
applications in Lotus Expeditor
Client V6.2.0 and earlier. The DRE installs into the runtime
environment for Lotus 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 Java EE standard used to deploy Java EE applications
to Java EE
application servers. An EAR file contains enterprise beans, a deployment
descriptor, and Web archive (WAR) files for individual Web applications.
(Sun)
- Enterprise JavaBeans (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.
- 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 Notes or 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 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
- IBM portlets
- Portlets that comply with the IBM Portlet API which is deprecated in WebSphere Portal
Version 6.1. Contrast with standard portlets.
- 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 Platform,
Enterprise Edition (Java EE)
- An environment for developing and deploying enterprise applications,
defined by Sun Microsystems Inc. The Java EE 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 Portlet
Specification addresses the requirements of aggregation, personalization,
presentation, and security for portlets running in a portal environment.
Version 1.0 of the Java Portlet
Specification, Java Specification
Request 168 (JSR 168), defines standards to enable portlet compatibility
between portal servers offered by different vendors.
- 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.
- Lotus Expeditor Client
- A standalone client of the Lotus Expeditor product. It is installed on
a user or development machine.
- Lotus Expeditor Toolkit
- A toolkit in the Lotus Expeditor product used to develop applications.
It installs into Rational SDP.
- 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 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, Lotus Notes, 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, global rule, or macro. Screen
captures are useful because they allow you to customize an application
even when not connected to the host. They are also
useful in creating macros which are the core of HATS Integration Object
and Web services support.
- 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 portlets
- Portlets that comply with the standard portlet APIs defined
by Java Portlet
Specification JSR 168. See JSR 168. Contrast with IBM portlets.
- 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
- An IBM i screen for which data description
specification (DDS) display file source members are not available.
System screen is specific to an application on an IBM i platform 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 in
your GUI, 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 in your GUI.
- 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 Java EE 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.)
- Web service
- A self-contained, self-describing modular application that
can be published and invoked over a network using standard network
protocols.
- WebFacing feature
- The IBM WebFacing Tool for IBM i feature of
the HATS Toolkit. The WebFacing feature provides the ability to convert IBM i 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.