Expanded Notices
Trademarks
Expanded About this book
What this book includes
Who this book is for
About this product
Conventions used in this book
Expanded What's new in this version?
Tell us what you think

Getting started
Expanded Introducing the Smalltalk development environment
The IBM Smalltalk development environment
Expanded Starting your product
Using a Transcript or Workspace window
Text editing
Evaluating Smalltalk expressions
Browsers in the base environment
Expanded A guided tour: Creating your first Smalltalk application
Expanded The Applications Browser
Method visibility
Creating the application STCalculatorApp
Creating the class STCalculator
Defining the class
Expanded Adding the method open
Testing STCalculator
Finishing the open method
Expanded Finishing the user interface
Fixing errors
Browsing CwRowColumn
Expanded Adding functions
The Classes Browser
Adding the remaining methods
Expanded Debugging the calculator
Introducing the Debugger
Expanded Tidying up the Calculator application
Extending another class
Categorizing methods
Public and private methods
Checking prerequisites
One last change
Ending the tour
Expanded System architecture
Image
Expanded Library
Loading and unloading components
Expanded Starting your image
Starting from the desktop
Starting from a command line
Recovering the command line
Image files
Expanded Saving an image to keep components loaded
Using the Save Image option
Using the Save Image As option
Saving upon exit
Expanded Components
System components
Software components
Expanded Classes
Defined classes
Extended classes
Visible classes
Public classes and private classes
Expanded Methods
Viewing methods
Method categories
Expanded Applications
Applications group classes
Applications relate to other applications
Subapplications
Configuration maps
Expanded Getting started with team concepts
Expanded Version control
Editions
Versions
Scratch editions
Expanded Change and access controls
Component ownership
Application groups
Change controls
Access controls
Expanded Configuration management
Application lineups
Configuration map lineups
Releasing
Expanded Organizing your team
Assigning team roles
Starting a project
The generic development process
Naming your components
Developing classes and creating individual baselines
Creating baselines as a team

Making your own applications
Expanded Creating applications
Creating applications--The basic steps
Example: Creating the application DevelopChooser
Setting application prerequisites
Checking prerequisites
Changing prerequisites
Expanded Defining group members for your application
Adding group members
Deleting group members
Assigning an application manager for your application
Assigning owners for classes
Expanded Defining classes
Expanded Defining a class--The basic steps
Using an existing class as a template
Using menu options
Expanded Example: Defining the class Chooser
Ensuring that the class you are subclassing from is visible
Creating a subclass
Adding variable declarations
Expanded Implementing methods
Implementing methods--The basic steps
Expanded Example: Adding methods to the defined class Chooser
Implementing the method open
Implementing the remaining ten methods
Opening Chooser
Ensuring that Chooser loads with DevelopChooser
Expanded Extending defined classes
Creating a class extension: The basic steps
Example: Extending the class Object
Example: Adding the method needsMoreWork to your class extension
Expanded Creating subapplications
Creating subapplications: The basic steps
Expanded Example: Creating the subapplication DevelopStopwatch
Creating a subapplication component
Defining the subclass Stopwatch
Implementing methods for Stopwatch
Opening the window
Completing work on your subapplication
Expanded More practice: Creating DevelopTextEditor and DevelopTimeLogger
A shortcut: Copying code into a browser
If you want to skip this practice...
Expanded Example: Creating DevelopTextEditor
Creating an application component for DevelopTextEditor
Defining the class TextEditor
Implementing the private instance methods
Expanded Example: Creating DevelopTimeLogger
Creating an application component for DevelopTimeLogger
Defining the class TimeLogger
Implementing the public instance methods
Implementing the private instance methods
Copying methods into TimeLogger
Expanded Using the enhanced browsers (TrailBlazer)
Loading TrailBlazer
Expanded Opening TrailBlazer
Returning to the standard browsers
Expanded Example: Using TrailBlazer to create DevelopScreenCapture
Creating an application component for DevelopScreenCapture
Changing prerequisites
Expanded Example: Defining the classes ScreenPMCapture and ScreenWinCapture
Creating a subclass
Adding variable declarations
Expanded Example: Implementing methods for ScreenPMCapture and ScreenWinCapture
Implementing the private instance methods
Opening an instance of the screen capture tool
Categorizing the methods
Copying methods to the other platform-specific class
Example: Enabling a Display Image push button

Inspecting and debugging code
Expanded Inspecting objects
Expanded Using an Inspector
Inspecting variables
Evaluating expressions in the value pane
Changing variables
Expanded Using a Dictionary Inspector
Inspecting some dictionaries in the system
Inspecting your own dictionary
Adding and removing dictionary keys
Using a Basic Inspector
Expanded Debugging code
Opening a debugger and examining its contents
Expanded Determining the cause of an error
Finding errors in evaluated expressions
Finding errors in nonevaluated code
Examining a message stack
Inspecting variables from a debugger
Expanded Correcting errors from a debugger
Changing a method in the description pane
Changing an inspected object's variables and values
Expanded Adding breakpoints and executing code step-by-step
Adding the message halt
Adding breakpoints using menu options
Executing messages individually
Watching value changes
Browsing information on entries in a message stack
Generating an error report
Setting debugger options
Expanded Common errors to watch for
Messages not understood
Missing separators
Mismatched brackets or parentheses

Handling software components
Expanded Moving classes and methods
Expanded Moving classes between applications
Preconditions
Steps
Example: Making DevelopStopwatch into an application
Expanded Moving methods between classes in the same application
Preconditions
Steps
Expanded Moving methods between classes in different applications
Preconditions
Steps
Expanded Deleting components
Expanded Deleting classes
Prerequisites
Steps
Example: Deleting the class extension from DevelopChooser
Expanded Deleting methods
Steps
Deleting applications
Expanded Deleting subapplications
Deleting a subapplication from one lineup
Deleting a subapplication from many lineups
Expanded Deleting application prerequisites
Deleting a prerequisite from the lineup in your image
Deleting a prerequisite from a lineup not in your image
Deleting a prerequisite from all lineups
Expanded Filing out and filing in components
Expanded What is the IBM Smalltalk format?
Example: Examining the format of filed-out code
Filing out components
Expanded Filing in components
Filing in components stored in the generic format
Example: Renaming a class and changing its methods

Handling team software components
Expanded Loading components from a library
Loading components: The process
Expanded Loading classes
Steps
Expanded Loading methods
Steps
Expanded Loading applications
If you know what application you want to load
If you do not know what application you want to load
Expanded Loading subapplications
Preconditions
Steps
Loading configuration maps
Example: Loading a configuration map
Expanded Unloading components from your image
Expanded Unloading classes
Preconditions
Steps
Expanded Unloading applications
Preconditions
Steps
Expanded Unloading subapplications
Preconditions
Steps
Unloading configuration maps
Expanded Creating new editions of existing components
Creating editions: the process
Expanded Creating class editions
Preconditions
Steps
Example: Creating a class edition
Expanded Creating application or subapplication editions
Preconditions
Steps
Example: Creating an application edition
Expanded Creating configuration map editions
Preconditions
Steps
Displaying configuration map timestamps
Expanded Loading other editions of components already loaded
Loading editions: The process
Expanded Loading class editions
Steps
Expanded Loading method editions
Preconditions
Steps
Expanded Loading application editions
Preconditions
Steps
Expanded Loading subapplication editions
Steps
Loading configuration map editions
Expanded Comparing editions
Expanded Comparing applications contained in two editions of a configuration map
Example: Comparing two editions of a single configuration map
Comparing classes contained in two application editions
Expanded Comparing methods
Comparing methods used by two class editions
Comparing two editions of one method
Comparing two methods used by one class
Comparing editions of two different configuration maps
Expanded Creating versions of components
Expanded Creating class versions
Preconditions
Steps
Example: Creating a class version
Expanded Creating application versions
Preconditions
Steps
Example: Creating an application version
Expanded Creating configuration map versions
Preconditions
Steps
Example: Creating a configuration map version
Expanded Releasing components
Expanded Releasing classes
Preconditions
Steps
Example: Releasing a class
Expanded Releasing applications
Preconditions
Steps
Replacing application editions or versions
Adding new applications to a configuration map
Expanded Releasing subapplications
Preconditions
Steps
Expanded Grouping applications using configuration maps
Expanded Creating configuration maps: The basic steps
Adding new applications
Replacing applications
Deleting applications
Adding, replacing, or deleting applications with TrailBlazer
Example: Creating the configuration map Chooser Map
Expanded Defining lineups for multiple platforms
Expanded Application lineups
Defining application lineups: The process and preconditions
Example: Defining application lineups for OS/2 and Windows
Expanded Configuration map lineups
Defining a configuration map lineup: The process and preconditions
Example: Adding a required map to a Chooser Map lineup
Replacing required map editions or versions in a lineup
Expanded Importing components
Preconditions
Importing user objects
Importing class versions
Expanded Importing application or subapplication versions
Steps
Importing configuration map versions
Expanded Exporting components
Preconditions
Exporting user objects
Exporting class versions
Expanded Exporting application or subapplication versions
Steps
Expanded Exporting configuration map versions
Setting exporting options
Steps for exporting configuration maps
Expanded Attaching non-Smalltalk files
Expanded About attachments
Attachment folders
Attachments and stored path names
Attachment types
No versioning of attachments
Opening the Application Attachments browser
Expanded Using the Application Attachments browser
Storing attachments
Retrieving attachments
Browsing attachments
Browser menu choices
Expanded Stored path names
How stored path names are derived
How stored path names are displayed
Supported platforms and file system types

Performing team system administration
Expanded Library operations
Creating libraries
Expanded Giving users access to libraries
Adding a user object to a library list
Changing to a different user object
Changing default libraries
Expanded Purging and salvaging components
Purging user objects
Purging applications and subapplications
Purging configuration maps
Cloning libraries
Expanded Recovering from crashes
Recovering from a file server or EMSRV crash
Expanded Recovering from image crashes
What the system checks
Invoking the check for consistency
Recovering lost components

Packaging, unloading, and analyzing code
Expanded Introduction to packaging
Expanded Packaging guidelines
Application prerequisites
Method dispatch
Class/global access
Accessing development environment information
Files to distribute with your application
Expanded Simple packaging
What to do before packaging your application
Expanded Running the packager
Possible problems
Running your packaged image
Expanded Advanced packaging
Expanded Packaging: An overview
Packaging terminology
Expanded Advanced packaging: The process
Summary of packaging steps
Detailed packaging procedure
Expanded Making applications "packager friendly"
Application centered packaging
Application packaging hints
Expanded Reducing the size of your packaged image
Reducing the number of classes and methods
Minimizing other objects in the packaged image
Expanded Unloading ENVY/App image components
Limitations
Expanded Unloading specific components
Applications
Classes
Compiled methods
Class variables
Class instance variables
Shared pool variables
Global variables
Expanded Unlinking all instances of a specific class
Example: Unlinking all instances of a class
Unlinking all instances of a specific method
Excluding version information
Setting the image startUp class
Expanded Running code at load time
Example: Specifying the class and selector to be run
Expanded Packaging with image components (ICs)
Expanded About ICs
Image components (ICs) and their benefits
Things to Consider: When to use ICs
Packaging preparation
Expanded Step-by-step examples building VisualAge ICs
Creating a leaf IC
Creating a reusable and a leaf IC
Creating ICs to be explicitly loaded
Creating a platform-dependent IC
Creating the ICs
Expanded Implementation issues and tips
Understanding packaging instruction classes
Snapshot classes and snapshot IDs
How snapshot files are located
Caches
Expanded Troubleshooting
Exit due to error: 33--Could not open image file
Exit due to error: 37--Image file is not an image
Problems during packaging
Side effects of using the -r command line option
Error attempting to load into a read-only object
Primitive failures during explicit IC loading
Errors during IC packaging
Reference to excluded pool
Excessive packaging time
Evaluation images
Runtime error at startup
Development image fails to start-up (Error 33)
Loading and unloading ICs
Expanded Customizing the icon and splash screen
Changing the icon on Windows and OS/2
Providing a customized splash screen
Displaying the splash screen longer
Expanded Swapping objects between disks and images
Expanded Getting started
Simple object loading and unloading using files
Object loading and unloading using streams
Expanded Features of the Swapper
Basic features
Advanced features
Expanded Using the Swapper
Simple object loading and unloading
Object replacement
Object mutation
Expanded Application considerations
CompiledMethods
Classes and Metaclasses
Special object considerations
Rehashing of collections
Limitations
Expanded Error processing
Where errors are generated
Error codes and their expected error objects
Debugging Swapper operations
Expanded The Swapper framework
Replacers and strategies as first class objects
When to define your own strategies
Expanded Analyzing the runtime performance of code
Expanded Quickly determining how long it takes code to run
Example: Having millisecondsToRun: display your code's run time
Expanded Analyzing code using the Benchmark Workshop
Writing the bench method
Overview of the Benchmark Workshop
Executing the bench method
Stabilizing the benchmark
Viewing the results
Browsing the time distribution
Browsing the method execution
Limitations when sampling [S]
Optimizing Smalltalk code
Expanded Using a Memory Monitor
Types of memory space that you can monitor
Interpreting the Memory Monitor display
Expanded Using a Memory Use Report
Memory usage by application, class, and method
Memory usage by application, class, and method
Memory usage during execution

Setting up, customizing, and extending the system
Expanded Setting up configuration files
Expanded Library access parameters
Example library access configurations
Image component (IC) mapping
Bitmap path
NLS path
Overriding Locale settings
NLS recognition
Virtual machine options
Expanded Setting up Smalltalk images
Expanded Using Preferences Workspace to configure images
Example: Evaluating an expression to change a setting
Expanded Namespace support
Expanded Namespaces
Scope rules
Namespace management
Expanded Declarations
Declaration methods
Declaration syntax
Expanded Working with declaration methods
Why use declaration methods?
Where to declare?
When several applications contribute to a pool
Placement of declarations
Platform-dependent declarations
Adding, deleting, and changing declarations
Finding declaration methods
Correcting declaration errors
Loading previous editions of applications that do not have declaration methods
File-out format
Expanded Extending the system
Expanded Changing Transcript menus
Methods that add or remove menus
Application initialization
Expanded Application behavior when starting and stopping the system
Example: Using startUp to open DevelopChooser when the system starts
Expanded User fields
Stored objects
Storing versions of objects in object stores

Appendixes
Index