Getting Started
VisualAge Generator code is managed by the same built-in library system
used by VisualAge for Java. This system facilitates team development
and code reuse by operating in concert with object-oriented principles and
providing programmers with an integrated environment in which they can
develop, share, and manage source code. Code is managed as methods,
classes and interfaces, projects, and packages. Workspaces enable
developers to customize their environments. Changes to parts in the
repository are managed as editions and versions.
In this team-development environment, VisualAge Generator and VisualAge
for Java source code is managed at four levels:
- Methods
- are pieces of executable code that implement the logic of a particular
behavior for a class. Methods are the smallest unit of source code that
the repository maintains. Each time a method is changed and saved, an
edition of its source code is saved in the repository so that individual
changes can be tracked and managed as classes are developed.
- Classes and Interfaces
- are specifications that determine the attributes and behavior of software
objects. Classes typically contain several attributes and
methods. Interfaces specify a set of behaviors that unrelated objects
can use to interact with each other without either object having to know the
full specification of the other. Both classes and interfaces are
tracked in the repository. Developers can share versions of classes and
interfaces and use them as templates to standardize objects across code
repositories. All VisualAge for Java beans are stored as classes or
interfaces.
- Packages
- are functionally related sets of classes and interfaces that provide
developers with reusable pieces of functionality. Developers can also
create and share versions of packages. Loaded packages are listed under
the Packages tab in the Workbench. They are also listed
under their individual projects under the Projects tab.
- Projects
- are named groups of packages that are usually associated with a product or
a major component of a product. Projects provide an easy way for
developers to import and export sets of packages and share them with other
development teams. The hierarchical relationship between projects,
packages, and classes and interfaces is shown under the Projects
tab in the Workbench.
Figure 4. VisualAge for Java Workbench

For more information on VisualAge for Java repository management, refer to
the online help.
The VisualAge Generator team-development environment uses the same
repository management system as VisualAge for Java, but VisualAge Generator
adds some enhancements to the environment so there are a few terms that apply
to VisualAge Generator development only:
- VAGen parts
- are units of VisualAge Generator 4GL code that are associated with a Java
method in a VAGen part class. VAGen parts are listed in the VisualAge
Generator Parts Browser and are displayed in the VAGen Parts pane depending on
your selections in the Types pane. To display the VAGen Parts Browser,
select the Workspace menu, then VAGen Parts Browser. You can open a
VAGen part by double-clicking on its name in the Parts Browser.
- VAGen part classes
- are Java classes that are used as templates for creating parts to
standardize object specifications, attributes, and behavior for different part
types. VAGen part class names begin with "VAGen."
Figure 5. VisualAge for Java Workbench: VAGen Part Classes and Parts

Unlike traditional source code management systems, where source files are
checked out and checked in, VisualAge for Java's access control
authorizes groups of developers to work on specific classes, packages, and
projects. Developers customize their environment by adding to their
workspace copies of packages (editions) that contain the classes they need to
work on. During the development cycle, programmers create open editions
and scratch editions of packages to make changes to code and run tests.
But each package and each class has a single owner, or manager, who is
responsible for releasing stable versions at appropriate times.
Familiarity with the following terms is essential to understanding how to
manage your code repository:
- Workspace
- In the simplest terms, a workspace is a customized view of items in the
repository, limited to the packages that contain the parts you need to change
or test. All developers have a file stored on their workstations that
defines their workspace. The default image file name is
ide.icx. When you save your workspace, this file is updated to
track which editions and versions of projects and packages you have
added. The next time you start VisualAge Generator, all the projects
and packages displayed in your workspace when you saved it last will be listed
on the Projects and Packages tab of the
Workbench.
- Edition
- In general, editions are packages that are subject to change. The
two kinds of editions you will encounter most often are:
- Open editions--packages that have not been frozen. You can
save classes to open editions in your workspace, and you can recognize them by
the date and time stamp enclosed in parentheses next to their names in the
Workbench. Open package editions can have new classes added to them,
classes deleted from them, and different versions of existing classes released
into them.
Note: | Select the Show Edition Names button on the toolbar to include
edition information beside package and project names.
|
- Scratch editions--copies of packages that are created automatically
when you save changes to an edition that is not open. Scratch editions
allow you to make changes for testing existing classes in packages owned by
other developers, but you cannot add new classes to a scratch edition.
Unlike open editions, scratch editions are displayed in the Workbench with a
version number in single angle brackets (<>) beside the edition
name. Changes made to scratch editions only exist in the image of the
developer who made them and they cannot be released into a package that does
not have an open edition.
- Version
- Versions are editions that have been frozen by the application manager to
prevent further changes to that level of code. They have version
numbers (without angle brackets) instead of date and time stamps next to their
names in the Packages pane of the VisualAge for Java
Workbench.
For hands-on practice loading packages, creating new editions, and other
library management tasks, complete the steps outlined in Chapter 8, "VisualAge Generator Developer on Java: a tutorial".
[ Top of Page | Previous Page | Next Page | Table of Contents | Index ]