Outline

Effective VisualAge for Java, Version 3

by Scott Stanchfield and Isabelle Mauny

ISBN: 0-471-31730-6

What is an IDE?
- Enter the IDE
- IDE Benefits
Files, Be Gone!
Through the Eyes of VisualAge for Java
- Repository, Workspace, and Workbench
- The Repository
- The Workspace
- The Workbench
- Teamwork in VisualAge for Java
Method-Level Interaction
Incremental Compilation
Hello World!

Chapter 2 Creating Code

Looking at Your Code in the Workbench
- Projects, Packages, Types, and Methods
Choosing Appropriate Names
- Basic Conventions
- Types
- Variables and Methods
- Packages
- Projects
Workbench Layout
Creating Projects
- Adding Elements from the Repository
Creating Packages
Creating Classes
- Creating Applications and Applets
Creating Interfaces
Creating Fields
- The Create Field SmartGuide
- Direct Field Entry
- Fields for JavaBean Component Properties
Creating Methods
- The Create Method SmartGuide
- Manual Method Entry
- Creating a Method Using Save
- Method Templates
- Generating Required Methods
- Creating Accessor Methods for Fields
- Overriding Methods
Editing Your Code
- Basic Editing
  - Cursor Movement
  - Selecting Code
  - Copy/Cut/Paste
  - Undo and Redo
- Saving Your Changes
- Searching in the Source/Comment Pane
  - Find/Replace
  - Incremental Find
- Code Completion
  - Keyword Completion
  - Macros
- Compilation Errors
  - Other ways to tell if you have errors
  - Getting Rid of the Error Dialog
- Formatting Your Code
- Key Bindings
  - The Whatis Command
- Miscellaneous Commands
  - Goto Line Number
  - Open Selection
  - Revert to Saved
  - Commenting Code
  - Indenting Code
  - Sorting Selected Lines
Program Element Properties
- Applet Parameters
- Program Parameters
- Class Path Parameters
- Code Generation Parameters
- Class Information
Running Your Code
- The Console
Reorganizing Program Elements
- Copying Elements
- Moving Elements
- Renaming Elements
- Fixing/Migrating References

Chapter 3 Navigating Your Code

Browsers, Pages, and Panes
- Tree Panes
  - Expanding and Collapsing Nodes
  - Opening Elements in a New Browser
  - Filtering the View
- List Panes
- Graph Panes
- Actions on Program Elements
  - Projects
  - Packages
  - Classes and Interfaces
  - Fields
  - Methods
- Cloning and Locking Windows
- Multiple Windows versus Single Window
The Workbench
- The Projects Page
  - Setting Bookmarks
- The Packages Page
  - List versus Tree Views
  - Inheritance Filters
  - Overriding the Easy Way
- The Classes and Interfaces Pages
- The Managing Page
- The All Problems Page
The Project Browser
- The Editions Page
The Package Browser
The Class Browser
The Interface Browser
The Method Browser
Searching Your Workspace
- Using the Class Selection Dialog
- The Go To Command
- Searching for Program Elements
- Doing a Simple Search
- Defining Working Sets
- Search Results Window
- Impact Analysis
- Using Find/Replace
- Using Text Search/Replace
The Log
Customizing VisualAge for Java
- General
- General->Cache
- General->Key Bindings
- Appearance
- Appearance->Lists
- Coding
- Coding->Compiler
- Coding->Code Assist
- Coding->Debugging
- Coding->Formatter
- Coding->Formatter->Spacing
- Coding->Indentation
- Coding->Keyword Completions and Coding->Macros
- Coding->Managing
- Coding->Method Javadoc and Type Javadoc
- Help
- Help->Tips and Help->Warnings
- Resources
- Resources->Resource Associations
- RMI Registry
- Visual Composition
- Visual Composition->Code Generation
- Visual Composition->Quick Form Manager
- Remote Access to Tool API
- Tools and Features

Chapter 4 Using Version Control

Where does VisualAge Keep Code ?
- The Repository
- The Workspace
- Enterprise versus Professional Edition
Overview of Versioning
- How VisualAge Associates Program Elements
- Performing Version Control Tasks
  - Creating Projects and Packages
  - Versioning Life Cycle
  - Working with Editions
  - Packaging the Application
  - Reconciling Changes
Working with a Team
- Setting Up the Team Environment
- Migrating From Professional to Enterprise
- You Need Discipline and Communication
- Forming The Team
  - Developers and Owners
  - Setting Component Ownership
- Development Cycle
  - Creating Rolling Baselines
  - Creating Scratch Editions
  - Delivering The Application
Grouping Multiple Projects
- Creating Solution Maps
- Solution Maps and Ownership
- Exporing/Importing Solution Maps
Managing Resources
Extracting Repository Information
A Bit of Administration
- Purging Program Elements
- Compacting the Repository
- Managing Multiple Repositories
Understanding the IDE Startup Process
Integration with External Software Configuration Management (SCM) Tools
- What Has Changed in Version 3.5

Chapter 5 Testing And Debugging

The Integrated Debugger
- The Debugger Window
  - The Debug Page
  - The Breakpoints Page
  - The Exceptions Page
- Managing Breakpoints
  - Configuring Thread Breakpoints
  - Attaching Expressions to Breakpoints
  - Configuring Iteration Breakpoints
  - Globally Enabling/Disabling Breakpoints
- The Debugger Commands
  - Rewinding Execution
- Handling Threads
- Monitoring and Inspecting Variables
  - Watching Variables and Expressions
  - The Inspector Window
  - The Evaluation Window
- Modifying Code While Debugging
  - Modifying Method Contents
  - Modifying Variable Values
- Handling Exceptions
- Debugging External Classes
- Debugging System Programs
- Debugging Program Initialization
The Scrapbook
- Handling Scrapbook Pages
- Interacting With the Code
- Understanding Java Contexts
- Runtime Behavior
- Importing External Code
The Distributed Debugger
- Debugger Architecture
- Installing the Distributed Debugger
- Debugging Interpreted Java Code
  - Exporting Code for Debugging
  - Starting the Debugger
  - The Debugger Client
  - Setting Breakpoints
  - Stepping in the Code
  - Monitoring Variables and Expressions

Chapter 6 Integrating With The File System

General Concepts
Exporting Code
- Exporting HTML for Applets
- Consideration for JavaBeans Components
- Strategies for Debugging
- Preserving Visual Composition Data
- Deploying Jar Files
Importing Code
- Importing from a Directory
- Importing Files With Errors
Using Repository Interchange Files
- Exporting Interchange Files
- Importing Interchange Files
- Migrating from Professional to Enterprise
Managing Resource Files
- Loading Resources in your Program
- Sharing Resources
- Resources and Export/Import
- Resources and Repository Interchange Files
Creating HTML Documentation
- Changing Method and Type Javadoc Comments

Chapter 7 Introduction To JavaBean Components

Beans are Vain Classes
What Makes a Class a Bean?
Bean Features
- Properties
  - Simple Properties
  - Indexed Properties
  - Bound and Constrained Properties
  - Bound Properties: Reporting Property-State Changes
  - Constrained Properties: Property Validation by Delegation
  - How Can a Tool Tell is a Property is Bound or Constrained?
- Event Sets
  - An Event Class
  - An Event-Listener Interface
  - An Event-Source Bean
  - A Sample Event Listener
  - Determining Which Events Are Fired
- Methods
Bean-Builder Tools and Beans
- Introspection and the Role of BeanInfo Classes

Chapter 8 The BeanInfo Editor

Birth of a Bean
The BeanInfo Editor
Basic Use of the BeanInfo Editor
Working with Properties
- Adding and Extending Properties
- Bound Properties
- Constrained Properties
- Modifying Properties
- Deleting Properties
- Changing the Type of a Property
- Changing a Property's Bound or Constrained Status
Working with Event Sets
- Adding Support for Existing Events
- Creating New Events
  - Generating Event Support Classes
  - Adding Details to the Generated Event Class
  - Firing the Generated Events
- Deleting Event Sets
Working with Methods
- Creating Methods through the BeanInfo Editor
- Deleting Methods
Synchronization of a Bean and its BeanInfo
- Adding Features to a BeanInfo Class

Chapter 9 Extension And Composition

Creating Beans through Extension
- General Strategies for Easily Extendible Beans
- A Simple Extension
- Extending to Bind an Unbound Property
- Binding Swing Components
Creating Beans through Composition
- A Simple Delegation Scenario

Chapter 10 Bean Composition In The VCE

I Didn't Mean to Do That!
Basic VCE Operation
The Beans Palette
- Customizing the Beans Palette
  - Adding Individual Beans to the Palette
  - Adding Several Beans from a Project to the Palette
  - Adding to the Beans Palette During JAR Import
The Design Area
- Dropping Beans
- Selecting Beans
- Popup Menus for Beans in the Design Area
- Naming Beans
- Moving Beans
- Copying Beans
- Deleting Beans
- Morphing Beans
- Changing the Definition of a Used Bean
The Beans List
Property Sheets
- Expert and Hidden Properties
- Multiple Selection and the Property Sheet
- Resetting Property Values
Using Beans to Compose Beans
- Break It Down!
- Promoting Features
  - Promoting a Property
  - Promoting an Event
Creating an Application or Applet
- Creating a Visual Application from Scratch
  - Create a Visual Class
  - Visually Compose the Class
- The Create Applet SmartGuide
  - The Create Applet Page
  - The Applet Properties Page
  - The Events Page
  - The Code Writer Page
  - The Parameters Page
  - The Applet Info Page
- The Create Application SmartGuide
  - The Create Application Page
  - The Applications Details Page
  - Customizing the Menu Bar
  - Customizing the Tool Bar
  - Generating Code

Chapter 11 Layout Management

GUI Design versus GUI Implementation
Absolute Positioning of Components
- Alignment Tools
- Distribution Tools
- Sizing Tools
Layout Management in the VCE
- FlowLayout
- BorderLayout
- GridLayout
- CardLayout
- BoxLayout
  - Box Beans
- GridBagLayout
A Useful GUI Pattern
Quick Form
- Generating a Quick Form
  - Defining a bean for our Quick Form
Custom Layout Managers
- The Public Default Constructor
- Layout Constraints
- Layout Parameters
- Using the Custom Layout Manager
Focus Ordering in the VCE
- AWT Tab Ordering
- Swing Tab Ordering

Chapter 12 Connections

Types of Connections
- Connection Sources and Targets
- Event Connections
  - Event-to-Method Connections
  - Event-to-Code Connections
  - Property-to-Method and Property-to-Code Connections
  - Event-to-Property Connections
- Connection Parameters
  - Setting Constant Parameter Values
  - Passing Event Data
  - Parameter Connections
- Property-to-Property Connections
  - Target Property Initialization
  - Synchronization of Bound Properties
  - An Example
  - Property-to-Property versus PropertyChangeEvent-to-Property
  - Changing Property-to-Property Direction
  - Changing Source and Target Events
- Result Connections
- Exceptions During Connection Processing
  - Handling Specific Connection Exceptions
Renaming Connections
Changing the Source or Target Bean
Changing Connection Shape
Order of Connection Execution

Chapter 13 Variables And Instances

Tearing-off Properties
- Manually Reaching our Goal
- Using Tear-Off Properties to Automate the Process
Casting Using Variables
- Casting Example: Manipulating a CardLayout
Variables as Plugs for External Classes
When a Variable Changes
Switching Between Variables and Instances
Variable Initialization

Chapter 14 Design Patterns For The VCE

General Strategies
- Less is More
- Code is Ok, If it is Visible
- Breakdown for Maintenance
- Separation is Key
Connection Patterns
- Factorization Patterns
  - Trigger Pattern
  - Funnel Pattern
  - Enabler Pattern
- Conditional Patterns
  - Visual Assertion Pattern
  - Conditional Fork Pattern
GUI Composition Patterns
- Encapsulated Promotion
- Hook Pattern
- Event Catcher
- Event Percolation Pattern
Boolean and Arithmetic Operations

Chapter 15 Model-View-Controller In The VCE

Available online at MVC In VisualAge for Java.

What Is MVC?
Interaction Between Components
Delegates - Combining View and Controller
Why is MVC So Important?
Implementing MVC in VisualAge for Java
Defining a Model Interface
- Bound Properties and GUI Components
- Making Things Easier in VisualAge for Java
Example Models
Defining SimpleAddressData
Defining AddressDataModel
Defining HashAddressBook
Defining AddressBookModel
Filling in the Implementation Details for HashAddressBook
Creating Delegates
A Delegate for AddressBook
Connecting as an Application
Running the Application
Fixing the Problem
- Adding a Simple Copy to the add() Method
- Using the Prototype Pattern
- Using a Factory Model
Adding Another Delegate
- Using the New Delegate

Chapter 16 Advanced Model-View-Controller Techniques

Available online at Advanced MVC.

Advanced MVC Strategies
Advanced Models and Delegate
- Models as Proxies
  - Models as Simple Filters
  - Filtering Existing Data
  - Narrowing your Phone List
  - Filtering is Only the Beginning
  - Models as Joins
  - Thinking About More Proxies
- Selection Models
  - Enter the Selection Model
  - Implementing a Selection Model
Food for Thought
- Documentation
- Advanced Delegates

Chapter 17 Factory Beans

When to Use Factory Bean
- Temporary Storage Creation
- Lazy Instantiation
Implementing Event Percolation

Chapter 18 Using AWT And Swing In The VCE

Heavyweight and Lightweight Components
AWT versus Swing and MVC
Swing Borders and Icons
Look and Feel
Top-level Components
Menus
- Swing Menu Construction
Dialogs
Grouping Radio Buttons
Scrolling Swing Components
JTabbedPane
Swing Model Usage
TableColumn
Desktop Panes and Internal Frames
Using Swing 1.1.1 in VisualAge for Java, version 3.0
- Current Swing Support
- Setting up Swing 1.1.1 in VisualAge for Java, version 3.0
- Writing Swing 1.1.1 Applications in VisualAge for Java, version 3.0
- Migrating Swing Code to VisualAge for Java, version 3.5

Chapter 19 Handwritten Code vs. Generated Code

Note: A large section of this chapter was omitted due to space limitations. This section, "Understanding the Generated Code", appears online at http://www.javadude.com/vaj under "Understanding the Generated Code".

Adding User Code to Generated Methods
- General Advice: Do Not Do It!
- Where It Is Safe to Add User Code
- Keep Clean Separation!
Keep Interfaces Simple
Use Beans Consistently

Chapter 20 Bean Customization

Property Editors
- Saving the Last Property Value in Bean Builders
  - The setValue() Method
  - The getValue() Method
- Starting Simple: String Editors
  - The getJavaInitializationString() Method
- Using the Property Editor
  - Explicit Property Editor Association Using BeanInfo
  - Explicit Property Editor Registration
  - Using Naming Conventions to Edit Properties
  - Recommended Registration Strategies
  - How the VCE Locates Property Editors
- Making the Property Editor a Bit Nicer...
- Taking Control of the Property Edit
- A More Natural Interface
- The Final Touch
- Locating Property Editors, Revisited
Customizers
- Simple and Direct Property Edits
  - Customizers Assist Inter-Property Relationships
- Problems with Complex Property Edits
When to Provide Property Editors and Customizers

Chapter 21 Database Programming

Populating Data in a Table
- Checking Prerequisites
  - Adding the Access Bean Feature
  - Adding JDBC Drivers to the Class Path
- Creating the InsertClassics Application GUI
- Customizing the Modify Bean
  - Creating a Package for the Database Access Class
  - Creating a Modify Bean
  - Defining the Database Connection
  - Using DataSources
  - Defining a DataSource
  - Testing a DataSource Programmatically
  - Using a DataSource in a Database Connection
  - Defining the SQL Specification
  - A Look at the Generated Code
- Completing the Application
  - Registering a Quick Form
  - Using Quick Form on the Modify Bean
  - Finalizing the Application
Displaying a List of Rows
- Creating the GUI
- Customizing the Select Bean
  - Choosing Database Tables
  - Defining Joins
  - Defining Conditions
  - Selecting Columns to Show
  - Ordering the Rows
  - Reviewing the Mapping
  - Testing the SQL Statement
- Changing Caching Options
  - Navigating in the ResultSet
  - Handling Exceptions
- Completing the GUI
  - Creating Table Columns Manually
  - Using the Select Bean to Update Data
- Understanding Other Expert Properties
- Using the Database Application SmartGuide
- Using the Selector Beans
Querying Data with Stored Procedures
- Configuring DB2
- Invoking the Stored Procedure Builder
- Creating a Database Connection
- Creating a Stored Procedure
- Special Considerations for VisualAge
- Calling the Stored Procedure from an Application
Developing SQLJ Programs
- Prerequisites
- Editing SQLJ Files
  - Using a Different Editor
  - Creating SQLJ Files
  - The Translation Process
  - Setting the Right Translator
  - Changing Translation Options
  - Calling Translate
- Profile Customization
- Debugging SQLJ Programs
  - Deploying the Code
  - Creating an Environment File
  - Debugging the Application

Chapter 22 Developing Distributed Applications

Overview of Distributed Objects
Developing RMI Applications
- Writing the Remote Interface
- Creating the Server Application
- Generating RMI Stubs and Skeletons
- Creating a Client Application
- Running the Application
- The Transition to CORBA
Developing CORBA Applications
- Pre-requisites
- The IDL Page
- Creating the Counter Interface
  - Creating an IDL Group
  - Adding an IDL Object
- The Evil Reserved Package
- Installing a Third-party ORB
- Setting Compiling Options
- Generating the Java Classes
- Versioning the IDL and Generated Classes
- Importing and Exporting IDL Files
- Searching IDL

Chapter 23 Enterprise Programming

Introduction to Enterprise Beans
- Enterprise JavaBeans Architecture
- Enterprise Beans Types
  - Session Beans
  - Entity Beans
- Enterprise Beans and "Normal" Beans
Developing a Simple Session Bean
- Introduction to the EJBs Page
- The Hello World Enterprise Bean
  - Adding an EJB Group
  - The Evil Reserved Package
  - Creating the Session Bean
  - Adding Business Logic
- Modifying the Deployment Descriptor
- Testing the Hello World Bean
  - Generating Deployment Code and Test Client
  - Setting Up the Execution Environment
  - Running the Test Client
  - Using the TestClient in Version 3.5
  - Modifying Code on the Fly
- Creating a Client Application
- Using Access Beans
  - Creating a Java Bean Wrapper Access Bean
  - A Look at the Access Bean Code
  - Modifying the Client Program
Working With Entity Beans
- Creating the Song Entity Bean
  - Creating the Entity Bean
  - Defining Container-Managed Fields
  - Modifying ejbCreate Methods
- Database Mapping
  - Introducing VisualAge Mapping Tools
  - Using the Top-Down Approach
    - Handling the Database Schema
    - Creating the Schema in the Database
    - Converting Java Types to SQL Types
    - Handling the Schema Map
  - Using the Meet-in-the-Middle Approach
    - Import the Database Schema
    - Creating the Schema Map
    - Saving the Mapping Information
  - Testing an Entity Bean
Using Inheritance and Associations
- Enterprise Beans Inheritance
  - Looking at the Generated Code
  - Using Single Table Mapping
  - Using Root Leaf Mapping
    - Creating the Tables
    - Defining Foreign-Key Relationships
    - Mapping Tables to Enterprise Beans
- EJB Associations
  - A Look at the Generated Code
  - Modifying the ejbCreate and ejbPostCreate Methods
  - Completing the Table Mapping
Deployment Considerations
- Deploying to WebSphere Advanced Edition
- Deploying to Other Application Servers
- Deploying to Component Broker
Troubleshooting
- Deleting an Entity CMP Field
- Deleting Enterprise Beans
- Renaming Enterprise Beans
- Changing an EJB Package Name
- Importing Enterprise Beans Definitions to the EJB Page
- Transporting EJBs Definition
Migrating from Version 3.02 to Version 3.5
Advanced Topics
- Declaring Const Methods
- Defining Environment Variables
- Creating Finder Methods
- Creating an EJB Home Factory

Chapter 24 Developing Servlets And Java Server Pages

Installing and Testing the Environment
- Prerequisites
- Using the WebSphere Test Environment
  - Starting the WebSphere Test Environment (version 3.02)
  - Stopping the WebSphere Test Environment (version 3.02)
  - Starting/Stopping the WebSphere Test Environment (version 3.5)
- Testing the Installation
Configuring the WebSphere Test Environment
- Modifying the HTTP Port and Document Root Properties
Developing Servlets
- Quick Introduction to Servlets
- Creating the Calcday Servlet
  - A Reusable Basic Servlet
  - Creating the Day Bean
  - Creating the CalcdayServlet
Testing Servlets
- Using the Servlet Wizard (version 3.5 only)
- Unit Testing with Servlet Launcher
- Calling a Servlet from an HTML Page
Debugging Servlets
Developing JSP Components
- Quick Intro to JSP Components
- Choosing the Right JSP Compiler (version 3.02 only)
- Modifying the CalcdayServlet
- Completing the JSP Files
- Running and Debugging JavaServer Pages
  - Setting JSP Debugging Options
  - Working with the JSP Execution Monitor
  - Debugging JSP Components
  - Dealing with JSP Syntax Errors
  - Dealing with JSP Java Errors
  - Stepping in JSP Source Code
  - Import Troubleshooting
Calling Enterprise Beans From Servlets
- Creating the Song Access Bean
- Testing the Access Bean
- Creating the ListSongs servlet
- Completing the ListSongs JSP Component
- Testing the Whole Solution
Advanced Configuration
- Setting Servlet Engine Properties
  - Changing Transport Definitions (version 3.5 only)
  - Changing Hostname Bindings
- Working with Web Applications
- Creating Your Own Web Application
- Customizing Default Servlets in A Web Application
- Adding User Servlets to a Web Application
- Starting the Servlet Engine Manually (version 3.02 only)

Chapter 25 Tool Integration

An early version of this chapter is available online at http://www.javadude.com/vaj. See "Using the Tool API".

Features
- Creating Features
  - Step 1: Export the Projects
  - Step 2: Copy the Project Resources
  - Step 3: Create Help HTML
  - Step 4: Create the Control File
  - Step 5: Delete the Projects from Your Workspace
  - Step 6: Shutdown and Restart VisualAge for Java
  - Step 7: Add the Feature
  - Step 8: I Say Zip it! Zip it Good!
  - Updating Existing Features
Tool Integration
- Developing Tools
  - Step 1: Add the Tool API Feature
  - Step 2: Write the Tool Code
  - Step 3: Export the Code
  - Step 4: Copy Resources and Help
  - Step 5: Create the Control File
  - Tool Contexts
  - Sample Control Files
  - Step 6: Shutdown and Restart VisualAge for Java
  - Step 7: Run it!
  - Step 8: When a New Tool Comes Along, You Must Zip It!
  - Updating Existing Tools
- VCE Tool Setup
- Testing and Execution
Writing a Tool
- Version Considerations
- The Tool API Packages
- Are We Running in VisualAge for Java?
  - A Simple Example
- Interfaces Everywhere!
- Connecting to the Workspace
- Are We Running Team Version Control?
- Workspace and Repository Contents
  - Workspace and Repository Models
  - The Workspace Interface
  - The Repository Interface
  - Working with Projects
  - Working with Packages
  - Working with Types
- Running a Class
- Helping the User Pick an Object
  - Common Parameters
  - Workspace Prompting Methods
- Exporting and Importing
  - Import and Export Specifications
- Generating Code
  - The Code Generation Interfaces
  - Code Generation Tasks
- Storing Tool Options
  - Setting Tool Data
  - Checking to See If Tool Data Exists
  - Reading the Tool Data
  - Deleting the Tool Data
  - Storing Other Files
  - Workspace and Repository Data
- Miscellaneous Features
- Removing Features and Tools
Internationalization and Features/Tools

Appendix A Internationalization

What is Internationalization?
- What Must Be Internationalized?
String Internationalization
- The Externalize Strings Command
- Where Did All My Strings Go?
- Now What?
- Changing VCE Properties After Externalizing Strings
General Internationalization Strategy

Appendix B Maintenance And Troubleshooting

Performance
- Fragmentation and Disk Speed
- Workspace and Repository Size
  - Keeping a Lean Workspace
  - Warehousing
  - Purging
- System Resources
Maintenance and Recovery
- Backups
  - The Repository
  - The Workspace
  - Other Files
- Corrupt Workspace Recovery
  - Recovering Workspaces that VisualAge Could Not
- Version Upgrades

Appendix C Overview of Changes in VisualAge for Java

Changes Between Versions 3.02 and 3.5
- The Workbench
- Editor
- Version Control
- Removed Features
- WebSphere Test Environment
- Database Programming
- Other Features
Changes Between Versions 2.0 and 3.02
- The Workbench
- Keyboard Features
- Code Assist
- Editor
- Searching
- Import/Export
- Debugging
- Scrapbook
- VCE
- BeanInfo
- WebSphere Test Environment
- Other Features
- Tool API

Appendix D The CD ROM

System Requirements
- Prerequisites for VisualAge for Java, Version 3.5
  - Installation of VisualAge for Java, Version 3.5
The CD-ROM Organization
IBM's VisualAge for Java
- Why We Included the Professional Edition
- Installing VisualAge for Java
Instantiations' VA Assist/J
- Features of VA Assist/J
  - Version Control Enhancements
  - Browser/Ergonomic Enhancements
  - Visual Composition Enhancements
  - Import and Export Enhancements
- Installing VA Assist/J
The Book's Sample Code
- License and Disclaimer for the Sample Code
- Installing the Sample Code
- Sample Code Contents
Tools and Features
- License and Disclaimer for Tools and Features
- Tool Installation
- Tool Descriptions

Appendix E VisualAge for Java Resources

Web Sites
Frequently-Asked Questions
- jGuru.com VisualAge for Java FAQ
- IBM VisualAge Developer Domain FAQ
Newsgroups
- VisualAge for Java Newsgroups
- Java Newsgroups
- Newsgroup Archives
Books

JavaDude.com

-- Scott Stanchfield