VisualAge for Java Glossary
- A
- AccessApp

- Generated by the Data Access Builder for each schema mapping, an executable GUI that
provides access to the database using the other classes generated for the mapping.
- Access Builder for SAP R/3

- A VisualAge for Java ToolKit for developing Java beans, Java applications, or Java
applets that access SAP business objects. The Access Builder for SAP R/3 consists of
R/3 Access Classes, Business Object Repository Access Classes, Logon Java beans, and the
Access Builder tool.
- administrator

- See repository administrator.
- agent
- In Domino, a stand-alone program that performs a specific task in a database.
- AgentRunner
- A tool that allows developers to debug agent code within VisualAge for Java (outside
Domino) by providing the IDE with a previously saved agent context and a main entry point.
- applet
- A Java program designed to run within a Web browser. Contrast with application.
- application
- In Java programming, a self-contained, stand-alone Java program that includes a static
main method. It does not require an applet viewer. Contrast with applet.
- ASCII
- American Standard Code for Information Interchange. A standard assignment of 7-bit
numeric codes to characters. See also Unicode.
- attribute

- In Data Access Builder, the aspect of a schema mapping that represents a column in a
database table.
- B
- baseline

- The common set of package and class editions upon which a development team builds an
application. Package and class owners release their editions to update the team
baseline; developers replace the editions in their workspaces to synchronize with the team
baseline. Baselines typically signify a point of progress.
- base type
- In Java, a type that establishes an interface to anything inherited from itself.
See type, derived type.
- bean
- A definition or instance of a JavaBeans component. See JavaBeans.
- BeanInfo
- (1) A Java class that provides explicit information about the properties, events, and
methods of a bean class. (2) In the Integrated Development Environment, a page in the
class browser that provides bean information.
- beans palette
- In the Visual Composition Editor, a two-column pane that contains prefabricated beans
that you can select and manipulate to create programs. The default set of beans generally
represent JDK AWT components. You can add your own categories and beans to the beans
palette.
- BO Proxy Beans

- The proxy classes to SAP business objects generated with the Access Builder for SAP
R/3. When generating the BO Proxy Beans, the Access Builder for SAP R/3 also
generates proxy classes that map the used tables, structures, and container classes for
method parameters. The term BO Proxy Classes is sometimes used to describe all proxy
classes generated by the Access Builder for a given SAP business object
- BOR Access Classes

- Classes that retrieve information from the Business Object Repository (BOR). The
BOR contains all information on SAP business objects, such as attributes, methods, and
events. The Access Builder uses the BOR Access Classes to retrieve the information
required to generate BO Proxy Classes. The generated proxy classes do not depend on
the BOR Access Classes, only on the R/3 Access Classes.
- breakpoint
- A point set in the code that determines where execution of the code will stop and a
debugger will be invoked.
- browser
- (1) In VisualAge for Java, a window that provides information on program elements. There
are browsers for projects, packages, classes, methods, and interfaces. (2) An
Internet-based tool that lets users browse Web sites.
- Business Application Programming Interface (BAPI)

- Methods that SAP business objects use for such tasks as creating and changing a
"customer order" from inside or outside R/3, for example through Internet
applications.
- business object

- (1) An object that represents a business function. Business objects contain
attributes that define the state of the object, and methods that define the behavior of
the object. A business object also has relationships with other business
objects. Business objects can be used in combination to perform a desired
task. Typical examples of business objects are Customer, Invoice, or Account.
(2) In the Enterprise Access Builder, a class that implements the IBusinessObject
interface. Business objects are used to map interactions with an existing host
application. Business objects are either managed or unmanaged. Managed business objects
have a key object that only permits the existence of one instance of the business object
class at any time per execution context. A key must implement the IBusinessObjectKey
interface. An unmanaged business object is a class that implements the IBusinessObject
interface, but has no key object.
- Business Object Repository (BOR)

- A representation of the business data, transactions, and events within the R/3 system as
an integrated set of SAP business objects. The BOR manages these objects, which are
related to each other in object models. The BOR anticipates future requirements for
R/3 systems architecture and integration. It also provides the basis for embracing
distributed object standards, such as COM/DCOM and CORBA.
- bytecode
- Machine-independent code generated by the Java compiler and executed by the Java
interpreter.
C
- C++ Access Builder

- A VisualAge for Java Enterprise tool that generates beans and C++ wrappers that let your
Java programs access C++ DLLs.
- CICS Client

- A server program that processes CICS ECI calls, forwarding transaction requests to a
CICS program running on a host.
- CICS ECI

- An API that provides C and C++ programs with procedural access to transactions.
- CICS Gateway for Java

- A server program that processes Java ECI calls and forwards CICS ECI calls to the CICS
Client.
- class
- An encapsulated collection of data and methods to operate on the data. A class may
be instantiated to produce an object that is an instance of the class.
- class hierarchy
- The relationships between classes that share a single inheritance. All Java classes
inherit from the Object class.
- class owner

- In team programming, the member of the development team who is responsible for the
quality of a particular class or interface. Only the owner can release the class or
interface into its containing package.
- class path
- When running a program in VisualAge for Java, a list of directories and JAR files that
contain resource files or Java classes that a program can load dynamically at run time.
A program's class path is set in its Properties notebook.
- CLASSPATH
- In your deployment environment, the environment variable keyword that specifies the
directories in which to look for class and resource files.
- client

- A networked computer in which the IDE is connected to a repository on a team server.
- client-side server proxy

- Generated by the RMI Access Builder, a local representative of a remote server bean.
This proxy provides access to the operations of the server bean, allowing a Java client to
work with it as if it were the server bean.
- clone window
- An identical instance of the current window.
- command

- In the Enterprise Access Builder, the representation of a single interaction with a host
system. A command is a composite, the main elements being connection specification,
interaction specification, input bean, and output bean. You can construct a command in the
Visual Composition Editor, or by using the Command Composer SmartGuide.
- COMMAREA

- See communications area.
- commit

- The operation that ends a unit of work and updates the database so that other processes
can access any changes made.
- Common Connector Framework

- In the Enterprise Access Builder, interface and class definitions that provide a
consistent means of interacting with enterprise resources (for example, CICS and Encina
transactions) from any Java execution environment.
- Common Object Request Broker Architecture (CORBA)
- A vendor-independent specification that defines how objects interoperate over a network.
- Common RFC Interface for Java

- A set of Java interfaces and classes that defines a middleware-independent layer to
access R/3 systems from Java. If applications are built on top of this interface,
they can leverage different middleware at run time without recoding. The generated
beans are based on this interface and provide the same flexibility.
- communication

- The interface definition in the Common Connector Framework, and the implementation of
the interface by the various connectors. It provides the common way of communicating with
a host system.
- communications area (COMMAREA)

- In a CICS transaction program, a group of records that describes both the format and
volume of data used.
- compilation context
- The class you choose to contain a Java code fragment when you compile and run it in the
Scrapbook.
- component model
- An architecture and an API that allows developers to define reusable segments of code
that can be combined to create a program. VisualAge for Java uses the JavaBeans component
model.
- composite bean
- A bean that can contain both visual and nonvisual components. A composite bean is
composed of embedded beans.
- configuration

- The combination of package or class editions that make up a particular edition of a
project or package, respectively. Project and package configurations are updated
when a package or class is created, released, or deleted.
- connection
- In the Visual Composition Editor, a visual link between two components that represents
the relationship between the components. Each connection has a source, a target, and other
properties.
- connection specification

- The interface definition in the Common Connector Framework, and the implementation of
the interface by the various connectors. A concrete connection specification lets you
specify all properties to create a specific communication. It allows you to create a new
communication configured with properties that allow the communication to connect to a
specific host system.
- connector

- In the Enterprise Access Builder, a specific implementation of the Common Connector
Framework that wraps the client/server APIs of various resource managers in a way that
both provides a consistent programming interface, and supports product-specific
capabilities and host-system control.
- connector Run-Time Context

- A set of interfaces and classes in the Common Connector Framework that allows a
connector implementation to abstract from the concrete environment that it is running in.
A concrete implementation is provided for a fat Java application scenario. Specific
infrastructures (for example, Component Broker) that want to make use of the connectors
have to provide their own specific implementation.
- Console
- In VisualAge for Java, the window that acts as the standard input (System.in) and standard output (System.out) device for programs running in the
VisualAge for Java environment.
- constructor
- A method called to set up a new instance of a class.
- container
- A component that can hold other components. In Java, examples of containers include
applets, frames, and dialogs. In the Visual Composition Editor, containers can be
graphically represented and generated.
- cookie

- Persistent data stored by the client in the Servlet Builder.
- cooperative debugger

- The debugger used when debugging programs developed for the AS/400 system.
- CORBA

- Common Objects Request Broker Architecture.
- cursor

- A database control structure used by the Data Access Builder to point to a specific row
within some ordered set of rows and to retrieve rows from a set, possibly making updates
or deletions.
D
- Data Access Bean
- In the Visual Composition Editor, a bean that accesses and manipulates the content of
JDBC/ODBC-compliant relational databases.
- Data Access Builder

- A VisualAge for Java Enterprise tool that generates beans to access and manipulate the
content of JDBC/ODBC-compliant relational databases.
- debuggee
- The program or module being debugged.
- debugger
- A component that assists in analyzing and correcting coding errors.
- default package
- In the Integrated Development Environment, the package in a project that has no
user-defined name. There can only be one default package in a project. For example,
imported class files that do not specify a package are placed in the default package.
- derived type
- In Java, a type that overrides the definitions of a base type to provide unique
behavior.
- developer

- In team development, the person who created an edition of a class or interface.
Only the developer can version the class or interface.
- DLL (dynamic link library)

- A file containing executable code and data bound to a program at load time or run time,
rather than during linking. The code and data in a dynamic link library can be
shared by several applications simultaneously. The C++ Access Builder generates
beans and C++ wrappers that let your Java programs access C++ DLLs. Enterprise
Access Builders also generate platform-specific DLLs for the workstation and OS/390
platforms.
- dynamic record type

- In the Enterprise Access Builder, a one-dimensional representation of the data structure
of user-defined parts of a host application. A dynamic record type can be generated by one
of the Create RecordType SmartGuides (for example, the Create COBOL RecordType SmartGuide)
or can be hand-coded. Dynamic record types can be modified in the Record Editor.
E
- EAB

- Enterprise Access Builder.
- edition
- A specific "cut" of a program element. VisualAge for Java supports multiple
editions of program elements. See open edition, versioned edition, and scratch
edition.
- embedded bean
- A bean dropped into another bean in the Visual Composition Editor. The embedded
bean can be a single component or a composite bean.
- EMSRV repository server

- See repository server.
- EMSRV user

- In the team environment, the operating system account under whose privileges the
repository server program runs.
- EMSRV working directory

- In the team environment, a team server default directory used by the repository server
to locate shared repositories and to write its log.
- Enterprise ToolKit

- A set of VisualAge for Java Enterprise tools that enable you to develop Java code that
is targeted to specific platforms, such as AS/400, OS/390, OS/2, AIX, and Windows.
- event
- An action by a user, program, or system that may trigger specific behavior. In the JDK,
events notify the relevant listener classes to take appropriate action.
F
- factory
- A bean that dynamically creates instances of beans.
- field
- A data object in a class; for example, a variable.
- framework
- A set of object classes that provide a collection of related functions for a user or
piece of software.
- free-form surface
- In the Visual Composition Editor, the large, open area where you can work with visual
and nonvisual beans. You add, remove, and connect beans on the free-form surface.
- form data

- A generated class representing the HTML form elements in a visual servlet.
- fully bound object program

- On the OS/390 platform, an executable or DLL file that does not require an object file.
H
- hit

- When a module, a method, a source file, a source code line, or an assembler offset is
encountered in a trace, it is registered as a hit. Hits are used by the Enterprise
ToolKit for OS/390 Performance Analyzer.
- hook

- A point in some code used to control the program under analysis. Hooks are used by
the Enterprise ToolKit for OS/390 Performance Analyzer.
I
- IDL (Interface Definition Language)

- In CORBA, a declarative language that is used to describe object interfaces, without
regard to object implementation.
- IDL Development Environment

- In VisualAge for Java, an integrated IDL and Java development environment. The IDL
Development Environment allows you to work with IDL source code in the multipane IDLs page
and generate Java code using an IDL-to-Java compiler.
- IDL group

- A container used to hold IDL objects in the IDL Development Environment. It is
similar to a file system directory.
- IIOP (Internet Inter-ORB Protocol)

- A communications standard for distributed objects that reside in Web or enterprise
computing environments.
- Inspector
- In VisualAge for Java, a window in which you can evaluate code fragments in the context
of an object, look at the entire contents of an object and its class, or access and modify
the fields of an object.
- Integrated Development Environment (IDE)
- In VisualAge for Java, the set of windows that provide the user with access to
development tools. The primary windows are the Workbench, Log, Console, Debugger, and
Repository Explorer.
- interaction specification

- The interface definition in the Common Connector Framework, and the implementation of
the interface by the various connectors. A concrete interaction specification lets you
specify all properties that enable a communication to make a single interaction with a
host system.
- interface
- A list of methods that enables a class to implement the interface itself by using the
implements keyword. The Interfaces page in the Workbench lists all interfaces in the
workspace.
- Internet Inter-ORB Protocol (IIOP) Access Builder

- A tool that edits and generates CORBA-compliant Java modules. See Common
Object Request Broker Architecture (CORBA).
J
- JAR file format
- JAR (Java Archive) is a platform-independent file format that aggregates
many files into one. Multiple Java applets and their requisite components (.class
files, images, sounds and other resource files) can be bundled in a JAR file and
subsequently downloaded to a browser in a single HTTP transaction.
- JavaBeans
- A portable, platform-independent reusable component model.
- JavaObjs

- In Remote Method Invocation, the name of the user-defined default file that contains a
list of server objects to be instantiated when the Remote Object Instance Manager is
started.
- Java Record Editor

- An editor that allows you to construct and refine dynamic record types.
- Java Record Framework

- A Java framework that describes and converts record data
- Java Virtual Machine (JVM)
- The part of the Java Runtime Environment responsible for interpreting Java bytecode.
- JDBC (Java Database Connectivity)

- In the JDK, the specification that defines an API that enables programs to access
databases that comply with this standard.
- JNI (Java Native Interface)

- A native programming interface that allows Java code running inside a Java Virtual
Machine (VM) to interoperate with applications and libraries written in other programming
languages, such as C and C++.
L
- listener
- In the JDK, a class that receives and handles events.
- load
- The act of adding an edition from the repository to the workspace.
- Log
- In the IDE, the window that displays messages and warnings during development.
M
- mapper

- In the Enterprise Access Builder, a class that maps the properties of a bean (for
example, a record) to or from the properties of a set of beans (for example, business
objects). Mappers are constructed in the mapper builder.
- mapping

- See schema mapping.
- method
- A fragment of Java code within a class that can be invoked and passed a set of
parameters to perform a specific task.
N
- named package
- In the Integrated Development Environment, a package that has been explicitly named when
created. Contrast with default package.
- navigator

- In the Enterprise Access Builder, a command composed out of other commands that forms a
more complex interaction (navigation) with a host system. You construct these complex
interactions by interconnecting commands by means of the Visual Composition Editor. See command.
- nonvisual bean
- A bean that is not visible to the end user in the graphical user interface, but is
visually represented on the free-form surface of the Visual Composition Editor during
development. Developers can manipulate nonvisual beans only as icons; that is, they cannot
edit them in the Visual Composition Editor as they can edit visual beans. Examples
of nonvisual beans include beans for business logic, communication access, and database
queries.
O
- open edition
- An edition of a program element that can still be modified; that is, the edition has not
been versioned.
- ORB (Object Request Broker)

- In object-oriented programming, software that serves as an intermediary by transparently
enabling objects to exchange requests and responses.
P
- package
- A program element that contains classes and interfaces. See also default package and
named package.
- package group

- In team programming, for a specific edition of a package, the group of developers who
are authorized to create classes in the package, release classes into the package, and
assume ownership of any class in the package.
- package owner

- In team programming, the member of the development team who is responsible for the
quality of a particular edition of a package. The package owner can add developers
to the package group, and can version and release the package into its containing project.
- palette
- See beans palette.
- part
- An existing, reusable software component. All parts created with the Visual Composition
Editor conform to the JavaBeans component model, and are referred to as beans. See visual
bean and nonvisual bean.
- partially bound object program

- On OS/390 systems, output from a compiler or assembler which is itself executable
machine code or is suitable for processing to produce executable machine code.
- PDSE (partitioned data set extended)

- On OS/390 systems, a set of separate or partitioned data.
- Performance Analyzer

- In the Enterprise ToolKit for OS/390, a component that traces the execution of a program
and creates a trace file with data such as time stamps, events, and hits. See also time
stamp, trace event, and hit.
- persistence
- In object models, a condition that allows instances of classes to be stored externally,
for example in a relational database.
- Persistence Builder

- In VisualAge for Java, a persistence framework for object models, which enables the
mapping of objects to information stored in relational databases and also provides
linkages to legacy data on other systems.
- program
- In VisualAge for Java, a term that refers to both Java applets and applications.
- program element
- In VisualAge for Java, a generic term for a project, package, class, interface, or
method.
- project
- In VisualAge for Java, the topmost kind of program element. A project contains Java
packages.
- project owner

- In team programming, the member of the development team who is responsible for the
quality for a particular edition of a project. The project owner can version the
project and add, delete, and release packages in the project.
- property
- An initial setting or characteristic of a bean, for example, a name, font, text, or
positional characteristic.
- property sheet
- In the Visual Composition Editor, a set of name-value pairs that specify the initial
appearance and other bean characteristics. A bean's property sheet can be viewed from the
Properties secondary window.
- proxy bean

- A group of client-side and server-side objects that represent a remote server bean. The
top-level class that implements the proxy bean is the client-side server proxy. See BO
Proxy Beans, client-side server proxy, and server-side server proxy.
R
- record bean or class

- In the Enterprise Access Builder, Java code generated from a dynamic record type by the
Generate Records SmartGuide. A record bean or class contains properties that map to the
fields in a record in a host program. Record beans or classes can be used to define input
or output for commands in the Enterprise Access Builder.
- release

- In team programming, the act of updating the configuration of program elements contained
in a specific edition of a project or package. When package or class owners
release modified editions into a containing project or package, they update the team
baseline. See baseline.
- reload
- The act of replacing an edition in the workspace with a different edition from the
repository.
- remote debugger

- A debugging tool that debugs code on a remote platform.
- Remote Function Call (RFC)

- SAP's open programmable interface. External applications and tools can call ABAB/4
functions from the SAP System. You can also call third party applications from the
SAP System using RFC. RFC is a means for communication that allows implementation on
all R/3 platforms.
- Remote Object Instance Manager

- In Remote Method Invocation, a program that creates and manages instances of server
beans through their associated server-side server proxies.
- repository
- In VisualAge for Java, the permanent storage area containing all open and versioned
editions of all program elements, regardless of whether they are currently in the
workspace. The repository contains the source code for classes developed in (and
provided with) VisualAge for Java, and the bytecode for classes imported from the file
system. Every time you save a method in the IDE, it is automatically updated in the
repository. See also SCM repository and shared repository.
- repository administrator

- In team programming, the user who maintains the repository user list and performs
repository administration functions. See also EMSRV user.
- Repository Explorer
- In VisualAge for Java, the window from which you can view and compare editions of
program elements that are in the repository.
- repository server (EMSRV)

- In team programming, the program on the VisualAge for Java server that manages
concurrent user access to one or more shared repositories.
- repository user list

- In team programming, the list of users who can access a repository.
- resource file
- A non-code file that may be referred to from your Java program in VisualAge for Java.
Examples include graphic and audio files.
- RMI (Remote Method Invocation)
- In the JDK, the API that allows you to write distributed Java programs, allowing methods
of remote Java objects to be accessed from other Java virtual machines.
- RMI Access Builder

- A VisualAge for Java Enterprise tool that generates proxy beans and associated classes
and interfaces so you can distribute code for remote access, enabling Java-to-Java
solutions.
- RMI compiler
- The compiler that generates stub and skeleton files that facilitate RMI communication.
This compiler can be automatically invoked by the RMI Access Builder, and can also be
invoked from the Tools menu item.
- RMI registry
- A server program that allows remote clients to get a reference to a server bean.
- roll back

- The process of restoring data changed by SQL statements to the state at its last commit
point.
S
- schema

- In the Data Access Builder and the Persistence Builder, the representation of the
database that will be mapped.
- schema mapping

- In the Data Access Builder, a set of definitions for all attributes matching all the
columns for your database table, view, or SQL statement. The mapping contains the
information required by the Data Access Builder to generate Java classes.
- SCM
- See software configuration management.
- SCM repository
- In VisualAge for Java, a generic term for the data store of any external software
configuration management (SCM) tool. Some SCM tools refer to this as an archive.
- Scrapbook
- In VisualAge for Java, the window from which you can write, edit, and test fragments of
code without having to define an encompassing class or method.
- scratch edition

- In team programming, a private edition of a project or package. It is only
available to the workspace owner who created it.
- server bean

- The bean that is distributed using RMI services and is deployed on a server.
- server-side server proxy

- Generated by the RMI Access Builder, a companion class to the client-side server proxy,
facilitating client-side server proxy communication over RMI.
- service handler

- In the Servlet Builder, an interface for visual servlets.
- services

- In Persistence Builder, classes that implement the low-level functionality required to
store and retrieve objects from the data store.
- servlet

- Server-side classes that respond to HTTP requests.
- session data

- In the Servlet Builder, persistent data stored by the HTTP server.
- shadow browser
- Any browser launched from the Repository Explorer. Shadow browsers allow you to
view, copy, and edit source, but they do not allow you to save any changes.
- shared repository

- A repository residing on a VisualAge for Java server, used by a team of developers.
The team clients' workspaces connect to the shared repository. See also repository
and repository server (EMSRV).
- SmartGuide
- In IBM software products, an active form of help that guides you through common tasks.
- software configuration management (SCM)
- The tracking and control of software development. SCM tools typically offer
version control and team programming features.
- SQL predicate

- The conditional part of an SQL statement.
- stackframe
- In the Visual Age for Java Integrated Debugger, one of several methods that form a stack
trace. Stackframes are listed in the Methods pane, in reverse chronological order; that
is, the most recent method called is at the top.
- sticky
- In the Visual Composition Editor, the ability to drop multiple copies of a bean selected
only once from the palette. When sticky is enabled, the mouse pointer remains
crosshaired until you select either the Selection tool or another bean from the palette.
- stored procedure

- A procedure that is part of a relational database. The Data Access Builder can generate
Java code that accesses stored procedures.
T
- tear-off property
- In the Visual Composition Editor, a variable representing a property that allows you to
work with that property as if it were a separate bean.
- text deck

- On the OS/390 system, a name for a load module used to load a program into central
storage for execution.
- thread
- A separate flow of control within a program.
- time stamp

- In the Enterprise ToolKit for OS/390 Performance Analyzer, a record of the precise
time at which a trace event occurred during a program's execution.
- trace event

- An event in some code, such as the entry to a method, set by the Enterprise ToolKit for
OS/390 Performance Analyzer as a point for analysis.
- transaction

- (1) In a CICS program, an event that queries or modifies a database that resides on
a CICS server. (2) In the Persistence Builder, a representation of a path of code
execution. (3) The code activity necessary to manipulate a persistent object.
For example, a bank application might have a transaction that updates a company account.
- type
- In VisualAge for Java, a generic term for a class or interface.
U
- Unicode
- A 16-bit international character set defined by ISO 10646. See also ASCII.
- unresolved problem
- In VisualAge for Java, an error marked by an X to the left of the program element name,
for example, a declaration or definition problem. You can view all unresolved problems
from the Unresolved Problems page in the Workbench.
- user list

- See repository user list.
V
- version
- The act of making an open edition a versioned edition, that is, a read-only edition, and
naming it.
- versioned edition
- An edition that can no longer be modified.
- visual bean
- In the Visual Composition Editor, a bean that is visible to the end user in the
graphical user interface.
- Visual Composition Editor
- In VisualAge for Java, the tool you can use to create graphical user interfaces from
prefabricated beans, and to define relationships (called connections) between beans. The
Visual Composition Editor is a page in the class browser.
- visual servlet

- A servlet that is designed to be built using the Visual Composition Editor
W
- Workbench
- In VisualAge for Java, the main window from which you can manage the workspace, create
and modify code, and open browsers and other tools.
- workspace
- The work area that contains the Java code that you are developing and the class
libraries on which your code depends. Program elements must be added to the
workspace from the repository before they can be modified.
- workspace owner

- In team programming, the team developer currently associated with the workspace on a
VisualAge for Java client. The owner's privileges determine what operations the
developer can perform on objects in the shared repository.
