• 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 2023 (version 12.0.0)
  • 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