Smalltalk User Guide
Preface
Notices
Trademarks
About this book
Who this book is for
What's new?
Support for Tonel has been added
VAST Platform 2024 (version 13.0.0)
VAST Platform 2024 (version 13.0.1)
Conventions used in this book
Tell us what you think
Overview
Getting started
The basic development environment
Browsers in the basic environment
Standard browsers
TrailBlazer browsers
Pop-up menus
Picking a browser
System architecture
Image
Image files
Library
Loading and unloading components
Starting your image
Starting from the desktop
Starting from a command line
Command line arguments
Accessing the command line arguments
Saving an image to keep components loaded
Using the Save Image option
Using the Save Image As option
Saving upon exit
Components
System components
Software components
Getting started with team concepts
Version control
Editions
Versions
Scratch editions
Change and access controls
Component ownership
Application groups
Change controls
Class owner
Class developers
Application managers
Configuration map managers
Access controls
Image and library controls
Application controls
Setting access control privileges for applications
Configuration management
Application lineups
Configuration map lineups
Releasing
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
Creating applications
Creating applications--The basic steps
Example: Creating the application DevelopChooser
Setting application prerequisites
Checking prerequisites
Changing prerequisites
Example: Changing prerequisites for the application DevelopChooser
Defining group members for your application
Adding group members
Deleting group members
Assigning an application manager for your application
Assigning owners for classes
Defining classes
Defining a class--The basic steps
Using an existing class as a template
Using menu options
Example: Defining the class Chooser
Ensuring that the class you are subclassing from is visible
Creating a subclass
Adding variable declarations
Implementing methods
Implementing methods--The basic steps
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
Extending defined classes
Creating a class extension: The basic steps
Example: Extending the class Object
Example: Adding the method needsMoreWork to your class extension
Creating subapplications
Creating subapplications: The basic steps
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
Practice: Creating DevelopTextEditor and DevelopTimeLogger
A shortcut: Copying code into a browser
If you want to skip this practice...
Example: Creating DevelopTextEditor
Creating an application component for DevelopTextEditor
Defining the class TextEditor
Implementing the public instance methods
Implementing the private instance methods
Private methods for category Getters & Setters
Private methods for category Initialization & Startup
Private methods for category Window Creation
Private methods for category Event Handlers
Private methods for category File Operations
Example: Creating DevelopTimeLogger
Creating an application component for DevelopTimeLogger
Defining the class TimeLogger
Implementing the public instance methods
Implementing the private instance methods
Private methods for category Window Creation
Private methods for category Event Handlers
Private methods for category Operations
Copying methods into TimeLogger
Copying methods from Stopwatch
Copying methods from TextEditor
Code for the private instance methods
Opening an instance of TimeLogger
Using TrailBlazer browsers
Loading TrailBlazer
Opening TrailBlazer
Returning to the standard browsers
Example: Using TrailBlazer to create DevelopScreenCapture
Creating an application component for DevelopScreenCapture
Changing prerequisites
Example: Defining the classes ScreenPMCapture and ScreenWinCapture
Creating a subclass
Adding variable declarations
Example: Implementing methods for ScreenPMCapture and ScreenWinCapture
Implementing the private instance methods
Private methods for category Getters & Setters
Private methods for category Initialization
Private methods for category Window Creation
Private methods for category Event Handlers
Private methods for category Image Operations
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
Inspecting objects
Using an Inspector
Inspecting variables
Evaluating expressions in the value pane
Changing variables
Using a Dictionary Inspector
Inspecting some dictionaries in the system
Inspecting your own dictionary
Adding and removing dictionary keys
Adding Keys
Removing Keys
Using a Basic Inspector
Debugging code
Opening a debugger and examining its contents
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
Correcting errors from a debugger
Changing a method in the description pane
Changing an inspected object's variables and values
Adding breakpoints and executing code step-by-step
Adding the message halt
Adding breakpoints using menu options
Modifying breakpoint constraints
Browsing breakpoints
Removing breakpoints
Executing messages individually
Watching value changes
Browsing information on entries in a message stack
Generating an error report
Generating a System Configuration Report
Setting debugger options
Common errors to watch for
Messages not understood
Missing separators
Mismatched brackets or parentheses
Transcript Logging
Transcript Logging menu
Transcript Logging scriptable interface
Handling software components
Moving classes and methods
Moving classes between applications
Preconditions
Steps
Example: Making DevelopStopwatch into an application
Creating the application DevelopStopwatchApp
Moving a class from DevelopStopwatch to DevelopStopwatchApp
Moving methods between classes in the same application
Preconditions
Steps
Moving methods between classes in different applications
Preconditions
Steps
Deleting components
Deleting classes
Prerequisites
Steps
Example: Deleting the class extension from DevelopChooser
Deleting methods
Steps
Deleting applications
Deleting subapplications
Deleting a subapplication from one lineup
Deleting a subapplication from many lineups
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
Filing out and filing in components
What is the VAST chunk format?
Example: Examining the format of filed-out code
Ensuring that your system is set to the VAST chunk format
Filing out a method
Viewing the method's format in a workspace
Filing out components
Filing in components
Filing in components stored in the generic chunk format
Example: Renaming a class and changing its methods
Filing out ScreenPMCapture in the generic chunk format
Examining the filed-out code
Changing the filed-out code
Filing the changed code into the subapplication DevelopCaptureWin
Monticello Importer
Loading the Monticello Importer
Using the Monticello Importer
What the Monticello Importer does
Monticello Importer Troubleshooting
Missing superclass
Missing base class
Method that won’t compile
Tonel
Loading Tonel
Handling team software components
Loading components from a library
Loading components: The process
Loading classes
Steps
Loading methods
Steps
Loading applications
If you know what application you want to load
If you do not know what application you want to load
Loading subapplications
Preconditions
Steps
Loading configuration maps
Example: Loading a configuration map
Unloading components from your image
Unloading classes
Preconditions
Steps
Unloading applications
Preconditions
Steps
Unloading subapplications
Preconditions
Steps
Unloading configuration maps
Creating new editions of existing components
Creating editions: the process
Creating class editions
Preconditions
Steps
Example: Creating a class edition
Creating application or subapplication editions
Preconditions
Steps
Example: Creating an application edition
Creating configuration map editions
Preconditions
Steps
Displaying configuration map timestamps
Loading other editions of components already loaded
Loading editions: The process
Loading class editions
Steps
Loading method editions
Preconditions
Steps
Loading application editions
Preconditions
Steps
Loading subapplication editions
Steps
Loading configuration map editions
Comparing editions
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
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
Comparing editions of the same Configuration Map
Creating versions of components
Creating class versions
Preconditions
Steps
Example: Creating a class version
Creating application versions
Preconditions
Steps
Example: Creating an application version
Creating configuration map versions
Preconditions
Steps
Example: Creating a configuration map version
Versioning and releasing the contained components
Versioning the configuration map
Releasing components
Releasing classes
Preconditions
Steps
Example: Releasing a class
Releasing applications
Preconditions
Steps
Replacing application editions or versions
Adding new applications to a configuration map
Releasing subapplications
Preconditions
Steps
Releasing subapplications into the loaded lineup
Releasing subapplications into several lineups
Grouping applications using configuration maps
Creating configuration maps: The basic steps
Adding new applications
Replacing applications
Deleting applications
Adding, replacing, or deleting applications with TrailBlazer
Adding applications
Replacing applications
Deleting applications
Example: Creating the configuration map Chooser Map
Defining lineups for multiple platforms
Application lineups
Defining application lineups: The process and preconditions
Preconditions
Example: Defining application lineups for OS/2 and Windows
Creating the subapplications DevelopCapturePM and DevelopCaptureWin
Moving platform-specific classes to the subapplications
Releasing the classes to the subapplications
Specifying Boolean expressions for the lineups
Testing lineup expressions in a Workspace
Releasing prerequisites
Releasing platform-specific subapplications
Ensuring that DevelopScreenCapture loads
Replacing subapplications in a lineup
Configuration map lineups
Defining a configuration map lineup: The process and preconditions
Preconditions
Example: Adding a required map to a Chooser Map lineup
Creating Chooser Required Map
Releasing Chooser Required Map into the Chooser Map Lineup
Deleting DevelopmentWidget from Chooser Map
Replacing required map editions or versions in a lineup
Importing components
Preconditions
Importing user objects
Importing class versions
Importing application or subapplication versions
Steps
Importing configuration map versions
Exporting components
Preconditions
Exporting user objects
Exporting class versions
Exporting application or subapplication versions
Steps
Exporting configuration map versions
Setting exporting options
Steps for exporting configuration maps
Attaching non-Smalltalk files
About attachments
Attachment folders
Attachments and stored path names
Attachment types
No versioning of attachments
Opening the Application Attachments browser
Using the Application Attachments browser
Storing attachments
Retrieving attachments
Browsing attachments
Browser menu choices
Folders
Attachments
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
Library operations
Creating libraries
Giving users access to libraries
Adding a user object to a library list
Changing to a different user object
Changing default libraries
Purging and salvaging components
Purging user objects
Purging applications and subapplications
Purging configuration maps
Cloning libraries
Recovering from crashes
Recovering from a file server or EMSRV crash
Recovering from image crashes
What the system checks
Invoking the check for consistency
Recovering lost components
Using the Available Classes menu item
Using the More Recent Editions menu item
Packaging, unloading, and analyzing code
Introduction to packaging
Packaging guidelines
Application prerequisites
Method dispatch
Class/global access
Accessing development environment information
Example: specifying launch code
Implementing the launching method
Files to distribute with your application
Choosing your executable
Simple packaging
What to do before packaging your application
Running the packager
Possible problems
Starting Application
Example: Running the packager
Example: Packaging - saving packaging instructions
Versioning the packaging instructions
Repackaging
Running your packaged image
Problems
Example: Running DevelopChooser
Advanced packaging
Packaging: An overview
Advanced packaging: The process
Summary of packaging steps
Browse Packaged Images
Choose Instructions
Choosing the Packaging Instruction Type
Modify Instructions
Applications and ICs
Startup Code
Policies
Reduce
Examine & Fix Problems
Browse Image Contents Examine & Fix Problems
Save Instructions
Packaging Instructions Application
Output Image
Version packing instructions
Running your packaged image
Setting up to run
Running a packaged image with a User Interface
Running a headless packaged image
Example: Running DevelopChooser
Development Envirionment
VAST Runtime
Making applications "packager friendly"
Application centered packaging
Application packaging hints
packagerIncludeSelectors
packagerKnownSymbols
packagerIncludeClassNames
packagerTranslateSelectors
packagerIgnoreSelectors
packagerIgnoreReferencesInSelectors
Reducing the size of your packaged image
Reducing the number of classes and methods
Avoid unnecessary components
Minimize polymorphism
Create well-structured applications
Minimizing other objects in the packaged image
Finding and removing hidden data
Discarding unnecessary components from base Smalltalk classes
Avoiding unnecessary references to pool dictionaries
Troubleshooting
Exit due to error: 33--Could not open image file
Could not open image file
Exit due to error: 37--Image file is not an image
Does Not Understand errors
Problems during packaging
Output file path
Saving your image
Duplicate object error when packaging
Packaging Statistics
Automated Build Support
AbsBuildSpecification
Public Attributes available for defining an AbsBuildSpecification:
Public Actions:
Validations and Logging
Build Artifacts Output
Unloading ENVY/App image components
Limitations
Unloading specific components
Applications
Example: Unloading an application and its subapplication
Classes
Example: Unloading one class
Example: Unloading a class and its subclasses
Example: Unloading many classes
Compiled methods
Example: Unloading one method
Example: Unloading many methods
Class variables
Example: Unloading a class variable with its current value
Example: Unloading a class variable with a specific value
Class instance variables
Example: Unloading class instance variables
Shared pool variables
Example: Unloading shared pool variables
Global variables
Example: Unloading global variables
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
Running code at load time
Example: Specifying the class and selector to be run
Packaging with image components (ICs)
About ICs
Image components (ICs) and their benefits
Reducing the memory footprint
Facilitating incremental development
Image components as compared to DLLs
The structure of ICs within an application
IC dependencies
Relationship of ICs to applications
IC usage architecture
Pure ICs
Image file with ICs
Explicit binding and unbinding
The process of loading ICs
Explicit loading of ICs
Removing ICs
Initializing an IC
Things to Consider: When to use ICs
General issues
Making maintenance easier
Reducing memory footprint
Minimizing memory footprint during IC loading
Packaging preparation
Step-by-step examples building VA Smalltalk ICs
Creating a leaf IC
Creating a reusable and a leaf IC
Creating a reusable IC
Creating a leaf IC
Test ICs
Creating ICs to be explicitly loaded
Desktop Launcher IC
Creating a platform-dependent IC
Creating the Windows subapplication
Adding a config expression for a Windows subapplication
Creating the OS/2 subapplication
Adding config expressions for OS/2 subapplications
Creating the ICs
Windows leaf IC
OS/2 leaf IC
Implementation issues and tips
Understanding packaging instruction classes
Snapshot classes and snapshot IDs
How snapshot files are located
Caches
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
Output file path
Saving your image
Duplicate object error when packaging
Prerequisite ICs
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
Customizing the icon and splash screen
Changing the program icon on Windows
Providing a customized splash screen
Displaying the splash screen longer
Swapping objects between disks and images
Getting started
Simple object loading and unloading using files
Object loading and unloading using streams
Features of the Swapper
Basic features
Advanced features
Using the Swapper
Simple object loading and unloading
Object replacement
Dumping replacement
Object-identity-based replacement
Class-based replacement
Instance-variable-based replacement
Loading replacement
Combining dumping and loading replacement
Another look at "Redefining methods to implement class-based replacement"
Summary on replacement
Object mutation
Mutation of loaded instances
Requirements for object mutation
Loading objects whose instance variable names have been renamed
Loading objects whose classes have been renamed
Overriding default object mutation code
Application considerations
CompiledMethods
Classes and Metaclasses
Special object considerations
Rehashing of collections
Limitations
Error processing
Where errors are generated
API methods that return error codes
Obsolete API methods that return error codes
Error codes and their expected error objects
Debugging Swapper operations
The Swapper framework
Replacers and strategies as first class objects
Why replacers and strategies?
Dumping replacers
Loading replacers
When to define your own strategies
Resolving method conflicts
Analyzing the runtime performance of code
Quickly determining how long it takes code to run
Example: Having millisecondsToRun: display your code's run time
Analyzing code using the Benchmark Workshop
Writing the bench method
Inherited instance variables
Timing sections of code
Advantages of bench methods
Overview of the Benchmark Workshop
The tool bar
The work area
The execution buttons and benchmark list
The text pane
The line graph
The results bar graph
The status line
Executing the bench method
Preparing to execute the bench method
Specifying the mode of execution
Running a bench method [R]
Sampling a bench method [S]
Tracing a bench method [T]
Stabilizing the benchmark
Factors that affect stability
Factors beyond the control of the Stats tool
Viewing the results
Filtering raw time
Comparing benchmarks
Storing, loading, and clearing benchmarks
Browsing the time distribution
Browsing the method execution
Total time and local time
The methods list and execution tree
Limitations when sampling [S]
Optimizing Smalltalk code
The rules for optimizing Smalltalk code
Run less code
Send fewer messages
Avoid expensive operations
Run your code--not the garbage collector
Using a Memory Monitor
Types of memory space that you can monitor
Interpreting the Memory Monitor display
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
Using and maintaining configuration (.ini) files
.INI file syntax
.INI file contents
Library access stanza
Examples
EMSRV example
File I/O example
Image component (IC) mapping stanza
CommonGraphics stanza
NLS and Locale stanzas
Feature Load stanza
Kernel stanza
Virtual machine options stanza
SocketCommunicationsInterface stanza
PlatformLibrary name mappings stanza
Development Tools stanza
Printing stanza
Preference Settings Framework
Settings Framework API
Application Public Class Methods (modifiable)
Application Public Class Methods (delegated)
Application Public Class Methods
Number, subclass of Number, and Point Public Class Methods
Examples
Executing scripted Smalltalk code during image start up
Ex: pre and post startup
Ex: Load code
Ex: Test code library size
Ex: Automate packaging
Setting up Smalltalk images
Using Preferences Workspace to configure images
Example: Evaluating an expression to change a setting
What Is the VAST chunk format?
Changing the setting to false
Verifying that the setting changed
Extending the system
Changing Transcript menus
Methods that add or remove menus
Example: Adding a Transcript menu
Extending Browser Menus
Adding to browser menus
Adding items to main menus
Adding items to submenus
Controlling menu visibility
Application initialization
Application behavior when starting and stopping the system
Example: Using startUp to open DevelopChooser when the system starts
Application behavior when Windows Power Management events occur
User fields
Stored objects
Storing versions of objects in object stores
Index
Smalltalk User Guide
Smalltalk User Guide
Preface
Notices
Trademarks
About this book
Who this book is for
What's new?
Conventions used in this book
Tell us what you think
Overview
Getting started
The basic development environment
Browsers in the basic environment
System architecture
Image
Image files
Library
Loading and unloading components
Starting your image
Starting from the desktop
Starting from a command line
Accessing the command line arguments
Saving an image to keep components loaded
Using the Save Image option
Using the Save Image As option
Saving upon exit
Components
System components
Software components
Getting started with team concepts
Version control
Editions
Versions
Scratch editions
Change and access controls
Component ownership
Application groups
Change controls
Access controls
Configuration management
Application lineups
Configuration map lineups
Releasing
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
Creating applications
Creating applications--The basic steps
Example: Creating the application DevelopChooser
Setting application prerequisites
Checking prerequisites
Changing prerequisites
Example: Changing prerequisites for the application DevelopChooser
Defining group members for your application
Adding group members
Deleting group members
Assigning an application manager for your application
Assigning owners for classes
Defining classes
Defining a class--The basic steps
Using an existing class as a template
Using menu options
Example: Defining the class Chooser
Ensuring that the class you are subclassing from is visible
Creating a subclass
Adding variable declarations
Implementing methods
Implementing methods--The basic steps
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
Extending defined classes
Creating a class extension: The basic steps
Example: Extending the class Object
Example: Adding the method needsMoreWork to your class extension
Creating subapplications
Creating subapplications: The basic steps
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
Practice: Creating DevelopTextEditor and DevelopTimeLogger
A shortcut: Copying code into a browser
If you want to skip this practice...
Example: Creating DevelopTextEditor
Creating an application component for DevelopTextEditor
Defining the class TextEditor
Implementing the private instance methods
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
Using TrailBlazer browsers
Loading TrailBlazer
Opening TrailBlazer
Returning to the standard browsers
Example: Using TrailBlazer to create DevelopScreenCapture
Creating an application component for DevelopScreenCapture
Changing prerequisites
Example: Defining the classes ScreenPMCapture and ScreenWinCapture
Creating a subclass
Adding variable declarations
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
Inspecting objects
Using an Inspector
Inspecting variables
Evaluating expressions in the value pane
Changing variables
Using a Dictionary Inspector
Inspecting some dictionaries in the system
Inspecting your own dictionary
Adding and removing dictionary keys
Using a Basic Inspector
Debugging code
Opening a debugger and examining its contents
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
Correcting errors from a debugger
Changing a method in the description pane
Changing an inspected object's variables and values
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
Common errors to watch for
Messages not understood
Missing separators
Mismatched brackets or parentheses
Transcript Logging
Handling software components
Moving classes and methods
Moving classes between applications
Preconditions
Steps
Example: Making DevelopStopwatch into an application
Moving methods between classes in the same application
Preconditions
Steps
Moving methods between classes in different applications
Preconditions
Steps
Deleting components
Deleting classes
Prerequisites
Steps
Example: Deleting the class extension from DevelopChooser
Deleting methods
Steps
Deleting applications
Deleting subapplications
Deleting a subapplication from one lineup
Deleting a subapplication from many lineups
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
Filing out and filing in components
What is the VAST chunk format?
Example: Examining the format of filed-out code
Filing out components
Filing in components
Filing in components stored in the generic chunk format
Example: Renaming a class and changing its methods
Monticello Importer
Tonel
Handling team software components
Loading components from a library
Loading components: The process
Loading classes
Steps
Loading methods
Steps
Loading applications
If you know what application you want to load
If you do not know what application you want to load
Loading subapplications
Preconditions
Steps
Loading configuration maps
Example: Loading a configuration map
Unloading components from your image
Unloading classes
Preconditions
Steps
Unloading applications
Preconditions
Steps
Unloading subapplications
Preconditions
Steps
Unloading configuration maps
Creating new editions of existing components
Creating editions: the process
Creating class editions
Preconditions
Steps
Example: Creating a class edition
Creating application or subapplication editions
Preconditions
Steps
Example: Creating an application edition
Creating configuration map editions
Preconditions
Steps
Displaying configuration map timestamps
Loading other editions of components already loaded
Loading editions: The process
Loading class editions
Steps
Loading method editions
Preconditions
Steps
Loading application editions
Preconditions
Steps
Loading subapplication editions
Steps
Loading configuration map editions
Comparing editions
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
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
Creating versions of components
Creating class versions
Preconditions
Steps
Example: Creating a class version
Creating application versions
Preconditions
Steps
Example: Creating an application version
Creating configuration map versions
Preconditions
Steps
Example: Creating a configuration map version
Releasing components
Releasing classes
Preconditions
Steps
Example: Releasing a class
Releasing applications
Preconditions
Steps
Replacing application editions or versions
Adding new applications to a configuration map
Releasing subapplications
Preconditions
Steps
Grouping applications using configuration maps
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
Defining lineups for multiple platforms
Application lineups
Defining application lineups: The process and preconditions
Example: Defining application lineups for OS/2 and Windows
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
Importing components
Preconditions
Importing user objects
Importing class versions
Importing application or subapplication versions
Steps
Importing configuration map versions
Exporting components
Preconditions
Exporting user objects
Exporting class versions
Exporting application or subapplication versions
Steps
Exporting configuration map versions
Setting exporting options
Steps for exporting configuration maps
Attaching non-Smalltalk files
About attachments
Attachment folders
Attachments and stored path names
Attachment types
No versioning of attachments
Opening the Application Attachments browser
Using the Application Attachments browser
Storing attachments
Retrieving attachments
Browsing attachments
Browser menu choices
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
Library operations
Creating libraries
Giving users access to libraries
Adding a user object to a library list
Changing to a different user object
Changing default libraries
Purging and salvaging components
Purging user objects
Purging applications and subapplications
Purging configuration maps
Cloning libraries
Recovering from crashes
Recovering from a file server or EMSRV crash
Recovering from image crashes
What the system checks
Invoking the check for consistency
Recovering lost components
Packaging, unloading, and analyzing code
Introduction to packaging
Packaging guidelines
Application prerequisites
Method dispatch
Class/global access
Accessing development environment information
Example: specifying launch code
Files to distribute with your application
Simple packaging
What to do before packaging your application
Running the packager
Possible problems
Starting Application
Example: Running the packager
Example: Packaging - saving packaging instructions
Running your packaged image
Example: Running DevelopChooser
Advanced packaging
Packaging: An overview
Advanced packaging: The process
Summary of packaging steps
Browse Packaged Images
Choose Instructions
Modify Instructions
Reduce
Examine & Fix Problems
Save Instructions
Output Image
Version packing instructions
Running your packaged image
Example: Running DevelopChooser
Making applications "packager friendly"
Application centered packaging
Application packaging hints
Reducing the size of your packaged image
Reducing the number of classes and methods
Minimizing other objects in the packaged image
Troubleshooting
Exit due to error: 33--Could not open image file
Could not open image file
Exit due to error: 37--Image file is not an image
Does Not Understand errors
Problems during packaging
Packaging Statistics
Automated Build Support
Unloading ENVY/App image components
Limitations
Unloading specific components
Applications
Classes
Compiled methods
Class variables
Class instance variables
Shared pool variables
Global variables
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
Running code at load time
Example: Specifying the class and selector to be run
Packaging with image components (ICs)
About ICs
Image components (ICs) and their benefits
Things to Consider: When to use ICs
Packaging preparation
Step-by-step examples building VA Smalltalk 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
Implementation issues and tips
Understanding packaging instruction classes
Snapshot classes and snapshot IDs
How snapshot files are located
Caches
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
Customizing the icon and splash screen
Changing the program icon on Windows
Providing a customized splash screen
Displaying the splash screen longer
Swapping objects between disks and images
Getting started
Simple object loading and unloading using files
Object loading and unloading using streams
Features of the Swapper
Basic features
Advanced features
Using the Swapper
Simple object loading and unloading
Object replacement
Object mutation
Application considerations
CompiledMethods
Classes and Metaclasses
Special object considerations
Rehashing of collections
Limitations
Error processing
Where errors are generated
Error codes and their expected error objects
Debugging Swapper operations
The Swapper framework
Replacers and strategies as first class objects
When to define your own strategies
Analyzing the runtime performance of code
Quickly determining how long it takes code to run
Example: Having millisecondsToRun: display your code's run time
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
Using a Memory Monitor
Types of memory space that you can monitor
Interpreting the Memory Monitor display
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
Using and maintaining configuration (.ini) files
.INI file syntax
.INI file contents
Library access stanza
Image component (IC) mapping stanza
CommonGraphics stanza
NLS and Locale stanzas
Feature Load stanza
Kernel stanza
Virtual machine options stanza
SocketCommunicationsInterface stanza
PlatformLibrary name mappings stanza
Development Tools stanza
Printing stanza
Preference Settings Framework
Executing scripted Smalltalk code during image start up
Setting up Smalltalk images
Using Preferences Workspace to configure images
Example: Evaluating an expression to change a setting
Extending the system
Changing Transcript menus
Methods that add or remove menus
Extending Browser Menus
Adding to browser menus
Controlling menu visibility
Application initialization
Application behavior when starting and stopping the system
Example: Using startUp to open DevelopChooser when the system starts
Application behavior when Windows Power Management events occur
User fields
Stored objects
Storing versions of objects in object stores
Index