Example Session (user input in bold):

  > stx -R
  STX> #clear answerprompt
  STX> 10 factorial.
  3628800
  STX> #set timing
  STX> 100 factorial.
  9332621544394415268169923885...
  10ms
  STX> #clear timing
  STX> x := 10 factorial.
  STX> x + x.
  7257600
  STX> #show variables
  _0 -> 7257600
  _1 -> 3628800
  _2 -> 9332621544394415268169923885
  _3 -> 3628800
  x -> 3628800...
  STX> 'hello'
  asUppercase
  .
  'HELLO'
  STX> 'hello' asUppercaseFirst.
  'Hello'
  STX> 'hello' foo.
  Error encountered: String does not understand: #foo
  Debug (y/n): y
    ...
    backtrace
    ...
    MiniDebugger> a
    Evaluation aborted.
  STX> #set nodebug
  STX> 'hello' foo.
  Evaluation aborted: String does not understand: #foo
  STX> #clear nodebug
  STX> #read MyClass.st
  STX> MyClass start
  STX> ^D
  >

Defaulting Command Line Options via Shell Variables

• STX_MORE_ARGS
  if set, and the "--noShellArgs" option is not present, the value of this shell variable is prepended to the list of arguments.

• STX_DEFAULT_ARGS
  if no command line argument was given at all (i.e. ST/X was started with "stx" alone), the value of this shell variable is used as a list of arguments.

Quickstart Command Line Option (--quick)

When started without a snapshot image, Smalltalk/x first does a recursive scan of all directories below the stx-top directory for autoloadable packages. This is done for your convenience, so that many tools, demos and other support classes are already present as autoload-stubs in the class hierarchy. Autoloaded classes are simple proxy objects which perform an on-demand lazy loading of missing code for you.

This recursive scan can be somewhat slow if many directories are present or the filesystem is slow (on a network drive). It is therefore often useful to start the system without autoloaded classes, and load missing packages either via the launcher's file menu, pr programatically with

    Smalltalk loadPackage: <packageID>

To start ST/X without autoloaded classes, use the "--quick" command line option.

Motivation for no longer making this a default behavior:
Because autoloading is only possible in the IDE (where the classes source code is accessible), but not for standalone applications, a common error situation is to access or depend upon classes which were originally autoloaded, but not binary-compiled into a classLibrary-dll. So during development in the IDE, these classes were present and everything worked fine. On the other hand, it lead to a runtime exception in the deployed application. Therefore, it was recommended to always use the "--quick" option during development, so the programmer got informed about any missing class.
We thought, that it is better to avoid such mistakes right away.

Autoload Command Line Option (--autoload)

The Debugger

Leaving the Debugger

You should be aware that the debugger is one of your best friends in the Smalltalk IDE. In contrast to other programming languages, getting into the debugger is far from being fatal in Smalltalk. In fact, many Smalltalk programmers place breakpoints into as yet unimplemented branches of their source, and develop the program almost exclusively inside the debugger, by adding the missing code, as the halts are reached. This ensures, that all of the code has been reached at least once and has already been tested at least once when the coding is complete.

The debugger's actions are controlled by a set of buttons, a main menu, and a popup menu in the walkback view (for the less frequently used functions).

The most useful button actions are:

• Abort
  execution continues at some save place in the interrupted process.
  The definition of what a "save place" is, depends on the process: for UI processes (such as workspaces, launchers etc. ) it's usually the place where input events are read.
  (To Smalltalkers: technically, an AbortOperationRequest exception is raised, for which a handler exists in the window's main event loop.)
  (To C-talkers: this is kind of a longjmp back to the window's main eventloop.)

• Continue
  the debugger will be closed, execution continues where it was interrupted.
  This will often trigger other errors and bring the debugger back again, if the error occurs in a loop, or if the followup processing gets confused by the first error. (for example, if the error was an unimplemented message send, the continue-function will continue as if the method was a no-operation and returned nil, which is often not what the caller expected.) Notice that not all exceptions are proceedable. For a non-proceedable exception, the "Continue"-button is disabled and you have to "Abort" instead.

• Terminate
  this will terminate the process (thread) in which the error occured.
  Usually, there is one process associated to each toplevel window on the screen. Pressing terminate shuts down this process and closes all of its views. Therefore, if an error occurs while evaluating a doIt in a workspace, the terminate function will abort the processing, terminate the process and close the workspace as a side effect.

  The terminate function is disabled, if the affected process is the scheduler or the event dispatcher process (since if those were terminated, proper operation of the system would no longer be possible).

• Next and Step
  single-step to the next line ("Next") or message send ("Step") in the selected method. In contrast to the "Send"-button, these step over any code in called methods (unless another error or halt is encountered). The debugger will regain control after the step, and show the current line, the position of the next message send which is about to be executed. "Next" and "Step" always operate on the currently selected context in the top list. By selecting the "about to be executed method" in the walkback, you can continue stepping in this called method. By selecting a context further up in the calling hierarchy (i.e. further down in the list), a caller can be stepped.

• Restart
  restarts the selected method from the beginning. This is especially useful after a code change in that method, or in one of the methods called by it.

There are many other button and menu functions in the debugger. Read ``Using the debugger'' for more information.

Hint:
When you are new to the system, you probably should not care about all of those options; simply press Abort or the close-button in the windows title area to get out of the faulty computation.

Entering the Debugger

You can also type the interrupt key "Break/Pause" in any view, to force the corresponding view-process to be interrupted and to enter the debugger. Thus, to interrupt an ongoing doIt, simply press "Break/Pause" into the workspace window. If your keyboard does not provide such a key, try "CTRL-." which is provided as an alternative (and is also compatible to other Smalltalk system's interrupt key).
(The key used to be "Ctrl-c" in previous Unix versions, but has been changed to have a unified keyboard mapping across systems. "Ctrl-c" is now copy on all systems.)

Finally, pressing "CTRL-c" in the terminal (xterm- or console) window where Smalltalk was started, forces a hard-interrupt, which interrupts any running process - even the scheduler, event dispatcher, other system process. This will usually bring you into a so called "Minidebugger" (see below), a very simple command line debugger. If ST/X does not even respond to "CTRL-c" in the terminal window, try quickly pressing it twice or more times.

The Minidebugger is especially useful to leave endless loops in undebugged user primitive code or if you made a mistake in changing some system code.

On some Unix systems, this interrupt key is labeled "INTR" or "DEL".
If "CTRL-c" does not work in your xterm, read the Unix manual page on the `stty' command for details.

Notice, that you can have multiple debuggers open at the same time, operating on different processes. However, only one so called "modal debugger" may operate on the scheduler or event dispatcher process. Pressing the interrupt key in the terminal window will usually bring you into a modal debugger.

or evaluate one of the following in a workspace:

    self halt:'stopped for debug'

    |someVariable|

    someVariable := 0.
    Transcript showCR:(5 / someVariable)

Aborting without Entering the Debugger

The "CTRL-Break" key handling is a functionality of the Smalltalk event handler - it does not work in the terminal window.

(Notice: in previous releases, this function used to be on the "Ctrl-y" key-combination. This has been changed to conform to standard conventions. "Ctrl-y" now means "redo")

Leaving the Low-Level Emergency (Mini-)Debugger

The system considers errors occuring in the graphical debugger itself as serious. For example, if you have changed the Scrollbar class which is also used in the debugView, or if any other error occurs while the debugView is initializing itself.

You may also get into the MiniDebugger, if you press "CTRL-C" in the terminal window.

• Type "?" at its prompt to get a list of options.

• try "c" (for continue)
• try "a" (for abort)
• if that does not help, try "T" (for terminate process)
• or "Q" (for quick terminate process)
• or "x" (to exit Smalltalk/X)

If all of the above fail, you should exit Smalltalk, restart from a previously saved image and reapply any changes using the ChangesBrowser. The MiniDebugger also offers two commands for emergency saving: "S" to save a crash-image, and "C" to save your session changes into a separate changes file.

The crash image can be browsed later with the snapshot image browser, or you can try to restart it (although that will likely fail).

In rare cases (other Smalltalk processes are running, and the scheduler suspended the debuggers process), the MiniDebugger may seem to not react to your input.
If this happens, press the interrupt key again (as described above) and try again. The interrupt should reenter the MiniDebugger in an exclusive input mode and stop any scheduling of other processes.

Editing

PopUp Menus

The menu's entries depend on the type of view and often on the context or type of object/text being displayed. Typically, it offers operations on the contents or the current selection.

Some views offer an extra control-middleButtonMenu, which is activated if the "CTRL" key is pressed simultaneously with the mouse button.
These control menus provide additional functions - which are either seldom needed or perform ST/X's developers hidden private goody operations ;-).
However, they may be useful for others too - try the control menu in the browser's code view or its class list (select a class first).

Scrolling Text

Scrolling using Scrollbars

• when the mouse-button is pressed below or above the so-called thumb, the text is scrolled page-wise (one page for every click).

• If the "SHIFT" key is pressed while the mouse button is pressed, positioning will be to that position. Thus you can position quickly within an even large text.

• If the "CTRL" key is pressed while the mouse button is pressed, positioning will be to the very top or to the end of the document.

• if you keep holding the mouse button down in one of the scrollbars up/down buttons, the view starts to autorepeat its scroll operation. It stops doing so, if you move the mouse pointer out of the up/down buttons area, or if the mouse button is released.
  Pressing "SHIFT" speeds up the autoscroll a bit

• If you move the mouse horizontally in vertical scroller or vertically in a horizoontal scroller), while keeping the mouse button pressed, the scroller will at some distance snap back and scroll to its original position. Move the mouse back towards the scroller to continue scrolling. This is very useful if you either change you mind while scrolling, or if you only want to look at some other place in the document and return to where you started.

Scrolling using the Mouse-Wheel

• If the "SHIFT" key is pressed while the mouseWheel is operated, the mouseWheel performs LINE-wise scrolling.

• If the "CTRL" key is pressed while the mouseWheel is operated, the mouseWheel performs PAGE-wise scrolling.

• Otherwise, the mouseWheel adjusts its scroll speed according to the size of the document and the size of the window. Typically, each motion-tick leads to a scroll of a few lines of text.

Scrolling using Cursor-Keys

Of course, moving the text-cursor in a textView or moving the selection in a list-view via the cursor keys also leads to a scroll operation if required.

Mini Scrollers

Selecting Text

1. press the button over the first character to be selected,
2. while-being pressed, move the mouse-pointer to the end position
3. release the mouse-button.

It is also possible to move the mouse pointer out of the view, while the mouse button is kept pressed. The view will then start to automatically scroll. The farther away you move the pointer from the views border, the faster will it scroll. This is the easiest way of selecting text: just let it scroll by and stop when the end-position arrives.

• a double click selects the word under the mouse pointer,
• a triple click selects the whole line,
• a quadruple click selects the whole text.

If you keep the button pressed and start to move after a double click, it continues to select whole words; moving after a triple click continues to select whole lines.

If you double click one of a parenthesis, bracket or brace, the text up to and including the matching one is selected.

Notice, ST/X differentiates between two types of selections:

• regular selections which were created by dragging the mouse,
• and pasted selections, which were created by pasting text.

There are also two convenient keyboard shortcuts (*) for selecting:

• "CTRL-a" - select all
  to select the whole text (same as quadruple-click)

• "ESC"
  to select from the beginning of the line up to the current cursor position. (Thus to evaluate something in a workspace, you have to press two keys only: "ESC" followed by "CMD-d".)

In Smalltalk, selecting has always been a separate action than copying. To copy something into a buffer, you first have to select the text then do a copy action.
In contrast to that, X-Window's xterm and toolkit views use a different style where select and copy are combined; whenever text is selected, this is automatically placed into the copy buffer.

Especially when new to the system, this may be a bit confusing.
(My personal feeling is that X's behavior is a result of a poor design, which was later made a ``feature'' - especially with the newest xterms, where you have to press "SHIFT" in addition, making things even more confusing ;-)

Editing Text

Most editors allow you to type in changes in a modeless fashion anywhere on the editors window area (i.e. there are no invisible and hidden tabulators or end-of-line characters embedded). Like on a piece of paper, you can position the text-cursor whereever you like, and start typing text. The editor will insert blanks or empty lines automatically, as required. This behavior can be turned off by checking the "ST80 Cursor Behavior"-flag in the ("Settings" - "Tools" - "Editor") settings dialog.

Special Characters

Accepting

The opposite of "accept" is "cancel". This will undo you changes and revert back to the last saved ("accepted") version.

As an option, the class browser adds two buttons to its code-editor window. These allow for very quick "accept" or "cancel". Also, they give a very prominent feedback on the modification state of the text.

Keyboard Accelerators / Function Keys

• "CTRL-c" - Copy
  the selected text is copied into the copy-paste-buffer. This also places the selection into the display's clipboard, to allow pasting it into a non Smalltalk (xterm) view.

• "CTRL-x" - Cut
  the selected text is deleted. The text is also copied into the copy-paste-buffer and to the display's clipBoard.

• "CTRL-v" - Paste
  the contents of the copy-paste-buffer is inserted at the current cursor position. If there is currently a selection, the selected text will be replaced. This also pastes selections from other (xterm) windows.

  If you press the "Shift" key in addition (i.e. "CTRL-SHIFT-V"), a list of previously copied text fragments is shown, from which you can choose the text that should be pasted ("copy history").

• "CMD-j" - Join line
  joins the cursor-line with the next line at the current cursor column. (i.e. the rest of the line after the cursor is deleted).

• "CTRL-f" or "CMD-s"- Find / Search & Replace
  opens a panel to start a string search. The entered search string and case-ignore-mode are remembered for followup "Search forward" and "Search backward" operations (see below).
  The dialog also offers an option to replace matching strings by another string.

• "CMD-f" - Search forward
  search forward in the text, and position the cursor to (and select) the next occurrence of the search-string. The search-string is either the current selection or - if there is no selection - the last search string entered into the search-string box.
  Thus, to search for the next occurrence of some word under the cursor, select it and type "CMD-f".

• "CMD-b" - Search backward
  search backward in the text, like above, but search backward.

• "CMD-w" - Select word
  selects the word under the cursor, or the whitespace between words, depending on the character under the cursor. A word is defined as any sequence of alphanumeric characters delimited by separators. If there is currently a selection, the next word or whitespace is selected.

• "CTRL-l" - Goto line-number
  opens a box to ask for a line-number and positions the cursor to that line.

• "CTRL-z" - Undo
  undoes the effect of the last text-modification(s). Every editor keeps a (possibly unlimited) undo list. This list remembers all changes made to the text and allows for undo/redo of edit modifications. The redo function is found in the textview's popup-menu (under the "others"-submenu).
  The undo list is cleared whenever the text is "accepted" (see below) (i.e. a files text is written back or a methods code is saved).

• "CTRL-y" - Redo
  undoes the the last undo.

• "CTRL-+" - Larger font
  
• "CTRL--" - Smaller font
  these change the font size of the view (which has the focus). With "SHIFT", the font size of all views is changed. (read more in "Changing the Font" below).

Cursor positioning:

• "Home" or "Pos-1" (Mac: "FN-CrsrLeft")- start of line
  position the cursor to the begin of the current line. If the line is indented (i.e. spaces at the beginning), and the cursor was positioned after the first non-space character, the cursor will be moved to right before the first non-blank character. Otherwise, the cursor is positioned to column 1.

• "End" (Mac: "FN-CrsrRight") - end of line
  position the cursor to the end of the current line

• "Ctrl-w" - next word
  position the cursor to the beginning of the next word. Numbers (i.e. digit sequences) are treated like words. Other characters (punktuation) are treated like single-character words.

• "Ctrl-W" - end of word / next word
  similar to the above. However, the cursor is first moved to the end of the current word. Then, the next press moves it to the beginning of the next word. Useful especially in a keyboard macro, to position the cursor to the end of a word.

• "Ctrl-m" - match
  position the cursor on the matching parenthesis. The definition of what matching parenthesis are depends on the editor's (programming-) language setting. Usually, this will be Smalltalk-mode, where "()", "[]" and "{}" are defined as pairs. However, the editor of a filebrowser uses the mime-type of the edited document to define those pairs. So, for example when editing HTML or XML, "<>" are also defined as matching pairs.

• "SHIFT-Return" - non inserting cursor return

• "SHIFT-Tab" - non inserting tab
  however, if there is a line-selection (i.e. a full line or a number of full lines), SHIFT-Tab will undent by 4 (remove 4 leading spaces).
  Unshifted, the Tab-key will indent the selected lines by 4 spaces.

• "Ctrl-Home" - start-of-screen/text
  when first pressed, move the cursor to the first visible line. If pressed again, move it to the very beginning of the text.

• "Ctrl-END" - end-of-screen/text
  when first pressed, move the cursor to the last visible line. If pressed again, move it to the very end of the text.

• "PageUp" - previous page

• "PageDown" - next page

Function-keys (these are configured during startup, by the "keyboard.rc" script-file):

• "F2" - Rename
  Which object is to be renamed depends upon the view in which you pressed the key. In a fileBrowser, the currently selected file(s) is/are renamed. In a systemBrowser, the class, method or selected variable is renamed.

• "F3" - Comment
  comment the selected (Smalltalk-) code. If the selection is a "full-lines-selection", an End-of-line comment is used.
  If the selection is a single word, or spawning multiple lines but not covering full first and last lines, a regular comment is used.
  If nothing is selected, the current cursors line is commented.

• "F4" - Uncomment
  uncomment the selected (Smalltalk-) code.
  The same heuristic behavior is as in the above "Comment" function is used.

• "F6" - Case Change
  convert the selected text to lowercase / uppercase / uppercase-first. Press this key multiple times to cycle through the above conversions.

• "F8" - Redo/Again
  search forward and repeat the last cut- or replace-operation.
  For example, to replace all occurrences of "foo" by "bar" in the text, select the first "foo" and type "bar" to replace it. Then repeat pressing F8 until no more replacements are possible.

• "F9" - Undent by four
  if present, remove 4 leading spaces in the cursor line, or the selected line range.
  The same operation is performed by the SHIFT-Tab-key (if there is a line-selection)

• "F10" - Indent by four
  add 4 more leading spaces in the cursor line, or the selected line range.
  The same operation is performed by the Tab-key (if there is a line-selection)

• "F11" - Undent by one
  if present, remove one leading spaces in the cursor line, or the selected line range.

• "F12" - Indent by one
  add one more leading spaces in the cursor line, or the selected line range.

• "CMD-a" or "CTRL-s" - accept / save
  the whole text (not just the selection) will be installed and changes be made permanent. The definition of what exactly "installing" means is context dependent:
  • in a file browser, the text is saved into the edited file.

  • in a system browser, the current method will be recompiled from the editor's code and installed; or if a class definition is being shown, a class is created/modified.

  • in a debugger, the selected method is be recompiled from the editor's text

  • in an inspector, the selected text's value is stored into the selected instance variable.

  • a change browser applies the shown change.

• "CMD-e" - explain (Windows: "F1")
  tries to explain the selected text, which must be a single word. This figures out, who implements a message or where a peritcular variable is defined.

• "CMD-SPACE" - abbreviation/snippet insert
  inserts a snippet using the word before the text-cursor as the name of of the abbreviation. For example, typing "itf" followed by "CMD-SPACE" will insert a template for the "ifTrue:ifFalse:" message send. The set of abbreviations can be edited via the Workspaces pulldown menu.

• "CTRL-SPACE" - code completion
  complete the word to the left of the cursor. This completion is syntax aware - if the word to the left of the cursor is a partial variable name, the best variable (as visible in the scope) is searched. If it's a message selector, the best matching message name is searched.
  If more than one completion is possible, a popup menu offers a choice among the most likely completions.

  Notice that most programmers prefer "as you type" completion hints, which shows possible completions automatically. Enable this via the Launcher's "System" - "Settings" - "Tools" - "Editor" settings dialog.

No change in the text will have any permanent effect, unless you accept the new text. Thus, to revert back to the original code in a system browser, simply reselect the method again.

Please read ``Keyboard commands'' in ``Configuration & Customization'' on how to add/change function keys settings. Especially, if your window manager (motif) catches some of these keys for its own window operations, you may have to change (some of) these settings. (i.e. use "CTRL" instead of "CMD").
Finally, see the keyPress:x:y: methods in the TextView class and its subclasses. You can easily modify these to add more functions.

In addition to using (and defining keys for) those builtin functions, it is also possible to define your own text or action macros. Read ``Keyboard macros'' in ``Configuration & Customization'' for more info on this.

Changing the Font

As opposed to many other (Smalltalk-) IDEs, we prefer a fixed-width font for code, as it makes tabular data much easier to look at and leads to a more consistent indentation. Therefore, the default is set to a fixed width "Courier" font. If you don't like this, please change it via the Launcher's settings dialog ("Settings" - "ViewStyle" - "Font").

To change an individual editor's font (i.e. one which is already open), open its font selection dialog via the "Other" - "Other" - "Font" - popup menu item.
The font size can be quickly changed by turning the mouse-wheel while keeping the "CTRL"-Key pressed, or with the "CTRL-+" (ctrl-plus) and "CTRL--" (ctrl-minus) keys.

In addition, "SHIFT-CTRL-+" and "SHIFT-CTRL--" will change the font sizes of ALL text views.

Moving the Keyboard Focus (Tabbing)

If you don't like this behavior, define an additional pair of tabbing keys, to function as (alternative) "FocusNext" and "FocusPrevious" keys.
Using the keyboard map, these can be set to "Alt-CursorLeft" and "Alt-CursorRight", for example.
(the default mapping defines both "Alt" and "Ctrl" combinations of the cursor keys.)

A dialog can be quickly closed (cancelled) with the "Escape" key.

Focus Mode ("focus-follows-mouse" vs. "focus-on-click")

Notice, that an explicit focus-assignment (eg. via tabbing) is never changed by simple mouse movements.

Smalltalk

Evaluating Smalltalk Expressions

The middle button menu's doIt function does this; it parses the selected text (i.e. checks it for being a correct piece of Smalltalk code) and silently evaluates the corresponding Smalltalk expressions. To try it, open a workspace and type (or copy-paste from this example):

    Transcript showCR:'hello'

    Transcript showCR:(100 factorial)

    WorkspaceApplication open

Unless the expression does some printing itself (as in the first two examples), the result of the evaluation is not shown anywhere.
To see the result of such an evaluation, use the middle button menu's printIt function.
Just like doIt, this evaluates the expression; however, after the evaluation, it inserts a printed representation of the result at the current text-cursor position.
See the difference between doIt and printIt when executing:

    100 factorial

Finally, inspectIt opens an inspector window on the result, where you can have a look at the resulting object in more detail.
Try to inspect the result of:

    Array new:10

    Point x:10 y:25

• "CMD-d" - doIt
  the selected text is evaluated as a Smalltalk expression (if nothing is selected, the whole text in the cursors line is evaluated).

• "CMD-p" - printIt
  the selected text is evaluated as a Smalltalk expression, and a printed representation of the result is inserted as the new selection (use cut to remove it).

• "CMD-i" - inspectIt
  the selected text is evaluated as a Smalltalk expression and an Inspector is opened on the result.

• "CMD-B" - browseIt (notice the shifted-"B" key)
  evaluates the selected text, and opens a browser on the result (if it evaluated to a class) or on its class.

• "Break" - interrupt
  stops the evaluation and enters a debugger. In the debugger, you may proceed with the evaluation by pressing 'Continue'. Depending on the system, the break key is either the "Interrupt/Pause"-key or "CTRL-c". For the convenience of Squeak and VisualWorks users, "CMD-." (alt-period) is also mapped to this function.

• "CTRL-Break" - abort
  stops and aborts the evaluation (without debugger).

Also notice that all keyboard shortcuts are defined in the startup scripts (usually in "display.rc"). Read ``Configuration & Customization'' and have a look at the startup files.

Variables and Scope in a doIt Evaluation

In a Workspace

"self" refers to nil. Global variables (Smalltalk bindings) are visible. In addition, special Workspace- and Doit-Variables are optionally visible (see the description in Workspace).

In an Inspector

"self" refers to the inspected object. Direct and inherited instance variables and class variables are visible.

In a Debugger

"self" refers to the receiver of the currently selected context. Like in the code, method local variables, direct and inherited instance variables and class variables are visible.

In a Browser

"self" refers to the selected class. Class variables and private classes are visible.

Loading Existing Code / Using the FileBrowser

    Smalltalk fileIn:filename

To see the contents of a file, double-click on its name in the fileBrowser's top list. Also directories are changed in this way.

More info on the fileBrowser is found in ``Using the FileBrowser''.

Importing Code from Other Smalltalk Dialects

Non-graphical classes should work (almost) unchanged even if they originated from these systems - if you find interesting code on an ftp-archive, you may also try to fileIn this.

Although ST/X was written to be protocol compatible to other Smalltalk implementations (i.e. ANSI-Smalltalk), most classes were implemented differently and internals are completely different. Loaded code depending on such internals may not work as expected.

In practice, most non-graphical classes work unchanged; however, if a loaded class depend on a particular superclass implementation (accessing instance variables), or superclass hierarchy (accessing superclasses by name), this may not be true. In this case, you should open a Changes Browser on the source file, and apply individual changes one-by-one, to see where problems arise.

Packages from Squeak/Pharo can also be imported in their native Monticello package format; for this, use a "Monticello Browser".

Programming

Start by examining existing simple demo programs (such as the ClockView, TicTacToe, PenDemo etc.
All classes also include a documentation method category, where you will find two methods called "documentation" and "examples".
The examples can be selected in the browser and evaluated via the doIt menu function.

More info on the System Browser is found in ``Using the SystemBrowser''.
An introduction to Smalltalk and programming is found in the ``Smalltalk Beginners Tutorial''.

Learning Smalltalk

• get yourself a textbook on Smalltalk (see literature)
• learn how to use the SystemBrowser
• try and understand the basic classes (especially: containers, numbers & streams)
• create and inspect instances of some classes
• 'talk' to these objects in the inspector
• place breakpoints on methods and see what happens when single stepping
• although there are lots of existing classes, create new collection classes and play with them

For a rough overview of what is there, read ``Basic Classes Overview'' and start excursions to the classes encountered there.
Many classes contain example methods in their documentation category. Try these, and understand what is going on there. Also, many methods (especially in the collection classes) contain a comment with some sample expressions at the end. These are meant to show short typical uses of those methods.

Getting more used to the language, try creating a little graphical application or a web service.

Read and understand the coding examples found in the directories "doc/coding" and "clients/Demos".

Notes:

(**) command key
The command key is labeled different on some keyboards; try "ALT", "CMD", "META" or similar.

Notice that some window managers catch some command-key combinations themselfes - NOT passing those key events to ST/X (this is especially true for motif's mwm and fvwm, and for MacOSX, where some CTRL-key combinations might be used for desktop operations) .

If this is the case with (some of) your keys, you may either disable the window manager's key functions (in the wm's resource file) or change the settings (in your "private.rc") to use different control- or command key combinations instead.

Most of the window manager's key functions are hardly ever used if you have a mouse hooked to your system - so it may be preferrable to disable those, instead of redefining ST/X's key mapping.

Copyright © Claus Gittinger Development & Consulting
Copyright © eXept Software AG