VisualAge for Java Glossary
A
- Abstract Window Toolkit (AWT)
- As defined by Sun Microsystems, a collection of GUI components that were implemented
using native-platform versions of the components. These components provide that subset of
functionality which is common to all native platforms. Largely supplanted by the Project
Swing component set. Contrast with Swing.
- AccessApp

- In Data Access Builder, a class generated for each schema mapping. The AccessApp is an
executable program that provides access to the database using the other classes generated
for the mapping.
- access beans
- In the EJB Development Environment, access beans are wrappers for enterprise beans and
are typically used by client programs, such as JSP files and servlets. Access beans hide
the complexity associated with home and remote interfaces.
- Access Builder for SAP R/3

- A VisualAge for Java tool 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. It also includes a connector for SAP R/3.
- Access Builders

- VisualAge for Java tools for developing applications that access enterprise servers,
data, and programs outside your Java programs. Access Builders generate beans that you can
use in the Visual Composition Editor to connect to your user interfaces. VisualAge for
Java, Enterprise Edition provides the following Access Builders: the Enterprise Access
Builder for Transactions, the Data Access Builder, the RMI Access Builder, the C++ Access
Builder, the Domino Access Builder and the Access Builder for SAP R/3.
- administrator

- See repository administrator.
- agent
- In Domino, a stand-alone program that performs a specific task in a database.
- 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.
- association

- In the EJB Development Environment, a relationship that exists between two
container-managed persistence (CMP) entity beans. There are two types of association:
one-to-one and one-to-many.
- attribute

- In Data Access Builder, the aspect of a schema mapping that represents a column in a
database table.
- AWT
- See Abstract Window Toolkit.
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.
- bean
- A definition or instance of a JavaBeans component. See JavaBeans.
- bean-managed persistence (BMP) entity bean

- In the EJB Development Environment, an entity bean that manages its own persistence.
Contrast with container-managed persistence (CMP) entity bean.
- BeanInfo
- (1) A Java class that provides explicit information about the properties, events, and
methods of a bean class. (2) In the VisualAge for Java IDE, a page in the class browser
that provides bean information.
- beans palette
- In the Visual Composition Editor, a resizable pane that contains prefabricated beans
that you can select and manipulate to create programs. The default set of beans generally
represents JDK AWT components.
- 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

- See Business Object Repository.
- 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) An Internet-based tool for browsing Web sites. (2) In VisualAge for Java, a window
that provides information on program elements. There are browsers for projects, packages,
classes, methods, and interfaces.
- 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) In the Access Builder for SAP R/3, 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
Persistence Builder, it is an object in your problem domain that you wish to save in a
datastore. Contrast with EAB business 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.
- C++ header file

- A text file that is used by a group of functions, programs, or users. It can contain
system-defined control information or user data, and generally consists of declarations.
- CICS Client

- A program that processes CICS ECI calls on the workstation and forwards transaction
requests to a CICS program that runs on a server.
- 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

- In the RMI Access Builder, a local representative of a remote server bean. The
client-side server proxy works together with a server-side server proxy bean to establish
client/server communications. See server-side server proxy.
- clone window
- An identical instance of the current window.
- CMP

- An acronym for container-managed persistence. See container-managed persistence
(CMP) entity bean.
- Command

- See EAB Command.
- 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 for Transactions, 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 SAP 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

- In the Common Connector Framework, the interface definition and its implementation of 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 Broker
- An IBM enterprise solution for distributed object computing that provides client
applications with a consolidated interface to server resources across applications,
platforms, and languages. Consists of an application development environment and a runtime
environment for building, executing, and managing applications across heterogeneous
distributed computing environments. Implements the Object Management Group's Common Object
Request Broker Architecture (CORBA), and supports Enterprise Java Beans (EJBs).
- 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

- In Visual Age for Java, the combinat ion 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 for Transactions, 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

- In the Common Connector Framework, a set of interfaces and classes 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 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
- (1) 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. (2) An EJB run-time environment that manages one or
more enterprise beans. Containers manage the life cycles of EJB objects, coordinate
distributed transactions, and implement object security. They run on an EJB server.
- container-managed persistence (CMP) entity bean

- In the EJB Development Environment, an entity bean that delegates its persistence to its
container. Contrast with bean-managed persistence (BMP) entity bean.
- control descriptor

- A control descriptor is a special class (javax.ejb.deployment.ControlDescriptor) that
defines the database isolation levels and other constant values for each method in an
enterprise bean that is used by the deployment descriptor.
- cookie

- (1) A block of data that a Web server stores on a client system. A copy of the cookie is
sent back to the server when a user returns to the same Web site. Cookies are used for a
variety of administrative purposes. (2) In VisualAge for Java, 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

- See Common Object 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 beans
- Beans provided with VisualAge for Java, for developing programs that access relational
databases. The Select bean is a nonvisual bean that queries a relational database. The
DBNavigator bean is a visual bean that provides a set of buttons that execute the SQL
statement for the associated Select bean. See also Data Access Builder.
- Data Access Builder

- A VisualAge for Java tool that generates beans that access and manipulate the content of
JDBC/ODBC-compliant relational databases. These beans perform operations beyond the scope
of the Data Access beans.
- 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.
- deployment

- In the EJB Development Environment, the act of generating EJB deployed classes for a
specific container.
- deployment descriptor

- In the EJB Development Environment, a special class that is serialized and that contains
run-time settings for an enterprise bean.
- 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

- See dynamic link library.
- Domino
- Software from Lotus Development Corporation, used for developing interactive
applications that run on Web servers.
- Domino Access Builder

- A VisualAge for Java tool that that allows you to create Java applications that access
databases and services located on a Domino server or on a Notes client. Domino Access
Builder provides generic beans, based on the Domino Java classes from Lotus, plus a
SmartGuide to create user-defined beans.
- Domino AgentRunner

- A VisualAge for Java tool that enables Domino developers to debug agent code within
VisualAge for Java. The Domino AgentRunner provides the IDE with a previously saved agent
context and a main entry point.
- Domino Java class library
- A class library provided with the Domino or Lotus Notes program products. The Domino
Access Builder uses this library to access Domino databases.
- dynamic link library (DLL)

- 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 Toolkits 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

- See Enterprise Access Builder for Transactions.
- 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.
- EAB Business Object

- In the Enterprise Access Builder for Transactions, a class containing a key property.
Contrast with business object.
- EAB Command

- In the Enterprise Access Builder for Transactions, represents a single interaction with
a host system. An EAB Command is composed of the connection specification, interaction
specification, and input and output records.
- EIS

- See Enterprise Information System.
- EJB

- See Enterprise JavaBeans.
- EJB Development Environment

- In VisualAge for Java, a specialized development environment that you can use to
develop, deploy, and test enterprise beans.
- EJB group

- In the EJB Development Environment, a logical group used to organize enterprise beans.
- EJB server

- A high-level process or application that provides a run-time environment to support the
execution of server applications that use enterprise beans. An EJB server provides a Java
Naming and Directory Interface (JNDI)-accessible naming service, manages and coordinates
the allocation of resources to client applications, and provides a transaction service.
- 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 Access Builder (EAB)

- See Enterprise Access Builder for Transactions.
- Enterprise Access Builder for Transactions (EAB)

- A set of frameworks and tools for creating Java applications that access existing host
applications and data, for example using CICS, IMS, MQSeries, SAP or Encina.
- Enterprise bean

- A nonvisual object that conforms to the Enterprise JavaBeans architecture. Enterprise
beans are deployed in an EJB container and run on an EJB server. There are two types of
enterprise beans: session beans and entity beans.
- Enterprise Information System (EIS)

- A host application or host system.
- Enterprise JavaBeans
- A distributed component architecture defined by Sun Microsystems.
- 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.
- Enterprise Toolkit for AS/400

- VisualAge for Java tools that target Java applications for execution on AS/400.
- Enterprise Toolkit for OS/390

- VisualAge for Java tools that target Java applications for execution on OS/390.
- Enterprise Toolkit for Workstations

- VisualAge for Java tools that target Java applications for execution on OS/2, Windows
NT, or AIX.
- entity bean

- An enterprise bean that contains data which can be preserved in a persistent data store,
such as a database. Contrast with session bean. There are two types of entity
beans: container-managed persistence (CMP) entity beans and bean-managed persistence (BMP)
entity beans.
- ET/390

- See Enterprise Toolkit for OS/390.
- ET/400

- See Enterprise Toolkit for AS/400.
- ET/Workstation

- See Enterprise Toolkit for Workstations.
- 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.
- Feature Integrator

- A VisualAge for Java mechanism that lets you integrate Java class libraries and beans,
called features, that reside on the file system.
- 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.
G
- generic bean

- In the Domino Access Builder, a bean from the Domino Java class library that has been
wrapped with a bean interface. Generic beans can be used in Java programs and for visual
composition in the VisualAge Java IDE.
H
- HOD

- See Host On-Demand.
- home interface

- In the EJB Development Environment, the methods used by a client to create, locate, and
remove instances of enterprise beans.
- hook

- An assembler instruction inserted in the user application code that gives the Enterprise
Toolkit for OS/390 Performance Analyzer control to perform analysis.
- Host On-Demand (HOD)

- An IBM software product that provides a Java-based, e-business network solution that
incorporates industry-standard Telnet 3270 protocols.
- HPC

- An acronym for High Performance Compiled.
I
- IDE
- See Integrated Development Environment.
- IDL

- See Interface Definition Language.
- IDL Development Environment

- In VisualAge for Java, an integrated development environment that allows you to work
with IDL source code 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.
- inheritance

- (1) An object-oriented programming technique that allows the use of existing classes as
bases for creating other classes. (2) A mechanism by which a derived class can use the
attributes, relationships, and member functions defined in more abstract classes related
to it (its base classes). (3) In the EJB Development Environment, there are two forms of
inheritance: class inheritance and EJB inheritance. In class inheritance, the home
interface, remote interface, or enterprise bean class inherits properties and methods from
base classes that are not themselves enterprise bean classes or interfaces. In EJB
inheritance, an enterprise bean can inherit properties (such as container-managed
persistence fields and association ends), methods, and method-level control descriptor
attributes from another enterprise bean that resides in the same group.
- initializer
- A value that is used as the default until explicitly changed.
- 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

- In the Common Connector Framework, the interface definition 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
- In the Java programming environment, a group methods that can be implemented by several
classes, regardless of where the classes are in the class hierarchy. The Interfaces page
in the Workbench lists all interfaces in the workspace.
- Interface Definition Language (IDL)

- In CORBA, a declarative language that is used to describe object interfaces, without
regard to object implementation.
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
- As defined by Sun Microsystems, a portable, platform-independent, reusable component
model.
- Java Database Connectivity

- In the JDK, the specification that defines an API that enables programs to access
databases that comply with this standard.
- Java Development Kit (JDK)
- As defined by Sun Microsystems, a software development environment for writing applets
and applications in the Java programming language.
- Java Foundation Class (JFC)
- As defined by Sun Microsystems, an extension that adds graphical user interface class
libraries to the Abstract Windowing Toolkit (AWT).
- Java Native Interface (JNI)

- A native programming interface that allows Java code running inside a Java Virtual
Machine (JVM) to interoperate with applications and libraries written in other programming
languages, such as C and C++.
- 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.
- JavaServer Pages (JSP)
- A server-side scripting technology that enables you to embed Java code within static Web
pages (HTML files), and to execute the Java code when the page is served.
- Java Virtual Machine (JVM)
- The part of the Java Runtime Environment responsible for interpreting Java bytecode.
- JDBC

- See Java Database Connectivity.
- JDK
- See Java Development Kit.
- JFC
- See Java Foundation Class.
- JNI

- See Java Native Interface.
- JSP
- See JavaServer Pages.
- JSP Execution Monitor
- A tool that enables you to monitor the execution of JSP source, JSP-generated Java
source, and HTML output.
- JSP file
- A scripted HTML file that has a .jsp extension. A JSP file can be directly requested as
a URL, called by a servlet, or called from within an HTML page.
- JVM
- See Java Virtual Machine.
K
- key property

- In the Enterprise Access Builder for Transactions, a class that includes a set of Java
properties that uniquely identify an EAB Business Object.
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
- makefile

- In the C++ Access Builder, a makefile is a text file that contains commands. It may
include commands to create backups, set up build environments, or start execution of a
program. Traditionally, makefiles specify the dependencies of target files on source
files.
- mapper

- In the Enterprise Access Builder for Transactions, 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).
- 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.
- Migration Assistant
- In VisualAge for Java, the tool you can use to help convert an ActiveX component to a
Java bean. The Migration Assistant generates Java source code that implements the JavaBean
event handling model.
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 for Transactions, an EAB Command composed of other
Commands to form a more complex interaction (navigation) with a host system. See also EAB
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

- See Object Request Broker.
- 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.
- partitioned data set extended

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

- See partitioned data set extended.
- 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 and events. See also trace
event and trace file.
- persistence
- A bean persists by having its properties, fields and state information saved and
restored to and from storage. This is in contrast to transient objects that cease existing
when the application that created them is not running.
- 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 existing 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, a unit of organization used to group 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.
- project resources directory
- The file system directory where VisualAge for Java stores or looks for external
resources such as images or HTML files. By default, each project has its own resources
directory (with the same name as the project) inside x:\IBMVJava\Ide\project_resources,
where x:\IBMVJava is the directory where VisualAge for Java is installed.
- 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 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

- In the Enterprise Access Builder for Transactions, contains properties that map to the
fields in a record of a host application. Records can be used to define input or output
for Commands in the Enterprise Access Builder. See also EAB Command.
- Record Framework

- A Java framework that describes and converts record data.
- record type

- In the Enterprise Access Builder for Transactions, a one-dimensional representation of
the data structure of user-defined parts of a host application. A record type can be
generated by one of the Import Source to Record Type SmartGuides or can be hand-coded.
-
- 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 interface

- In the EJB Development Environment, specifies the remote business methods that a client
can be call on an enterprise bean.
- 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.
-
- Remote Method Invocation (RMI)
- 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 machine
- Remote Object Instance Manager

- In the RMI Access Builder, 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 directory
- See project resources directory.
- 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.
- RFC

- See Remote Function Call.
- RMI
- See Remote Method Invocation.
- 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 configuration

- In the EJB Development Environment, one or more enterprise beans that, in combination
with a set of specific properties, have been added to an EJB server.
- server-side server proxy

- In the RMI Access Builder, a companion class to the client-side server proxy,
facilitating client-side server proxy communication over RMI. See client-side server
proxy.
- 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.
- Servlet Builder

- A set of visual and nonvisual beans provided with VisualAge for Java, Enterprise
Edition, for building servlets.
- Servlet Launcher

- A tool in the IDE that allows you to start an HTTP server, bring up your browser, and
launch a servlet.
- session bean

- A relatively short-lived enterprise bean. Contrast with entity bean. There are
two types of session beans: stateful and stateless.
- 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.
- SPB

- See Stored Procedure Builder.
- SQL predicate

- The conditional part of an SQL statement.
- SQLJ

- A standard way to embed SQL statements in Java programs. Contrast with JDBC.
- stack frame
- In the VisualAge for Java Integrated Debugger, one of several methods that form a stack
trace. Stack frames are listed in the Methods pane, in reverse chronological order; that
is, the most recent method called is at the top.
- stateful sesssion bean

- A session enterprise bean that acts on behalf of a single client, and that maintains
client-specific session information (called conversational state) across multiple method
calls and transactions.Contrast with stateless session bean.
- stateless session bean

- A session enterprise bean that does not maintain any conversational state. Contrast with
stateful session bean. Stateless session beans are pooled with others in a
container.
- staleness

- In the Persistence Builder, this describes stored data that should have been rewritten,
but was left unchanged because of a failed write operation.
- 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.
- Stored Procedure Builder

- In VisualAge for Java, a tool that allows you to work with DB2 stored procedures.
- Swing
- As defined by Sun Microsystems, the code name for a collection of GUI components that
runs uniformly on any native platform that supports the Java virtual machine (JVM).
Contrast with AWT.
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.
- Tivoli Connection

- A set of components that enable development of VisualAge applications that are ready to
be managed by Tivoli.
- Tivoli Enterprise Console

- An event and automation application that provides rules-based event correlation for
integrating network, systems, database, and applications management.
- Tivoli event

- A formatted message that is sent to the Tivoli Enterprise Console when a significant
event occurs in an application.
- Tivoli Management Software

- Network, systems, and application management software developed by Tivoli Systems Inc.
- Tool Integrator
- A VisualAge for Java mechanism that lets you integrate Java applications that reside on
the file system in order to launch them from within the IDE.
- toolkit

- See Enterprise Toolkit.
- trace event

- An event in user application code, such as the entry to a method, that is recorded by
the Enterprise Toolkit for OS/390 Performance Analyzer for analysis.
- trace file

- A file produced by the Enterprise Toolkit for OS/390 Performance Analyzer that contains
trace analysis information from your program. The file can be downloaded and viewed in the
Performance Analyzer diagrams.
- 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.
- union

- In the C++ Access Builder: (1) A class that can contain different types of objects at
different times. Only one of the member objects can be stored in a union at any time. (2)
Given the sets A and B, all elements of A, B, or both A and B.
- 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
- WebSphere
- A set of IBM software products that help customers build and manage high-performance Web
sites.
- WebSphere Application Server
- IBM's Java servlet-based Web application server used for deploying and managing Web
applications. WebSphere Application Server is a Web server plug-in based on a server-side
Java programming model that uses servlets, JavaServer Pages files, and enterprise beans.
Executable code that is generated by VisualAge for Java can be run on the Websphere
Application Server.
- 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.
