Smalltalk

coll := Dictionary new.
slot := key.
22480

coll := LookupTable new.
slot := key.
18548 18877

## Comparison with Integers in the 1-1000 Range As Keys

Smalltalk

coll := Dictionary new.
slot := (key * n) truncated + 1.
59 59 60 65

coll := LookupTable new.
slot := (key * n) truncated + 1.
51 49 53

## Comparison with Integers in the 1-7654000 Range As Keys

Smalltalk

coll := Dictionary new.
slot := (key * n) truncated * 7654 + 1.
64 61 60

coll := LookupTable new.
slot := (key * n) truncated * 7654 + 1.
51 51

## Concatenation and Streams

Tip

Strings can be formed from smaller strings by using the concatenation message (comma) or streams. Here is a comparison of the two:
Smalltalk

lumpSomeStrings:为空OfString

| bigLump |
bigLump := String new.
arrayOfStrings
  do: [ :aString |
        bigLump := bigLump, aString ].
^ bigLump

This is simple and straightforward, but note that each assignment to bigLump involves copying the previous contents of bigLump to a new place and copying aString behind it. When bigLump becomes long, there is a lot of copying going on.

An alternative and better solution when strings become large uses streams
and works like this:

Smalltalk

lumpSomeStrings:为空OfString
| aStream |
aStream := WriteStream on: String new.
arrayOfStrings
do: [ :aString |
       stream nextPutAll: aString ].
^ stream contents

Basically, a stream continues to add on new stuff behind previous stuff in a
large working collection (called the stream contents). If the working
collection fills up, the stream allocates a bigger collection and copies the
data to it.

It is possible to prevent all copying by specifying the size of the collection:
Smalltalk

lumpSomeStrings: arrayOfStrings
| aStream length |
|: inject: 0
| into: [ :len :str | len + str len ].
| aStream := WriteStream on: (String new: length). "← changed"
| arrayOfStrings
| do: [ :aString |
| stream nextPutAll: aString ].
| ^ stream contents

(The *inject:into*: method is not often used, but it should be! Here it is used to sum the lengths of all of the strings in *arrayOfStrings* and in one simple expression!)

All of these examples answer the same string (at least, according to #=).

Comparing Floating-Point Values

Tip

This expression answers *false*, but it looks like it should answer *true*:

Smalltalk

(45.0 * 1.15 * 10.0) = (45.0 * 10.0 * 1.15)

So, is it a problem? No. Why?

I used a *printHex* method to look at *raw* floating point values:

<table><thead><tr><td>Expression</td><td>Result</td><td>Notes</td></tr></thead><tbody><tr><td>1.5d0 printHex</td><td>'1.8000000000000e0'</td><td>Test case that converts evenly</td></tr></tbody></table>

The value is in hex; the exponent is hex and is the number of bits to shift the value. For the other values, it shows:

<table><thead><tr><td>Expression</td><td>Result</td><td>Notes</td></tr></thead><tbody><tr><td>1.15 printHex</td><td>'1.2666666666666e0'</td><td>Not exact conversion</td></tr><tr><td>45.0 printHex</td><td>'1.6800000000000e5'</td><td>Exact conversion</td></tr></tbody></table>
<table><thead><tr><td>Expression</td><td>Result</td><td>Notes</td></tr></thead><tbody><tr><td>10.0 printHex</td><td>'1.40000000000000e3'</td><td>Exact conversion</td></tr></tbody></table>

Note how 1.15 seems to run forever. It is not represented exactly in binary. Now, let's look at the results of the calculation:

Smalltalk

(45.0 * 1.15 * 10.0) printHex '1.2BFFFFFFFFFFFFe9'

(45.0 * 10.0 * 1.15) printHex '1.2C00000000000e9'

Note how the first expression answers a value just a tiny bit smaller; adding a one bit at the rightmost position makes the first equal to the second. It's just off the minimum value that a float can be and still be different.

Such are the hazards of comparing floats for equality. The top three rules in using floating point values are:

1. Do not compare floats for equality.

2. Do not use floats for monetary computations.

3. Do not compare floats for equality.

## Immutable Objects and Identity Objects

### Tip

There are two similar terms that are often confused: *Identity* and *Immutable*. Here is a definition of both:

* **Identity object**

An object where each object with the same value is the same object. Identity objects include characters, small integers, true, false, nil, and symbols.

The reason why each of these objects is an identity object differs, but the result is the same. If a and b refer to identity objects, and a=b is true, then a==b is always true as well. Thus, $(2+2)=(1+3)$ is always true.

* **Immutable object**

An object whose contents are never modified. Instead of modifying the contents, a new object is answered.
Two objects with the same value are different objects: 2.0 + 2.0 produces a 4.0 that is different from the 4.0 produced by 1.0+3.0; both have the same value but are not the same object.

Immutable objects include large integers, floats, and anything else you happen to code to be immutable. If a and b refer to immutable objects, and a=b is true, then a==b may or may not be true as well.

Identity objects and immutable objects are not opposite terms. In fact, all identity objects are immutable objects. Here is some related information:

* Mutable objects

Mutable objects have internal states that can be changed. Most objects are mutable, including most of the objects people typically write.

Points, for example, are mutable. One can write `(p x: p x + 1)` to increment the `x` value. The result is stored in the same instance of point. No new point is answered. All variables that pointed to the point still point to it with its new value.

* Small integers

Small integers are immutable because they are encoded directly in the object pointer. This is an optimization and not something esoteric in the basics of OOP or Smalltalk. It is a hack, but one that provides a huge gain in performance.

Ideally such optimizations should go unnoticed, and this one almost does. It requires some bit of odd code to tell when an integer is a small integer, or where the boundary is with large integers. (See *IBM Smalltalk: The Language* for some code.)

The encoding in current Smalltalk systems usually takes 2-3 bits of a 32-bit address for flags. With two bits, 30 bits are left for encoding an integer. However, this internal representation is never accessible to Smalltalk code. Users, even those who dig into the innards, see just integers; the class may differ depending on the size, but the direct encoding into an object pointer is never seen. This is also true with characters, which are often encoded in the object pointer as well.

* Adding

Now, when it is time to add, say 1, to a small integer, the encoded value is converted into a regular hardware integer value, 1 is added, and the result is converted back into some kind of integer. The answer is always a new object.
Characters cannot be added to, but they do have a value that can be
converted to an integer. This integer can be incremented and converted
to a different character (if it is not too big).

In neither case is the immutable object changed internally; the result is
always a new value, and all variables that hold the original value still
hold it.
# Chapter 5. ENVY

In this chapter, we cover the ENVY programming environment.

## Working with the Team Environment

**Question** We expect to have to put in quite a number of hours on our VisualAge for Smalltalk project on a tight schedule. We are running in the Team environment at the office. We would also like to do some development at home. We have access to our Team server library drive remotely via LAN Distance and Netware. Rather than have to go through all that is required to export the application or its parts, we'd like to simply have a client environment at home as well as at work. The license agreement seems to allow this so, from a technical point of view, how should we set up the environment? Are there any issues with respect to synchronizing the home client image with that at the office? Do we need to make our image consistent or recache the pointers?

**Answer** Principally speaking, I do not see how your home setup differs from your office setup. Basically you share the same library across your remote LAN extension. Since nothing is really locked in the library, there should be no problem loading your editions at home.

The only risk I can think of is working on the same edition of a class in two or more images, since every method save implies a release of the current method edition into the class. Therefore, you might run into problems when trying to version or release the class, since you may not have all the currently released methods in your image. But even then a "reload current" on the class will do the trick.

You also may want to consider taking your image with you so that you are working with the same open editions. The alternative is to version your code before leaving home (or leaving the office), and then just load it from the library when you arrive.

Actually, there is really no need to cart the image back and forth. Here is a simple process that you can follow to do nontrivial development at both the office and at home. This process requires no new software or hardware. It typically takes me 15 minutes or less to do the versioning and exporting and zipping required to prepare my work for travel:
1. Bootstrap your home system with a starter manager and a matching image. You can create the manager by exporting the latest version of each configuration map or application loaded in your image.

2. Going from home to work: Version off the day's changes (up to the application or map level) and export them to a new library. Zip it and put it on diskette. Import the code into the office manager when you get to work. Load your changes into the image and start working.

3. Going from work to home: version off the day's changes (up to the application or map level) and export them to a new library. Zip it and put it on diskette. Import the code into your home manager when you get back home. Load your changes into the image and start working.

Don't worry about having Version 999 or whatever. The only thing that matters is the name that you use to version the code when you ship. If this is a psychological barrier, then start your version numbers at 0.1 and let them grow to 0.nnn. When you are ready to ship, version it as 1.0.
Versioning often is a good habit. It makes for excellent checkpoints.
Versioning is a tool. It is your friend. Use it.

## Shared Library Password Protection

**Question** How do I protect certain components of my library against unauthorized access? For example, in a university environment, rather than sharing code, students need to hide their work from other students.

**Answer** The VisualAge for Smalltalk Professional Server is meant for sharing information, but it does have password control. You should be able to define a password for each student to limit their access to only their work in a common repository. Then define an application for each student where they and their professor are the only group members. This is covered in the *VisualAge for Smalltalk User's Guide*.

## Libraries

**Tip** The Professional version of VisualAge for Smalltalk permits the creation of libraries. These libraries are useful for moving applications from one installation to another. They can also be used for making backups or for providing a reusable library to share between development installations.
## Import and Export

**Question**

How do I import and export applications from a library file?

**Answer**

In the VisualAge for Smalltalk Organizer, open the menu titled Applications. Select submenu **Import/Export**. Select menu item **Import Applications...** In the resulting file dialog, locate the library file (with .dat extension) and click **OK**.

<figure><img src="image_16.png" /></figure>

The contents of the library file will be presented. Select the application and version that you want to import and click the >> button (this includes the selected application and version in the list of things to import). Click **OK**. The version(s) of the application(s) you selected will be imported into your current library, but they will not be loaded into your image.

## Loading Applications

**Question**

How do I load applications from the library?

**Answer**

In the VisualAge for Smalltalk organizer, open the menu titled **Applications**. Select submenu **Load**. Select menu item **Available Applications...**

A list of applications that have not been loaded in the image will be presented. Select the application and version that you want to load and click the >> button (this includes the selected application and version in the list of things to load). Click **OK**. The versions of the applications you selected will be loaded into your image. Save the image.
## Moving Components Between Libraries

**Tip**

You can move components between two libraries directly without exporting or importing them. For example, to move your applications from a Version 3.0 Manager to a Version 3.0a Manager without exporting or importing, do the following:

From within your Version 3.0a image that is connected to the Version 3.0a manager, choose **Import**, and specify the Version 3.0 (old) manager as the file to import from. It will then bring up the list of all applications in the manager. You can choose all that you need to import over.

Remember: Your Manager is essentially a normal .DAT file.

## Archival Code

**Question**

I'm using VisualAge for Smalltalk Professional. I use only import/export, and not filein/fileout. Do I still need to generate archival code?

**Answer**

No, you don't need the archival code. The primary purpose of archival code is for sharing code between standalone images. With the Professional product, import/export is much preferred. So, with VisualAge for Smalltalk Professional, there may be only two cases when you might want archival code:

* If you want to move code to a "Standard" image

* If you are creating several copies of a part and want to modify the filed-out version of it to file it in.

## Identifying the Released Version

**Question**

How do I see which version is released? I know how to determine which version of a class is currently loaded in my image, but how do I determine which version is the released one without having to load Released and then examine which one responds?

**Answer**

There are many ways to find out which class version is the released version in an application. One way is to browse the application editions. From the Application Manager, select the application you want, then browse the application editions. Select the edition you want to see; the class versions listed are the released versions.
## Change Management for Flat Files

**Question**

I am using VisualAge for Smalltalk Professional for change management of my Smalltalk code. However, I also have some flat files that are used as part of the product as well (metadata and the like). Does VisualAge for Smalltalk Professional have any capability to manage these too, or am I forced to use a different approach for my non-Smalltalk product files?

**Answer**

If your team is comfortable with the VisualAge for Smalltalk Professional version control system, there's nothing stop you from saving the contents of those files as Smalltalk comments in some method. VisualAge for Smalltalk Professional manages applications, classes, and methods by storing them in its library file. It also expects the methods to compile under Smalltalk but comments don't have to compile.

You can easily extract the text of methods and write them out to files again in Smalltalk. Besides, other revision-control systems are doing just that in their own way.

A much more sophisticated approach is to look into the support provided by the LibraryObjects application. This allows you to associate any object that can be persisted by the ObjectDumper with a given class in an application. All that you need to add to this is some trivial CommonFileSystem code to read your files into a byte array (for storing) and some code to write the byte array back out to a named file (for restoring).

This gives you the version control that you are looking for. It has the added benefit that your files can be binary or text. (You can't store binary files in the comment fields unless you use something like uuencode to turn them into a stream of hexadecimal characters.)

## Date Stamp for Versioned Classes

**Question**

An editioned class or application has a date-created stamp. What about after you've versioned the class or application? How can I see from the browser or manager what the date of the versioning is?

**Answer**

Versions are really just editions, but in a versioned state. Therefore, even though you are looking at a versioned edition, you can still find out its timestamp, but it is the timestamp when the *edition* was created.

If you want the version name to include the timestamp as part of its signature, do the following: From the Transcript menu, select **Smalltalk tools**
→ **Open Preferences Workspace**. Scroll down a bit to find the following line within the Configuration Management section:

**Smalltalk**

EmTimestamp showVersionTimeStamps: false

Change *false* to *true*, swipe the line, and execute.

**Note**

This still shows only the timestamp of the edition, that is, when the edition was created, not when it was versioned.

## Applications and Subapplications

**Question**

I am not quite sure when to use applications and when to use subapplications. Would someone please explain the differences and the criteria generally used for determining when a set of classes are considering a subapplication?

**Answer**

Subapplications are used for functional grouping, or for class extensions that need platform-specific functions or supports. By default, when you load an application, all its subapplications will also be loaded.

Especially for platform specific support, an application will have some configurable expressions to specify which of its subapplications should not be loaded on a certain platform.

## Connecting to a Cloned Library

**Question**

Can I connect an old image to a cloned library?

**Answer**

Yes, you can, but recache your pointers!

**Never** connect an old image to a cloned library without having recached your pointers first! Otherwise your cloned repository could get corrupted.
Reloading an Application

Question

How do I, in code, reload the currently loaded edition of an application?

Answer

Try this:

Smalltalk

EmClassDevelopment imageBuilder loadApplications:
(OrderedCollection new add: <App Name>; yourself)

Loading Previous Editions of Application

Question

Is there a fast way to load all recent class editions of the entire application?
Each time, when I get a native image from the server and don't create a
new version of the application in advance, I have to load the last edition of
all classes manually. Is there a faster way of doing this?

Answer

One way you can manage your code so that the transition to a new image is less painful is to create a configuration map pointing to the application editions you are interested in. If you do this, you can load in all your applications with one operation.

Deleting an Application

Question

Can I, if I have installed VisualAge for Smalltalk Professional, delete an
application by simply selecting delete from the applications menu on the
organizer?

Answer

Deleting really just deletes an application from a configuration map, it does not delete the application from the library. If your application is not yet associated with any configuration map, the best you can do is unload it from your image and try to forget it exists.

Creating a new application does affect the library manager. Unfortunately, there is no way to remove your application from the library except to purge your application and clone the library.

Another way would be to start with a new manager, and import the
applications that you want from the old into the new.
**Question**

How do I delete an application when there is no configuration map?

**Answer**

Unload the application. (Check the "How Do I..." help from Transcript). Deleting really just deletes an application from a configuration map, it does not delete the application from the manager. In your case, your application is not yet associated with any configuration map and the best you can do is unload it from your image and try to forget it exists.

## Creating a New Application

**Question**

Does creating a new application immediately write to the library manager?

**Answer**

Yes. You can see this by creating an application and looking at the list of applications in an Applications Editions browser. The name of your new application appears in the list. Creating a new application does affect the library. Unfortunately, there is no way to remove your application except to purge it and clone the manager. Or, as we do, start with a new manager and import the applications that you want from the old into the new.

## Removing an Application

**Question**

How can I remove an application from the loadable applications list?

**Answer**

You, or your library supervisor, can purge the application if it is versioned using an Application Editions browser. (See the *IBM Smalltalk User's Guide*.) Make sure that you unload the application version before purging it.

## Deleting Old Versions of Classes

**Question**

Is there a way to delete old versions of classes from user-defined applications?

**Answer**

No, a version is immutable. Once you version the application, you have to open a new edition to make changes. When we are restructuring applications, we open an edition, move or delete the affected classes, then version the application as obsolete or "do not use." If the intention is to reduce the manager's size by deleting the classes, be aware that deleting doesn't shrink the manager, only cloning does.
## Getting Rid of Damaged Classes

**Question** How do I get rid of damaged classes when my image refuses to let me delete the class?

**Answer** Version and release your classes, applications, and configuration maps. Get a fresh image and reload your stuff.

**Question** How do I use the exporting option to get rid of unwanted versions of my library instead of using cloning?

**Answer** Get a new copy of the ABTMGR30.DAT file from the CD and start with that. In addition to an online copy of the original manager, we keep a base manager that has all of the original application versions plus any PTFs and third-party applications. Since we keep this base manager up to date, it becomes very easy for us to purge by exporting just our applications to a copy of the base.

## Prompting for Ownership

**Question** How do I get an image to prompt the user for "Who does this image belong to?"

**Answer** Try this:

Smalltalk

EmUser resetImageOwner "sets the image owner to nil"

Then save the image and exit VisualAge for Smalltalk. When VisualAge for Smalltalk starts, you get the "who does this image belong to" prompt.

## Moving Development Code

**Question** How do I move development code between libraries?
**Answer**

The best way is by creating a new library, then exporting a configuration map or applications to the library. Exporting requires the parts to be versioned because editions cannot be exported.

## Distributing an Application for OS/2 and AIX

**Question**

How do I distribute an application for both OS/2 and AIX clients?

**Answer**

You must package on the target environment. We access a single manager on an AIX machine for all environments using TCP/IP and the EMSRV support; thus no import/export is necessary, just a load and package.

## Exporting an Application to a Non-LAN PC

**Question**

How do I export an application to another PC not attached to a LAN?

**Answer**

You can create an export file that contains the application that you want to copy to the other VisualAge for Smalltalk workstation.

Keep in mind the following:

* The component being exported must be a version.

* The component version you want to export cannot already exist in the target library. If it does already exist in that library, the system exports only those components not already there.

Here's what you do. From your source image:

* Open an Application Manager browser from the transcript (**Smalltalk Tools → Manage Applications**).

* From the list of applications, select the application version you want to export.

* From the **Application** menu option, select **System → Export To**.

* In the displayed prompter, specify the path and file name for the target library.

* Click on **OK**. The system moves a copy of the application version from the library you are currently using to the target library.

If you cannot fit this file on one diskette, try using saveram or some other tool that can split and pack files.

From the image on the VisualAge for Smalltalk workstation where you wish to import the application:
* Open the Application Manager Browser

* From the **Application** menu option, select **Select → Import → Applications**.

* In the displayed prompter, specify a path and file name for the library storing the component.

* Click on **OK**. A window is displayed, prompting you for the name and version of the application you want to import.

* Select an application; then select a version of the application.

* Click on **OK**. A copy of the application version is moved from the selected library into the library you are currently using.

## Associating .DAT files with Features

**Question**

How can I figure out which feature was installed or loaded from which .DAT file. Does there exist a cross-reference list so I can identify the .DAT file with a given feature?

**Answer**

To figure out which .DAT is which, you can look at the .CTL files, which are found in the feature subdirectory. The first word in the file tells you the name of the feature as you see it in the Load Features list. The rest of that first line is just information that tells VisualAge for Smalltalk under what conditions to load the feature. The important information is the rest of the file. It lists the configuration map versions that are loaded for the feature and the .DAT file they are loaded from. You can use this list to determine whether you have used a .DAT file or not.

## Manager Consistency

**Question**

How can I check my library manager for consistency so that I don't end up with a badly corrupted repository where data is lost?

**Answer**

You can use the EmLibraryStatistics to check your manager for consistency. To use EmLibraryStatistics, read the comments in the class method `checkConsistencyOf`.
## Exporting a Pool Dictionary

**Question** Suppose I define a new pool dictionary for my application. How can I make sure that this pool dictionary is loaded when I export the application to another image?

**Answer** There are a few methods that you will need to implement to ensure that your pool dictionaries are defined in the image prior to loading your application. They are `toBeLoadedCode:`, `wasRemovedCode:` and `installToBeLoadedCode`. Details can be found in the IBM Smalltalk User's Guide.

## Exporting Configuration Maps

**Question** I'd like to export a whole bunch of configuration maps (specific versions of specific configuration maps) to an empty .DAT library. I'd like to do this without the user interface so that I can run this unattended overnight. Do you have a script that can do this?

**Answer** You can do this without a script. Select export from the pop-up menu in the configuration maps pane (not the versions, but names) of the configuration maps browser. Then select the target library, and you'll be prompted for all map or version pairs up front.

## Manager Growth Rate

**Question** What is the approximate rate of the Manager file growth on the server? I heard about 1 MB per day per developer. Is it true?

**Answer** It comes down to how much code your developers can crank out or change per day. If they migrate some existing application into a brand new VisualAge for Smalltalk library, chances are the library will grow with however much code is being migrated into the manager.

If your developers write Smalltalk code from scratch (keyboard input) chances are that they won't be able to type anywhere near 1 million key strokes of desirable Smalltalk code per day. One can try for half that on a DBCS input. Modifying an existing method may store incremental changes only (I don't deal with that algorithm.) If you make changes via the VisualAge for Smalltalk Composition Editor, the run-time code is stored as various methods, so there won't be much difference in the way method
source code is stored. This may allow for method changes at a faster rate than manual input.

A 1 GB drive should give you very comfortable room for development. Even though you may not need that much, a 1 GB drive should be cheap enough today to buy that luxury, where a 300 MB or 500 MB drive would risk the later discovery that you'll have to spend time to move the manager to a larger drive.

Anyway, make sure that your team has a good reliable means to back up the shared manager file. You don't really need to back up each developer image file, as the files can be rebuilt from the manager or library file. And make as frequent (daily, weekly) a backup schedule as you can afford.

## Class Changes versus Alternatives

**Question**

What is the difference between class changes and class alternatives?

**Answer**

I found the following information in an ENVY/Manager user manual. I hope the information is helpful.

* **File Out Changes**

File out methods in the primary class editions that are different from the corresponding methods in the alternative class editions.

* **File Out Alternatives**

File out methods in the alternative class editions that are different from the corresponding methods in the primary class editions.

"Primary" seems to indicate the editions that appear in the left pane of a changes browser. "Alternative" method editions appear in the right pane of the browser.

## Moving Windows Library to AIX

**Question**

We are developing in Windows now but are considering also doing some AIX development. My understanding is that this would require us to move our manager to AIX. Is the procedure for doing this documented somewhere? I took a quick look through the *VisualAge for Smalltalk Users Guide* where other library administration tasks are documented, but didn't see anything. I assume that there's more to it than just copying the manager file, but what?
**Answer**

You should reinstall the server code on AIX following the instructions in the READMEs, and so on, and then copy your library file from Windows over the library that was added during the server install on AIX. Also, all of your clients will need to update their abt.cnf to point to the new library location and to use EMSRV as the transport mechanism.

## Identical Users

**Question**

In our team development environment, we have two distinct users who have the same name. I suppose this happened from importing classes from another library, or maybe there is a space after the name. In any case, can anyone make a recommendation as to how best to get rid of one of these users? Right now, they are both owners of different classes and managers of applications.

**Answer**

Assign new owners (or managers) to the classes and applications created under the user that you don't want. To do this, use the **Become New Owner** and **Become New Manager** options of a **Group Members** menu.

Next you might want to check for any classes still owned by the user (Select **Queries** → **Classes Owned By** from the **Smalltalk Tools** menu). Finally, purge the user.

You should also understand how you got into this situation. There are two important parts to a user:

1. The external name. This is what you see in the browsers and this does not have to be unique.

2. The unique name. This is used by the system to differentiate users.

In your case, the users have unique underlying names, but their visible names happen to be the same. If you wish, you could simply change the visible name as described above.

The lesson to learn is that you should not define new users without making sure that the unique names are consistent. The easiest way to do this is to export and import the users explicitly or to allow the definitions to come over as a byproduct of code import or export.
## Classes Available in the Library

**Question**

Is there any way to develop a snooper that can be used to compare the loaded classes against what is available in the library? A function like that would provide the user with the capability of selectively picking up fixes on a periodic basis into an existing image. Is it feasible to develop such a utility that could be run on demand?

**Answer**

The Team version/release control features give you the functionality that you are looking for. The way you can work with it is to have configuration maps for the various major components of the product, and applications within those configuration maps. Whenever you open an application to make a change, you immediately release the application's edition to the configuration map (opening the configuration map as well if necessary).

Now, to get the latest and greatest, check out your configuration maps to see if any new application editions have been released, and if so, you can load them if you are interested. Once you have open application editions, you can see any newly released classes by examining the application in the Application Manager. If the released class does not match the one currently loaded in your image, it will have a > symbol next to it.

To further assist you, there is a **Query** menu option under **Smalltalk Tools** on the Transcript window. The choice for unreleased classes will print a list (to the Transcript) of every class in your image (by application) that is not the released version for that application. You can also use this in addition to Open Class Editions to help you locate all the changes you have made leading up to a build so you know what you need to version and release.

## ENVY/Windows95/Novell

**Question**

What about accessing ENVY/Manager library using Windows 95 clients and Netware servers?

**Answer**

IBM has recently certified ENVY/Manager library access using Windows 95 clients and Netware 3.12 and 4.1 servers.

Windows 95 clients must use only the Novell Client32 for Windows 95 requestor. IBM has tested library access using the Microsoft Client for Netware Networks and has found problems that may result in corrupt libraries if this requestor is used. The problem has been logged with Microsoft Australia Technical Support as Problem 1570370.
The Client32 for Windows 95 requestor must be used only in conjunction
with two patches available from Novell:

* c3295c.exe (Client32 for Windows 95 Update C)

* landr5.exe (server patch)

If these two patches are not used, users may experience severe
performance problems when reading from attached servers and may also
find that locks are not correctly released if more than one image is running
concurrently on the same machine. The two patches will correct both of
these problems.

The Client32 for Windows 95 requestor has many parameters that may be
changed in the Advanced Settings dialog. IBM has tested with default
settings provided on installation which in most cases trade data integrity for
performance (for example, True Commit set to off). Although other settings
have not been tested, changing any of the settings in the "Performance,
Cache" parameter group to less optimistic values should not present any
problems.

ENVY/Manager's release lock mode parameter should be set to *true* when
using this configuration.
# Chapter 6. Microsoft Windows

In this chapter, we cover VisualAge for Smalltalk on the Microsoft Windows platform.

## Sizing the Windows 95 Toolbar

**Tip** The Windows 95 toolbar sizes improperly at run time, potentially covering other visual parts. To work around this problem, adjust the *framingSpec* of the toolbar so that its bottom edge is attached to another widget. This will prevent the toolbar from covering other widgets. A fix for this problem is available in the downloadable update.

## Windows 95 TreeView

**Tip** The Windows 95 TreeView traps the collapse and expand events but does not properly signal the corresponding VisualAge events. Therefore, connecting to the *itemExpanded* or *item Collapsed* event of the TreeView does not work. The AbtCwTreeView methods below correct the problem.

**Smalltalk**

collapseNode: aWidget clientData: clientData callData: callData
"Private - The node collapse callback was called."

self signalEvent: #item Collapsed with:
(self partForNode: callData value)

**Smalltalk**

expandNode: aWidget clientData: clientData callData: callData
"Private - The node expand callback was called."

self signalEvent: #item Expanded with:
(self partForNode: callData value)

As an alternative, you can register Smalltalk callbacks in your parts to
handle the *itemExpanded* and *item Collapsed* events. Use code like that
shown below:
Smalltalk

widget
  addCallback: #expandCallback
  receiver: self
  selector: #expandNode:clientData:callData:
  clientData: nil.

widget
  addCallback: #collapseCallback
  receiver: self
  selector: #collapseNode:clientData:callData:
  clientData: nil.

You would then need to implement the `expandNode:clientData:callData:` and `collapseNode:clientData:callData:` selectors in your parts to handle the registered events. See the *IBM Smalltalk Programmer's Reference* for more information about callbacks.

## Deactivation of OLE Embedded WordPro Document

Tip

An unhandled exception occurs when deactivating an embedded, in-place activated OLE client container that contains a Lotus WordPro document. To work around this problem, when using WordPro documents, specify an *activationPolicy* of `XmOPEN` in the OLE Client part to disable in-place activation.

## Copying from Windows Explorer into an OLE Client Part

Tip

Use copy and paste to share OLE objects between the Windows Explorer and an OLE Client part. Dropping an OLE object that was dragged from the Windows Explorer onto an OLE Client part does not work.

## Generating OLE Methods

Tip

The OLE Class Generator generates set methods that signal the wrong event name. For example, the generated name of the change symbol for the attribute *count* is `#countChanged`. However, the generated *count*: setter method contains the following code:
Smalltalk

self signalEvent: #count with: aValue

The *signalEvent* code will have no effect because the change symbol for the
does not match the signaled event name. To fix this, change the
OlexPropertyDescription->>#abtSetSelectorWithInterace: method. Change
the code lines:

Smalltalk

nextPutAll: 'self signalEvent: ' ;
nextPutAll: selectorName asSymbol printString ;

to:

Smalltalk

nextPutAll: 'self signalEvent: ' ;
nextPutAll: ( selectorName , 'Changed' ) asSymbol printString;

Free Disk Space on Windows Platform

Question

Does anybody know how to retrieve free disk space information on Windows
platforms?

Answer

The GetDiskFreeSpace function call returns the following information:

1. Number of sectors per cluster

2. Number of bytes per sector

3. Number of free clusters on the disk

4. Total number of clusters on the disk

Pointers to variables where the above information can be returned must be
passed to the GetDiskFreeSpace function. To get the total amount of free
disk space, you must multiply the sectors per cluster by the bytes per sector
by the number of free clusters.

Listed below is code that will call the GetDiskFreeSpace function, calculate
the amount of free space on C:, and display that value in a message
prompter.
| oscall freeSpace sectorsPerCluster bytesPerSector
freeClusters totalClusters rc |

oscall := OSCall new.
sectorsPerCluster := ByteArray new: 4.
bytesPerSector := ByteArray new: 4.
freeClusters := ByteArray new: 4.
totalClusters := ByteArray new: 4.

rc := oscall getDiskFreeSpace: 'C:'
IpSectorsPerCluster: sectorsPerCluster
IpBytesPerSector: bytesPerSector
IpFreeClusters: freeClusters
IpClusters: totalClusters.

freeSpace := (sectorsPerCluster abtAsInteger) *
igrating (bytesPerSector abtAsInteger) *
freeClusters abtAsInteger).

CwMessagePrompter message: 'Free space on disk C: is ',
freeSpace printString.
# Chapter 7. National Language Support

In this chapter, we cover questions related to national language support of VisualAge for Smalltalk.

## Code Page Support

**Question**

Does VisualAge for Smalltalk support my particular code page?

**Answer**

VisualAge for Smalltalk makes an operating system call to translate the string. If the operating system call doesn't support the conversion between the code pages, then it will try to translate with the translate tables you provide. The operating system calls are different for each platform. To see if the call is supported on your machine, take any string and pass the message `convertToCodePage`:

Smalltalk

'Hello World' convertToCodePage: 37

where the number passed is the code page you wish to convert to.

If the code page is not supported, the method `convertToCodePage:` will return an AbtError with errorText set to 'Conversion from codepage <...> to codepage <...>' is not supported'.

## Code Page and MPR Problems

**Tip**

The code page is stored in the MPR file so it can be correctly translated to the new code page. For example, on my machine on Windows, character 252 = ü (U umlaut). On OS/2, that same character is 129. However, I don't have to modify the MPR file I generated on Windows because code points are automatically translated for text stored in MPR files. The ABTRULES.NLS file contains the mappings, and AbtCharacterTranslator handles the translations. All you have to do is this:

1. Generate your external strings with: `YourApp abtGenerateExternalStringsIfNecessary`.

2. Add `abtExternalizedStringBuildingInfo` method to your application.

3. Add `loaded` method that calls `self abtRegisterExternalStrings`.
4. Add `unloaded` method that calls `self abtUnregisterExternalStrings`.

## Required CAT Files

<figure><img src="image_17.png" /></figure>

The following script helps you to determine, based on your packager output log, which `*.CAT` files you need with your run-time image. Just save the output log to a file and then run this script:

```
Smalltalk
| stream tokens file |
file := (CwFileSelectionPrompter new)
title: 'Packaging Messages'; prompt.
```

```
(file isNil) ifTrue: [^nil].
stream := CfsReadirstream open: file.
[stream atEnd] whileFalse: [
tokens := stream nextLine subStrings.
((tokens size > 0) and: [((tokens at: 1)
  indexOfSubCollection: 'NlsCat' startingAt: 1) > 0]) ifTrue: [
  Transcript cr; show: 'References messages in: ',
  ((Smalltalk at: (tokens at: 1) asGlobalKey) at: '!!CATALOGNAME')]]
stream close.
```

## Decimal Point Representations

<figure><img src="image_18.png" /></figure>

Is it possible to change the default decimal point for the current local representation which probably is a comma?

<figure><img src="image_19.png" /></figure>

The following code results in 0,75 if the local representation of a decimal uses a comma:

```
Smalltalk
Locale current lcNumeric printNumber: (3/4) asFloat on: Transcript
```

The next code will result in 0.75, and the reason is that the compiler needs to be able to recognize a float from a method named `","`.
(3/4) asFloat printOn: Transcript

When you use *printString* on a Float, you are getting a representation that can be highlighted and evaluated (compiled). For occasions where you need locale-specific output, you instead use the *printNumber:on:* method.

## Using Multiple National Languages

**Question**

How do I use multiple national languages with VisualAge for Smalltalk?

**Answer**

See the *VisualAge for Smalltalk User's Guide*, for a complete discussion of how national language support (NLS) enablement works.

## Adding French Characters to English

**Question**

How do I allow input of French characters in my English application?

**Answer**

I've been running Windows 95 lately, and for typing French characters I use the "U.S. International" keyboard layout. That maps certain deadkeys, such as ' (apostrophe) followed by e gives è (e accent grave). I'm not certain OS/2 has this same keyboard layout scheme, if not you could implement it yourself fairly easily using the text field modify verify callback. ' (single quote) followed by a character (e) adds accent grave, back quote followed by a character (a, e, u) adds accent aigu, Shift+6 (caret) followed by a character (a, e, o, u) adds accent circonflexe," double-quote followed by a character (e, i) adds accent umlaut, Accent character followed by space adds character (such as ' + space = '), followed by c adds cedilla. The only drawback I've found to this scheme is that if you need to type lots of quoted text, it is irritating because you have to remember to type an extra space. Of course, the other option is to switch your keyboard to the French layout. For U.S. users it will change most notably the location of the A, Q, M, period, comma, numbers, and so on. The other scheme I've seen, called *Transparent Language*, is to map the up/down arrow to cycle through accented characters. This is a good approach if characters are rarely entered (Macintosh uses a similar scheme, but uses the control key).
## Problems with National Language Support in Version 3

**Question**

I have a problem with national language support in Version 3. Why?

**Answer**

This could be a problem with the `nlspath` search. (I believe that the dynamic example does not rely on the search; it expects you to tell it the exact file.) Are there any old (nontranslated) MPRs earlier in the NLS search path. The search starts at the working directory and then works its way down the entries in `nlspath`. You can see which MPR each `nlsgroup` is bound to by executing this code fragment:

```
Smalltalk
AbtMRIManager requestsAndResolutions do: [ :aRequest |
Transcript cr; nextPutAll: aRequest request printString.
aRequest isResolved
ifTrue: [
Transcript tab;tab; nextPutAll: aRequest
resolution fileSpec full Name ]
ifFalse: [ Transcript tab;tab; nextPutAll: 'not resolved.' ] ]
```

## Code Page Conversion between OS/2 and Windows

**Question**

How can I develop an application with VisualAge for Smalltalk for OS/2, and then reuse it from VisualAge for Smalltalk for Windows, where the code page in OS/2 is 850 and in Windows it's 437?

**Answer**

Windows uses code page 819 (ISO 8859-1) regardless of what the code page is set to in DOS. The code page for DOS may be 437, but Windows ignores it. Code page 819 doesn't exist in OS/2.

Although OS/2 doesn't support code page 819, code pages 819 and 850 have consistent mappings for points 32-126. After that, it is hit or miss as to whether or not they match.

In Version 3 of VisualAge for Smalltalk, we automatically map the characters in label strings, messages, and the like to the correct code points for you. In Version 2.0, however, you have to do the mappings yourself. The easiest way to do this is to select the separate application strings option for the application you want to run in both OS/2 and Windows. Next, export the strings to a file. Edit this file (under Windows) and change all the characters
that aren't mapped correctly. After editing the file, import the strings (again under Windows). When you run the application under Windows, the new strings will be displayed.

The problem does not exist if you are using DB2/2 version 2.1. They take care of the code page translation for you.

Double-Byte Character Set

Tip

When installing on a Windows DBCS machine, please use the default specified on the Select Folder dialog. Because the English version of InstallShield does not support DBCS strings, translated strings appear incorrectly in the list of existing folder names.

Tip

In the Simplified Chinese environment on AIX, several of the dialogs may have strings truncated (vertically and horizontally) because of the system font used by VisualAge for Smalltalk. By installing a different set of font aliases for Simplified Chinese or changing the named fonts for several VisualAge for Smalltalk dialog controls (button labels, headings and subheadings, icon text, and text), the truncated strings will appear correctly. To change the VisualAge named fonts (used for settings pages and icon text), please refer to the "VISUALAGE NAMED FONTS" section of the Preferences Workspace. The Preferences Workspace can be displayed by selecting **Options → Preferences Workspace** from the VisualAge for Smalltalk Organizer dialog.
## Appendix A. Special Notices

This publication is intended to help VisualAge for Smalltalk developers avoid common programming pitfalls and as a guide for frequently asked questions about the IBM Smalltalk language, VisualAge for Smalltalk, and its features. The information in this publication is not intended as the specification of any programming interfaces that are provided by VisualAge for Smalltalk. See the PUBLICATIONS section of the IBM Programming Announcement for VisualAge for Smalltalk for more information about what publications are considered to be product documentation.

References in this publication to IBM products, programs or services do not imply that IBM intends to make these available in all countries in which IBM operates. Any reference to an IBM product, program, or service is not intended to state or imply that only IBM's product, program, or service may be used. Any functionally equivalent program that does not infringe any of IBM's intellectual property rights may be used instead of the IBM product, program or service.

Information in this book was developed in conjunction with use of the equipment specified, and is limited in application to those specific hardware and software products and levels.

IBM may have patents or pending patent applications covering subject matter in this document. The furnishing of this document does not give you any license to these patents. You can send license inquiries, in writing, to the IBM Director of Licensing, IBM Corporation, 500 Columbus Avenue, Thornwood, NY 10594 USA.

Licensees of this program who wish to have information about it for the purpose of enabling: (i) the exchange of information between independently created programs and other programs (including this one) and (ii) the mutual use of the information which has been exchanged, should contact IBM Corporation, Dept. 600A, Mail Drop 1329, Somers, NY 10589 USA.

Such information may be available, subject to appropriate terms and conditions, including in some cases, payment of a fee.

The information contained in this document has not been submitted to any formal IBM test and is distributed AS IS. The information about non-IBM ("vendor") products in this manual has been supplied by the vendor and IBM assumes no responsibility for its accuracy or completeness. The use of this information or the implementation of any of these techniques is a customer responsibility and depends on the customer's ability to evaluate and
integrate them into the customer's operational environment. While each item may have been reviewed by IBM for accuracy in a specific situation, there is no guarantee that the same or similar results will be obtained elsewhere. Customers attempting to adapt these techniques to their own environments do so at their own risk.

The following terms are trademarks of the International Business Machines Corporation in the United States and/or other countries:

<table><tr><td>AIX</td><td>AIX/6000</td></tr><tr><td>Application System/400</td><td>APPN</td></tr><tr><td>AS/400</td><td>CICS</td></tr><tr><td>Common User Access</td><td>CUA</td></tr><tr><td>DATABASE 2</td><td>DB2</td></tr><tr><td>DB2/2</td><td>DB2/400</td></tr><tr><td>DB2/6000</td><td>IBM</td></tr><tr><td>IMS</td><td>MQ</td></tr><tr><td>MQSeries</td><td>MVS</td></tr><tr><td>MVS/ESA</td><td>Object Connection</td></tr><tr><td>OS/2</td><td>OS/400</td></tr><tr><td>Presentation Manager</td><td>PS/2</td></tr><tr><td>RPG/400</td><td>SOM</td></tr><tr><td>SQL/400</td><td>TalkLink</td></tr><tr><td>VisualAge</td><td>VisualGen</td></tr><tr><td>VisualInfo</td><td></td></tr></table>

The following terms are trademarks of other companies:

C-bus is a trademark of Corollary, Inc.

PC Direct is a trademark of Ziff Communications Company and is used by IBM Corporation under license.

UNIX is a registered trademark in the United States and other countries licensed exclusively through X/Open Company Limited.

Microsoft, Windows, and the Windows 95 logo are trademarks or registered trademarks of Microsoft Corporation.

<table><tr><td>HP, HP-UX</td><td>Hewlett-Packard Company</td></tr><tr><td>Sun, Solaris</td><td>Sun Microsystems, Inc.</td></tr><tr><td>Lotus, Notes</td><td>Lotus Development Corporation</td></tr></table>

Other trademarks are trademarks of their respective companies.
# Appendix B. Related Publications

The publications listed in this section are considered particularly suitable for a more detailed discussion of the topics covered in this redbook.

## International Technical Support Organization Publications

For information on ordering these ITSO publications see "How to Get ITSO Redbooks" on page 275.

* VisualAge: Concepts and Features, GG24-3946

* VisualAge and Transaction Processing in a Client/Server Environment, GG24-4487

* AS/400 Application Development with VisualAge for Smalltalk, SG24-2535

* World Wide Web Server Development with VisualAge for Smalltalk, SG24-4734

* VisualAge: Building GUIs for Existing Applications, GG24-4244

* VisualAge for Smalltalk Distributed, SG24-4521

* VisualAge for Smalltalk and SOMobiles, SG24-4390

* OO Programming with Client Access for OS/400 and ODBC using VisualAge for Smalltalk, SG24-4718

* Application Development with VisualAge for Smalltalk and MQSeries, SG24-2117

* Object-Oriented Application Development with VisualAge for C++ for OS/2, SG24-2593

* Programming with VisualAge for C++ for Windows, SG24-4782

* IBM VisualAge for Cobol for OS/2: Workframe User Guide, SG24-4604

* IBM VisualAge for Cobol for OS/2: Primer, SG24-4605

* IBM VisualAge for Cobol for OS/2: Object-Oriented Programming, SG24-4606

* Visual Modeling Technique, Object Technology using Visual Programming, SG24-4227
## Redbooks on CD-ROMs

Redbooks are also available on CD-ROMs. **Order a subscription** and receive updates 2-4 times a year at significant savings.

<table><thead><tr><td>CD-ROM Title</td><td>Subscription Number</td><td>Collection Kit Number</td></tr></thead><tbody><tr><td>System/390 Redbooks Collection</td><td>SBOF-7201</td><td>SK2T-2177</td></tr><tr><td>Networking and Systems Management Redbooks Collection</td><td>SBOF-7370</td><td>SK2T-6022</td></tr><tr><td>Transaction Processing and Data Management Redbook</td><td>SBOF-7240</td><td>SK2T-8038</td></tr><tr><td>AS/400 Redbooks Collection</td><td>SBOF-7270</td><td>SK2T-2849</td></tr><tr><td>RS/6000 Redbooks Collection (HTML, BkMgr)</td><td>SBOF-7230</td><td>SK2T-8040</td></tr><tr><td>RS/6000 Redbooks Collection (PostScript)</td><td>SBOF-7205</td><td>SK2T-8041</td></tr><tr><td>Application Development Redbooks Collection</td><td>SBOF-7290</td><td>SK2T-8037</td></tr><tr><td>Personal Systems Redbooks Collection</td><td>SBOF-7250</td><td>SK2T-8042</td></tr></tbody></table>

## Other Publications

<figure><img src="image_20.png" /></figure>

These publications are also relevant as further information sources:

* VisualAge for Smalltalk User's Guide, SC34-4518

* VisualAge for Smalltalk Programmer's Guide to Building Parts for Fun and Profit, SC34-4496

* IBM Smalltalk Programmer's Reference, SC34-4493

* IBM Smalltalk User's Guide, SC34-4536

* IBM Smalltalk: The Language, by David N. Smith, Benjamin/Cummings Publishing Company, ISBN: 0-8053-0908

* VisualAge and Transaction Processing in a Client/Server Environment, by Andreas Bitterer, Michel Brassard, William Nadal, and Chris Wong, Prentice Hall PTR, 1996, ISBN: 0-13-460874-7

* AS/400 Application Development with VisualAge for Smalltalk, by Andreas Bitterer, Masahiko Hamada, John Oosthuizen, Gino Porciello, and Håkon Rambek, Prentice Hall PTR, 1997, ISBN: 0-13-520453-4

* World Wide Web Programming: VisualAge for C++ and Smalltalk, by Andreas Bitterer and Marc Carrel-Billiard, Prentice Hall PTR, 1997, ISBN: 0-13-612466-6

* Object-Oriented Application Development with VisualAge for C++ for OS/2, by Marc Carrel-Billiard, Peter Jakab, Isabelle Mauny, and Rainer Vetter. Prentice Hall PTR, 1996, ISBN: 0-13-242447-9

* Programming with VisualAge for C++ for Windows, by Marc Carrel-Billiard, Michael Friess, and Isabelle Mauny, Prentice Hall PTR, 1997, ISBN: 0-13-618208-9
* VisualAge for Smalltalk Distributed, by Walter Fang, Sven Guyet, Randy Haven, Matti Vilmi, and Eduardo Eckmann, Prentice Hall PTR, 1996, ISBN: 0-13-570805-2

* VisualAge for Smalltalk SOMsupport, by Walter Fang, Raymond Chu, and Markus Weyerhäuser, Prentice Hall PTR, 1997, ISBN: 0-13-570813-3

* IBM Smalltalk Programming for Windows and OS/2, by Dan Shafer and Scott Herndon, Prima Publishing, 1995, ISBN: 1-55958-749-0

* Visual Modeling Technique, by Daniel Tkach, Walter Fang, and Andrew So, Addison-Wesley, 1996, ISBN: 0-8053-2574-3

* Smalltalk with Style, by Edward Klimas, Suzanne Skublics, and David Thomas, Prentice Hall PTR, 1996, ISBN: 0-13-165549-3

* Object Technology in Application Development, by Daniel Tkach and Richard Puttick, Benjamin/Cummings Publishing Company, ISBN: 0-8053-2572-7

* Designing Object-Oriented Software, by Rebecca Wirfs-Brock, Brian Wilkerson, and Lauren Wiener, Prentice Hall PTR, 1994, ISBN: 0-13-629825-7

* TCP/IP Tutorial and Technical Overview, by Eamon Murphy, Steve Hayes, and Matthias Enders, Prentice Hall PTR, 1995, ISBN: 0-13-460858-5

* Object-Oriented Interface Design: IBM Common User Access Guidelines, SC34-4399
## How to Get ITSO Redbooks

This section explains how both customers and IBM employees can find out about ITSO redbooks, CD-ROMs, workshops, and residencies. A form for ordering books and CD-ROMs is also provided.

This information was current at the time of publication, but is continually subject to change. The latest information may be found at URL http://www.redbooks.ibm.com.

## How IBM Employees Can Get ITSO Redbooks

Employees may request ITSO deliverables (redbooks, BookManager BOOKs, and CD-ROMs) and information about redbooks, workshops, and residencies in the following ways:

* **PUBORDER** — to order hardcopies in United States

* **GOPHER link to the Internet** - type GOPHER.WTSCPOK.ITSO.IBM.COM

* **Tools disks**

To get LIST3820s of redbooks, type one of the following commands:

TOOLS SENDTO EPHONE4 TOOLS2 REDPRINT GET SG24xxxx PACKAGE
TOOLS SENDTO CANVM2 TOOLS REDPRINT GET SG24xxxx PACKAGE (Canadian users only)

To get BookManager BOOKs of redbooks, type the following command:

TOOLCAT REDBOOKS

To get lists of redbooks, type one of the following commands:

TOOLS SENDTO USDIST MKTTOOLS MKTTOOLS GET ITSOCAT TXT
TOOLS SENDTO USDIST MKTTOOLS MKTTOOLS GET LISTSERV PACKAGE

To register for information on workshops, residencies, and redbooks, type the following command:

TOOLS SENDTO WTSCPOK TOOLS ZDISK GET ITSOREGI 1996

For a list of product area specialists in the ITSO: type the following command:

TOOLS SENDTO WTSCPOK TOOLS ZDISK GET ORGCARD PACKAGE

* **Redbooks Home Page on the World Wide Web**

http://w3.itso.ibm.com/redbooks

* **IBM Direct Publications Catalog on the World Wide Web**

http://www.elink.ibmlink.ibm.com/pbl/pbl

IBM employees may obtain LIST3820s of redbooks from this page.

* **REDBOOKS category on INEWS**

* **Online** — send orders to: USIB6FPL at IBMMAIL or DKIBMBSH at IBMMAIL

* **Internet Listserver**

With an Internet e-mail address, anyone can subscribe to an IBM Announcement Listserver. To initiate the service, send an e-mail note to announce@webster.ibmlink.ibm.com with the keyword subscribe in the body of the note (leave the subject line blank). A category form and detailed instructions will be sent to you.
## How Customers Can Get ITSO Redbooks

Customers may request ITSO deliverables (redbooks, BookManager BOOKs, and CD-ROMs) and information about redbooks, workshops, and residencies in the following ways:

* **Online Orders** — send orders to:

<table><thead><tr><th></th><th>IBMMAIL</th><th>Internet</th></tr></thead><tbody><tr><td>In United States:</td><td>usib6fpl at ibmmail</td><td>usib6fpl@ibmmail.com</td></tr><tr><td>In Canada:</td><td>caibmbkz at ibmmail</td><td>lmannix@vnet.ibm.com</td></tr><tr><td>Outside North America:</td><td>dkibmbsh at ibmmail</td><td>bookshop@dk.ibm.com</td></tr></tbody></table>

<table><thead><tr><th></th><th>Internet</th></tr></thead><tbody><tr><td></td><td>usib6fpl@ibmmail.com</td></tr><tr><td></td><td>lmannix@vnet.ibm.com</td></tr><tr><td></td><td>bookshop@dk.ibm.com</td></tr></tbody></table>

* **Telephone orders**

<table><tr><td>United States (toll free)</td><td>1-800-879-2755</td></tr><tr><td>Canada (toll free)</td><td>1-800-IBM-4YOU</td></tr></table>

<table><tr><td>Outside North America</td><td>(long distance charges apply)</td></tr><tr><td>(+45) 4810-1320 - Danish</td><td>(+45) 4810-1020 - German</td></tr><tr><td>(+45) 4810-1420 - Dutch</td><td>(+45) 4810-1620 - Italian</td></tr><tr><td>(+45) 4810-1540 - English</td><td>(+45) 4810-1270 - Norwegian</td></tr><tr><td>(+45) 4810-1670 - Finnish</td><td>(+45) 4810-1120 - Spanish</td></tr><tr><td>(+45) 4810-1220 - French</td><td>(+45) 4810-1170 - Swedish</td></tr></table>

* **Mail Orders** — send orders to:

IBM Publications
Publications Customer Support
P.O. Box 29570
Raleigh, NC 27626-0570
USA

IBM Publications
144-4th Avenue, S.W.
Calgary, Alberta T2P 3N5
Canada

IBM Direct Services
Sortemosevej 21
DK-3450 Allerød
Denmark

* **Fax** — send orders to:

<table><tr><td>United States (toll free)</td><td>1-800-445-9269</td></tr><tr><td>Canada</td><td>1-403-267-4455</td></tr><tr><td>Outside North America</td><td>(+45) 48 14 2207 (long distance charge)</td></tr></table>

* **1-800-IBM-4FAX (United States) or (+1)001-408-256-5422 (Outside USA)** — ask for:

Index # 4421 Abstracts of new redbooks

Index # 4422 IBM redbooks

Index # 4420 Redbooks for last six months

* **Direct Services** — send note to softwareshop@vnet.ibm.com

* **On the World Wide Web**

Redbooks Home Page http://www.redbooks.ibm.com

IBM Direct Publications Catalog http://www.elink.ibmlink.ibm.com/pbl/pbl

* **Internet Listserver**

With an Internet e-mail address, anyone can subscribe to an IBM Announcement Listserver. To initiate the service, send an e-mail note to announce@webster.ibmlink.ibm.com with the keyword subscribe in the body of the note (leave the subject line blank).
## IBM Redbook Order Form

Please send me the following:

<table><thead><tr><td>Title</td><td>Order Number</td><td>Quantity</td></tr></thead><tbody><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr></tbody></table>

<table><tr><td>First name</td><td>Last name</td></tr><tr><td>Company</td><td></td></tr><tr><td>Address</td><td></td></tr><tr><td>City</td><td>Postal code</td><td>Country</td></tr><tr><td>Telephone number</td><td>Telefax number</td><td>VAT number</td></tr><tr><td colspan="3">• Invoice to customer number</td></tr><tr><td colspan="3">• Credit card number</td></tr><tr><td>Credit card expiration date</td><td>Card issued to</td><td>Signature</td></tr></table>

We accept American Express, Diners, Eurocard, Master Card, and Visa. Payment by credit card not available in all countries. Signature mandatory for credit card payment.
# Glossary

## A

**abstract class.** A class that provides common behavior across a set of subclasses but is not itself designed to have instances that work.

**abstraction.** A simplified description or view of something that emphasizes characteristics or purposes relevant to the user while suppressing details that are immaterial or distracting.

**accessor methods.** Methods that an object provides to define the interface to its instance variables. The accessor method to return the value of an instance variable is often called a *get* method or *getter* method, and the accessor method to assign a value to an instance variable is called a *set* method or *setter* method.

**access plan.** The control structure produced during compile time that is used to process SQL statements encountered when the program is run.

**action.** In VisualAge, a function or operation that a part can perform upon receiving a message. Actions enable a part's public interface to give other parts access to its behaviors. Compare to *event* and *attribute*.

**activate.** To make a resource of a node ready to perform the functions for which it was designed. Contrast with *deactivate*.

**activator.** In distributed processing environments, a program running in the background (sometimes called a "daemon process") that initially activates other programs the first time they are called.

**active.** (1) Able to communicate on the network. A token-ring network adapter is active if it is able to transmit and receive on the network. (2) Operational. (3) Pertaining to a node or device that is connected or is available for connection to another node or device. (4) Currently transmitting or receiving.

**adapter.** Hardware card that allows a device, such as a PC, to communicate with another device, such as a monitor, a printer, or other I/O device.

**address.** (1) In data communication, the IEEE-assigned unique code or the unique locally administered code assigned to each device or workstation connected to a network. (2) A character, group of characters, or a value that identifies a register, a particular part of storage, a data source, or a data sink. The value is represented by one or more characters. (3) To refer to a device or an item of data by its address. (4) The location in the storage of a computer where data is stored. (5) In word processing, the location, identified by the address code, of a specific section of the recording medium or storage.

**Advanced Program-to-Program Communication (APPC).** (1) IBM's architected solution for program-to-program communication, distributed transaction processing, and remote database access. A transaction program (TP) using the APPC API can communicate with other TPs on systems that support APPC. (2) An implementation of the Systems Network Architecture (SNA) logical unit (LU) 6.2 protocol that enables interconnected systems to communicate and share the processing of programs.

**agent.** A VisualAge part used to encapsulate business logic and data access executed outside a VisualAge for Smalltalk image.

**allocate.** A logical unit (LU) 6.2 application program interface (API) verb used to assign a session to a conversation for the conversation's use. Contrast with *deallocate*.

**American National Standard Code for Information Interchange (ASCII).** The standard code, using a coded character set consisting of 7-bit coded characters (8 bits including parity check), used for information interchange among
data processing systems, data communication
systems, and associated equipment. The ASCII
set consists of control characters and graphics
characters.

**analog.** Pertaining to data consisting of
continuously variable physical quantities.
Contrast with *digital*.

**anonymous FTP.** Using the FTP function of the Internet anonymously by not logging in with an actual, secret login ID and password. Often permitted by large, host computers that are willing to share openly some of the files on their system to outside users who otherwise would not be able to log in. See also FTP.

**API.** See application program interface.

**APPC.** See Advanced Program-to-Program
Communication.

**application.** (1) The use to which an information
processing system is put; for example, a payroll
application or an order-entry application. (2) A
collection of defined and extended classes that
provides a reusable piece of functionality. An
application contains and organizes functionally
related classes. It also can contain
subapplications and specify prerequisites.

**application layer.** In Open Systems
Architecture, the layer of the OSI reference
model that provides a means for application
processes residing in different open systems to
exchange information.

**application manager.** (1) A team member who
is responsible for the overall state of an
application. An application manager coordinates
the activities of the application's developers and
assigns ownership of classes to team members.
(2) The browser from which users can create,
delete, manage, or configure applications in
their image.

**application program.** (1) A program written for
or by a user that applies to the user's work.
Some application programs receive support and
services from a special kind of application
program called a network application program.

(2) A program used to connect and
communicate with stations in a network,
enabling users to perform application-oriented
activities.

**Note:** Do not use the term *application* in place
of *application program*.

**application program interface (API).** An
architected functional interface supplied by an
operating system or other software system. The
interface enables an application program written
in a high-level language to use specific data or
functions of the underlying system.

**application programmer.** A person who
primarily writes and modifies programs for
application data. Contrast with *system
programmer*.

**Archie.** An Internet tool for finding files stored
on anonymous FTP sites. You need to know the
exact file name or a substring of it.

**architecture.** A logical structure that
encompasses operating principles including
services, functions, and protocols.

**argument.** A data element included as part of a
message. Arguments provide additional
information that the receiver can use to perform
the requested operation. Binary messages and
keyword messages take arguments. In a
keyword message, a colon (:) following a
keyword indicates that an argument is required.

**ARPANet.** (Advanced Research Projects
Agency Network), the precursor to the *Internet*.
Developed in the late 1960s and early 1970s by
the US Department of Defense as an experiment
in wide-area-networking that would survive a
nuclear war. See also *Internet*.

**array literal.** A literal that is an indexed
sequence of literals. The symbol `#` precedes
this sequence and parentheses enclose the
sequence. For example, `(5 7 9)` is an array of
three integers.

**ASCII.** (American Standard Code for
Information Interchange), this is the world-wide
standard for the code numbers used by
computers to represent all the upper and lower-case Latin letters, numbers, punctuation, etc. There are 128 standard ASCII codes each of which can be represented by a 7-digit binary number, 0000000 through 1111111.

**atomic.** (1) Pertaining to the smallest element in a composite object that can be manipulated independently. (2) Pertaining to a set of operations performed such that either all the operations performed or none of the operations are performed. (3) Pertaining to a set of operations that cannot be interrupted, such as a critical section of a parallel program.

**attribute.** (1) In VisualAge, data that represents a property of a part. (For example, a customer part could have a name attribute and an address attribute.) Attributes enable a part's public interface to give other parts access to its properties. An attribute can itself be a part, with its own behavior and attributes. Compare to *event* and *action*. (2) Information that describes the characteristics of system objects or program objects.

**attribute-to-attribute connection.** A connection from an attribute of one part to an attribute of another part. When one attribute is updated, the other attribute is updated automatically. See also *connection*.

**attribute-to-script connection.** A connection from an attribute of a part to a script. The connected attribute receives its value from the script, which can make calculations based on the values of other parts. See also *connection*.

**authority.** The right to do something on the system or to use an object, such as a file or document, in the system.

**authorization list.** A list that gives a group of users one or more types of access to objects (such as files or programs) or data in the objects (such as records in a file). It consists of a list of two or more user IDs and their authorities for system resources.

## B

**backbone.** A high-speed line or series of connections that forms a major pathway within a network. The term is relative, as a backbone in a small network is likely to be much smaller than many nonbackbone lines in a large network. See also *Network*.

**bandwidth.** The transmission capacity of the lines that carry the Internet's electronic traffic. Historically, it's imposed severe limitations on the ability of the Internet to deliver all that we are demanding it deliver, but fiber-optic cables will ensure that bandwidth soon will be essentially limitless and free.

**Basic Input/Output System (BIOS).** In IBM personal computers with PC I/O channel architecture, microcode that controls basic hardware operations such as interactions with diskette drives, fixed disk drives, and the keyboard.

**baud.** In common usage the baud rate of a modem is how many bits it can send or receive per second. Technically, baud is the number of times per second that the carrier signal shifts value; for example a 1200 bit/second modem actually runs at 300 baud, but it moves 4 bits per baud. See also *bit*, *modem*.

**behavior.** (1) The set of external characteristics that an object exhibits. (2) The abstract class that provides common behavior for class and metaclass objects.

**binary.** (1) Pertaining to a system of numbers to the base two; the binary digits are 0 and 1. (2) Pertaining to a selection, choice, or condition that has two possible different values or states.

**bind.** The process by which the output from the SQL precompiler is converted to a usable structure called an *access plan*. This process is the one during which access paths to the data are selected and some authorization checking is performed.
**bit.** (binary digit) A single digit number in base 2, in other words, either a 1 or a zero. The smallest unit of computerized data. *Bandwidth* is usually measured in bits per second. See also bandwidth, bps, byte, kilobyte, megabyte.

**block.** A Smalltalk object consisting of one or more statements, enclosed in brackets [ ], passed as arguments or used as the receiver of messages that implement control flow. Blocks can define temporary variables for their own use.

**Bps.** (bits per second) A measurement of how fast data is moved from one place to another. A 28.8 modem can move 28,800 bits per second. See also bandwidth, bit.

**browse.** A way of looking at a file that does not allow you to change it.

**browser.** (1) A window that supports one or more programming activities, such as creating new classes or methods, modifying existing classes or methods, or viewing library members. (2) Software that enables users to browse through the cyberspace of the World Wide Web. See also Client, URL, WWW.

**buffer.** (1) A portion of storage used to hold input or output data temporarily. (2) A routine or storage used to compensate for a difference in data rate or time of occurrence of events, when transferring data from one device to another.

**byte.** A set of bits that represent a single character. Usually there are 8 bits in a byte, sometimes more, depending on how the measurement is being made.

# C

**cascaded messages.** Multiple messages sent to the same receiver object. The messages are separated by a semicolon (;).

**category.** (1) On the VisualAge Composition Editor, a selectable grouping of parts represented by an icon in the left-most column.

Selecting a category displays the parts belonging to that category in the next column over. (2) A logical association of a group of methods within a class, with a name assigned by the class developer.

**CGI Link.** A stand-alone executable program that receives incoming CGI requests and routes them to the VisualAge application. CGI Link runs on the HTTP server, which does not have to be the same as the machine running the VisualAge application.

**CGI Link session data.** A Web Connection nonvisual part that holds a persistent data object. You can use CGI Link Session Data to store an application-specific object that remains valid from one CGI query to the next, for the duration of a **session**.

**change-event symbol.** In VisualAge, the code used to signal that an attribute has changed in value.

**character.** A symbol used in printing. For example, a letter of the alphabet, a numeral, punctuation, or any other symbol that represents information.

**character literal.** A literal that is any single character preceded by a dollar sign ($).

**CICS.** See *Customer Information Control System*.

**class.** The specification of an object, including its attributes and behavior. Once defined, a class can be used as a template for the creation of object instances. *Class*, therefore, can also refer to the collection of objects that share those specifications. A class exists within a hierarchy of classes in which it inherits attributes and behavior from its superclasses, which exist closer to the root of the hierarchy. See also *inheritance*, *metaclass*, *polymorphism*, *private class* and *public class*.

**class definition.** The definition of a class, containing:

* Class name
* Type of class

* Immediate superclass for the class

* Instance, class, and class instance variables

* Pool dictionaries that the class uses.

**class developer.** A team member who develops and changes classes. The team member who created an edition of a class is that edition's class developer. Contrast with class owner.

**class extension.** An extension to the functionality of a class defined by another application. The extension consists of one or more methods that define the added functionality or behavior. These methods cannot modify the existing behavior of the defined class; they can only add behavior specific to the application that contains the extended class.

**class hierarchy.** A tree structure that defines the relationships among classes. A class has subclasses down the hierarchy from itself and superclasses up the hierarchy from itself. The methods and variables of a class are inherited by its subclasses.

**class instance variable.** Private data that belongs to a class. The defining class and each subclass maintain their own copy of the data. Only the class methods of the class can directly reference the data. Changing the data in one class does not change it for the other classes in the hierarchy. Contrast with *class variable*.

**class method.** A method that provides behavior for a class. Class methods are usually used to define ways to create instances of the class. Contrast with *instance method*.

**class owner.** Team member responsible for the integrity of that class in an application edition. The class owner is responsible for releasing class versions. Contrast with class developer.

**class variable.** Data that is shared by the defining class and its subclasses. The instance methods and class methods of the defining class and its subclasses can directly reference this

data. Changing the data in one class changes it for all of the other classes. Contrast with *class instance variable*.

**client.** A software program that is used to contact and obtain data from a server software program on another computer, often across a great distance. Each client program is designed to work with one or more specific kinds of server programs, and each server requires a specific kind of client. A Web browser is a specific kind of client. See also browser, server.

**client object.** An object that requests services from other objects.

**client/server.** The model of interaction in distributed data processing in which a program at one location sends a request to a program at another location and awaits a response. The requesting program is called a client, and the answering program is called a server.

**code page.** A font component that associates code points and character identifiers. A code page also identifies how undefined code points are handled.

**collection.** (1) In Smalltalk, a set of elements in which each element is an object. (2) In SQL, a set of objects created by the SQL/400 licensed program that consists of and logically classifies a set of objects, such as tables, views, and indexes.

**command.** (1) A request for performance of an operation or execution of a program. (2) A character string from a source external to a system that represents a request for system action.

**comment.** A set of characters enclosed in double quotation marks. Smalltalk ignores comments and does not execute them.

**Common Gateway Interface.** A standard protocol through which a Web server can execute programs running on the server machine. CGI programs are executed in response to requests from Web client browsers.
**Common Object Request Broker Architecture (CORBA).** An architectural standard proposed by the Object Management Group (OMG), an industry standards organization, for creating object descriptions that are portable among programming languages and execution platforms.

**Common Programming Interface Communications (CPI-C).** An IBM communications architecture that defines a programming interface for peer-to-peer communications that is common across different environments and platforms. Also referred to as CPI Communications or CPI-C.

**Common User Access (CUA).** An IBM architecture for designing graphical user interfaces that uses a set of standard components and terminology.

**component.** A functional grouping of classes and related files within a product. See also *system component*.

**composite part.** A part that contains other parts; it can also contain data and behavior of its own. For example, a user interface view is a composite part composed of subparts such as entry fields, push buttons, and text.

**Composition Editor.** In VisualAge, a view that is used to build a graphical user interface and to make connections among parts.

**concrete class.** A subclass of an abstract class that is a specialization of the abstract class. For example, the concrete class, OrderedCollection, is a subclass of the abstract class, Collection.

**configuration.** (1) A description of a group of components that identifies, for each component, the component edition or version that is part of the group. (2) The arrangement of a computer system or network as defined by the nature, number, and chief characteristics of its functional units. More specifically, the term may refer to a hardware configuration or a software configuration. (3) The devices and programs that make up a system, subsystem, or network.

**configuration file.** The collective set of definitions that describes a configuration.

**configuration map.** A named group of application editions. A configuration map usually represents a product or one of its major parts.

**connection.** (1) In VisualAge, a formal, explicit relationship between parts. Connections define the ways in which parts communicate with one another. Making connections is the basic technique used for building any VisualAge application. See also *attribute-to-script*, *attribute-to-attribute*, *event-to-script*, and *event-to-action* connection. (2) A linkage between nodes. Connections are established and released at the Network, Session, and Presentation Layers.

**construction from parts.** A software development technology in which applications are assembled from reusable and existing software components known as parts.

**control language.** The set of all commands with which users request functions from the system.

**controller.** A unit that controls input/output operations for one or more devices.

**conversation.** In SNA, a logical connection between two transaction programs using an LU 6.2 session. Conversations are delimited by brackets to gain exclusive use of a session.

**CORBA.** See *Common Object Request Broker Architecture*.

**CPI-C.** See *Common Programming Interface Communications*.

**CUA.** See *Common User Access*.

**Customer Information Control System (CICS).** An IBM licensed program that enables transactions entered at remote terminals to be processed by user-written applications. It includes facilities for building, using, and maintaining databases.
**Cyberspace.** Term originated by author William Gibson in his novel *Neuromancer*, the word Cyberspace is currently used to describe the whole range of information resources available through computer networks.

## D

**data area.** A system object used to communicate data such as common language variable values between the programs within a job and between jobs. A data area is identified to the system as a specific object type. The system-recognized identifier for the object type is *DTAARA*.

**database file.** A system object of the type *FILE* that contains descriptions of how input data is to be presented to a program from internal storage and how output data is to be presented to internal storage from a program. The collection of all database files makes up the database (all the data files stored in the system).

**database manager.** A VisualAge or IBM Smalltalk database component that models a database management system in order to provide the interface between an application and the database management system.

**data description specifications (DDS).** A format for describing the user's database files or device files to the system. Describing a file in DDS is similar to filling in information on a form that is arranged in columns and rows. The most common characteristics, such as the names and lengths of fields, are described by putting entries in specific columns on the form. Another part of the form allows special parameters that describe less common and more varied characteristics. The finished specifications are then used as the source for creating the file.

**data integrity.** (1) The condition that exists as long as accidental or intentional destruction, alteration, or loss of data does not occur. (2) Preservation of data for its intended use.

**data processing.** The systematic performance of operations upon data; for example, handling, merging, sorting, and computing.

**data queue.** A way to communicate and put data used by several programs in a job or between jobs. The data queue is identified to the system as a specific type of object. The system-recognized identifier for the object type is *DTAQ*.

**data structure.** The syntactic structure of symbolic expressions and their storage allocation characteristics.

**data transfer.** (1) The result of the transmission of data signals from any data source to a data receiver. (2) The movement, or copying, of data from one location and the storage of the data at another location.

**deactivate.** To take a resource of a node out of service, rendering it inoperable, or to place it in a state in which it cannot perform the functions for which it was designed. Contrast with *activate*.

**deallocate.** A logical unit (LU) 6.2 application program interface (API) verb that terminates a conversation, thereby freeing the session for a future conversation. Contrast with *allocate*.

**debugger.** A software tool used to detect, trace, and eliminate errors in computer programs or other software.

**default.** Pertaining to an attribute, value, or option that is assumed when none is explicitly specified.

**delimiter.** (1) A character used to indicate the beginning or end of a character string. (2) A bit pattern that defines the beginning or end of a frame or token on a LAN.

**dependent LU.** Any logical unit (LU) that receives an ACTLU over a link. Such LUs can act only as secondary logical units (SLUs) and can have only one LU-LU session at a time. Contrast with *independent LU*.
**destination.** Any point or location, such as a node, station, or particular terminal, to which information is to be sent.

**device.** An input/output unit such as a terminal, display, or printer.

**dictionary.** In Smalltalk, an unordered collection whose elements are accessed by an explicitly assigned external key. See also *pool dictionary*.

**digital.** (1) Pertaining to data in the form of digits. Contrast with *analog*. (2) Pertaining to data consisting of numerical values or discrete units.

**disabled.** (1) Pertaining to a state of a processing unit that prevents the occurrence of certain types of interruptions. (2) Pertaining to the state in which a transmission control unit or audio response unit cannot accept incoming calls on a line.

**display.** (1) To present information for viewing, usually on a terminal screen or a hard-copy device. (2) A device or medium on which information is presented, such as a terminal screen.

**Display.** (1) A Smalltalk command that executes the selected code and displays the result. (2) In IBM Smalltalk, an X/Motif concept that models the user's hardware display. The functions of the X/Motif Display object are implemented in the IBM Smalltalk CgDisplay class.

**distributed application.** A workstation application that runs in cooperation with programs running on other processes or machines. Client/server applications are a subset of distributed applications.

**distributed computing environment (DCE).** A set of services and tools that support the creation, use, and maintenance of distributed applications in a heterogeneous computing environment.

**Distributed System Object Model (DSOM).** An extension to SOM enabling SOM objects to reside on multiple network nodes.

**DLL.** See *dynamic link library*.

**domain.** (1) An access method, its application programs, communication controllers, connecting lines, modems, and attached terminals. (2) In SNA, a system services control point (SSCP) and the physical units (PUs), logical units (LUs), links, link stations, and all the associated resources that the SSCP has the ability to control by means of activation requests and deactivation requests.

**domain name.** The unique name that identifies an Internet site. Domain names always have two or more parts, separated by dots. The part on the left is the most specific, and the part on the right is the most general. A given machine may have more than one domain name but a given domain name points to only one machine. Usually, all of the machines on a given network will have the same thing as the right-hand portion of their domain names, for example, gateway.mynetwork.com.br, mail.mynetwork.com.br, www.mynetwork.com.br, and so on. It is also possible for a domain name to exist but not be connected to an actual machine. This is often done so that a group or business can have an Internet e-mail address without having to establish a real Internet site. In these cases, some real Internet machine must handle the mail on behalf of the listed domain name. See also *IP Number*.

**dynamic data exchange (DDE).** A communication mechanism between processes that enables two applications to exchange data in a client/server relationship.

**dynamic link library (DLL).** A file containing data and code objects that can be used by programs or applications during loading or at run time but are not part of the program's executable (EXE) file.
E

**EBCDIC.** Extended binary-coded decimal interchange code. A coded character set consisting of 8-bit coded characters.

**edition.** In the VisualAge or IBM Smalltalk team programming environment, a software component that is subject to further change. A software component can have one or more editions, identified by a time stamp stating the date and time of the edition's creation. Many changes can be made to a single edition of a class. In contrast, every change to a method creates a new edition of that method. In its broadest sense, edition can include scratch edition and version.

**EHLLAPI.** Emulator high-level language application programming interface. A programming interface that enables a workstation application to communicate with a mainframe application. EHLLAPI operates in conjunction with a terminal (such as 3270) emulator.

**e-mail.** (Electronic mail) Messages transmitted over the Internet from user to user. E-mail can contain text, but also can carry with it files of any type as attachments.

**enabled.** (1) On a LAN, pertaining to an adapter or device that is active, operational, and able to receive frames from the network. (2) Pertaining to a state of a processing unit that allows the occurrence of certain types of interruptions. (3) Pertaining to the state in which a transmission control unit or an audio response unit can accept incoming calls on a line.

**encapsulation.** The hiding of a software object's internal data representation. The object provides an interface that queries and manipulates the data without exposing its underlying structure.

**end user.** A person, device, program, or computer system that utilizes a computer network for the purpose of data processing and information exchange.

**enterprise.** A business or organization that consists of two or more sites separated by a public right-of-way or a geographical distance.

**Ethernet.** A very common method of networking computers in a LAN. Ethernet will handle about 10,000,000 bits/second and can be used with almost any kind of computer. See also bandwidth, LAN.

**event.** A representation of a change that occurs to a part. The events on a part's public interface enable other interested parts to receive notification when something about the part changes. For example, a push button generates an event signaling that it has been clicked, which might cause another part to display a window. Compare to *attribute*.

**event-to-action connection.** A connection that causes an action to be performed when an event occurs. See also *connection*.

**event-to-script connection.** A connection that causes a script to run when an event occurs. See also *connection*.

**exception.** An abnormal condition such as an I/O error encountered in processing a data set or a file.

**execute.** To perform the actions specified by a program or a portion of a program.

**execution.** The process of carrying out an instruction or instructions of a computer program by a computer.

**expression.** In Smalltalk, the syntactic representation of one or more messages. An expression can consist of subexpressions representing the receiver and arguments of the message. The expression can also cause the assignment of its result to one or more variables.

**external source.** The format of Smalltalk source code that is filed out to an external file. See also *file in* and *file out*.
F

**feature.** (1) A major component of a software product that can be ordered separately. (2) In VisualAge, an action, attribute, or event that is available from a part's public interface and to which other parts can connect. See also *attribute* and *event*.

**field.** A group of related bytes (such as name or amount) that are treated as a unit in a record.

**file.** (1) A generic term for the object type that refers to a database file, a device file, or a save file. The system-recognized identifier for the object type is *FILE. (2) In the hierarchical file system, a piece of related information (data), such as a document. (3) In SQL, the term is generally referred to as a table.

**file in.** A Smalltalk command for compiling external definitions of applications, classes, and methods from a text file.

**file name.** (1) A name assigned to or declared for a file. (2) The name used by a program to identify a file.

**file out.** A Smalltalk command for writing definitions of applications, classes, and methods to an external text file.

**firewall.** A combination of hardware and software that protects a local area network (LAN) from Internet hackers. It separates the network into two or more parts and restricts outsiders to the area outside the firewall. Private or sensitive information is kept inside the firewall.

**first-in first-out (FIFO).** A queuing technique in which the next request to be processed from a queue is the request of the highest priority that has been on the queue for the longest time.

**fixed-length record.** A record having the same length as all other records with which it is logically or physically associated.

**form.** An HTML element that can include entry fields, push buttons, and other user-interface controls through which users can enter information. Sometimes called a *fill-in form*.

**format.** (1) A specified arrangement of such things as characters, fields, and lines, usually used for displays, printouts, or files. (2) To arrange such things as characters, fields, and lines.

**FQDN.** (Fully Qualified Domain Name) The official name assigned to a computer. Organizations register names, such as *ibm.com* or *utulsa.edu*. They then assign unique names to their computers, such as *watson5.ibm.com* or *tornado.cs.utulsa.edu*.

**framework.** A library of classes, intended for reuse, that fall within a particular domain (for example, a communications framework or a graphics framework).

**free-form surface.** In VisualAge, the large open area of the Composition Editor window. The free-form surface holds the visual parts contained by the views a user builds and representations of the nonvisual parts that an application includes.

**FTP.** (File Transfer Protocol) The basic Internet function that enables files to be transferred between computers. You can use it to download files from a remote, host computer, as well as to upload files from your computer to a remote, host computer. (See Anonymous FTP).

**function.** (1) A specific purpose of an entity, or its characteristic action. (2) In data communications, a machine action such as carriage return or line feed.

G

**garbage collection.** A Smalltalk process for periodically identifying unreferenced objects and deallocating their memory.

**gateway.** A device and its associated software that interconnect networks or systems of
different architectures. The connection is
usually made above the reference model
network layer.

**GET.** One of the methods used in HTTP requests. A GET request is used to retrieve data from an HTTP server. See also POST.

**GIF.** (Graphics Interchange Format) A graphics file format that is commonly used on the Internet to provide graphics images in Web pages.

**global variable.** A variable that any method in
any object can access.

**graphical user interface (GUI).** A type of interface that enables users to communicate with a program by manipulating graphical elements rather than by entering commands. Typically, a graphical user interface includes a combination of graphics, pointing devices, menu bars, overlapping windows, and icons.

**graphics.** (1) The making of charts and pictures. (2) Pertaining to charts, tables, and their creation.

**group member.** A team member who belongs to a group that is responsible for developing an application.

**GUI.** See graphical user interface.

H

**hardware.** Physical equipment as opposed to
programs, procedures, rules, and associated
documentation.

**header.** The portion of a message that contains control information for the message such as one or more destination fields, name of the originating station, input sequence number, character string indicating the type of message, and priority level for the message.

**HLLAPI.** High-level language application programming interface. A programming interface that enables a workstation application to communicate with a mainframe application.

HLLAPI usually operates in conjunction with a
terminal emulator.

**host.** (1) A computer that "hosts" outside computer users by providing files, services or sharing its resources. (2) Any computer on a network that is a repository for services available to other computers on the network. It is quite common to have one host machine provide several services, such as WWW and USENET. See also Node, Network.

**host computer.** (1) The primary or controlling computer in a multicomputer installation or network. (2) In a network, a processing unit in where a network access method resides.

**host variable.** A variable in an SQL statement used for substituting data values into the statement at execution time.

**HTML (hypertext markup language).** The basic language that is used to build hypertext documents on the World Wide Web. It is used in basic, plain ASCII-text documents, but when those documents are interpreted (called rendering) by a Web browser such as Netscape, the document can display formatted text, color, a variety of fonts, graphic images, special effects, hypertext jumps to other Internet locations and information forms.

**HTTP (hypertext transfer protocol).** The protocol for moving hypertext files across the Internet. Requires a HTTP client program on one end, and an HTTP server program on the other end. HTTP is the most important protocol used in the World Wide Web (WWW). See also Client, Server, WWW.

**HTTP request.** A transaction initiated by a Web browser and adhering to HTTP. The server usually responds with HTML data, but can send other kinds of objects as well.

**hypertext.** Text in a document that contains a hidden link to other text. You can click a mouse on a hypertext word and it will take you to the text designated in the link. Hypertext is used in Windows help programs and CD encyclopedias to jump to related references elsewhere within
the same document. The wonderful thing about hypertext, however, is its ability to link—using HTTP over the Web—to any Web document in the world, yet still require only a single mouse click to jump clear around the world.

I

**icon.** A small pictorial representation of an object.

**image.** A Smalltalk file that provides a development environment on an individual workstation. An image contains object instances, classes, and methods. It must be loaded into the Smalltalk virtual machine in order to run.

**implementor.** For any given message selector, a method that implements that selector.

**IMS.** Information Management System/Virtual Storage.

**inactive.** (1) Not operational. (2) Pertaining to a node or device not connected or not available for connection to another node or device.

**independent LU.** A logical unit (LU) that does not receive an ACTLU over a link. Such LUs can act as primary logical units (PLUs) or secondary logical units (SLUs) and can have one or more LU-LU sessions at a time. Contrast with *dependent LU*.

**index.** A set of pointers that are logically arranged by the values of a key. Indexes provide quick access and can enforce uniqueness on the rows in a table.

**inheritance.** A relationship among classes in which one class shares the structure and behavior of another. A subclass inherits from a superclass.

**initialize.** In a LAN, to prepare the adapter (and adapter support code, if used) for use by an application program.

**input/output (I/O).** (1) Pertaining to a device whose parts can perform an input process and

an output process at the same time.

(2) Pertaining to a functional unit or channel involved in an input process, output process, or both, concurrently or not, and to the data involved in such a process.

**inspector.** A Smalltalk tool for viewing the data of any Smalltalk object.

**instance.** An object that is a single occurrence of a particular class. An instance exists in memory or external media in persistent form. Compare to persistent object.

**instance method.** In Smalltalk, a method that provides behavior for particular instances of a class. Messages that invoke instance methods are sent to particular instances, rather than to the class as a whole. Contrast with *class method*.

**instance variable.** Private data that belongs to an instance of a class and is hidden from direct access by all other objects. Instance variables can be accessed only by the instance methods of the defining class and its subclasses.

**interface.** (1) A shared boundary between two functional units, defined by functional characteristics, common physical interconnection characteristics, signal characteristics, and other characteristics as appropriate. (2) A shared boundary. An interface may be a hardware component to link two devices or a portion of storage or registers accessed by two or more computer programs. (3) Hardware, software, or both, that links systems, programs, or devices.

**interface aids.** In VisualAge, when used together with the RecordStructure classes, the interface aids convert existing C or COBOL definitions into Smalltalk objects.

**Internet.** The vast collection of interconnected networks that all use the TCP/IP protocols and that evolved from the ARPANET of the late 1960's and early 1970's. By July of 1995, the Internet was connecting roughly 60,000 independent networks into a vast global net.
**intranet.** A private *network* inside a company or organization that uses the same kinds of software that you would find on the public Internet, but that is only for internal use. As the Internet has become more popular, many of the tools used on the Internet are being used in private networks, for example, many companies have Web servers that are available only to employees.

**IP.** (Internet Protocol) The rules that provide basic Internet functions. See TCP/IP.

**IP Number.** An Internet address that is a unique number consisting of four parts separated by dots, sometimes called a *dotted quad*. (For example: 198.204.112.1) Every Internet computer has an IP number and most computers also have one or more domain names that are plain language substitutes for the dotted quad.

**ISDN** (Integrated Services Digital Network) A set of communications standards that enable a single phone line or optical cable to carry voice, digital network services and video. ISDN is intended to eventually replace our standard telephone system.

**iterative development.** A software development process that allows progress in stages. At the end of each stage, the result is verified by end users. Through such verification, requirements are dynamically identified and refined while the product is under development.

## J

**Java.** Java is a new programming language invented by Sun Microsystems that is specifically designed for writing programs that can be safely downloaded to your computer through the Internet and immediately run without fear of viruses or other harm to your computer or files. Using small Java programs (called *applets*, Web pages can include functions such as animations, calculators, and other fancy tricks. We can expect to see a huge variety of features added to the Web using Java, since you can write a Java program to do

almost anything a regular computer program can do, and then include that Java program in a Web page.

**job control language (JCL).** A problem-oriented language designed to express statements in a job that are used to identify the job or describe its requirements to an operating system.

**journal.** A system object that identifies the objects being journaled, the current journal receiver, and all journal receivers on the system for the journal. The system-recognized identifier for the object type is *JRN.

**journaling.** The process of recording, in a journal, the changes made to a physical file member. Journaling allows the programmer to reconstruct a physical member by applying or removing the changes in the journal to a saved version of the physical file member.

**journal receiver.** A system object that contains journal entries added when changes are made to an object, for example, when an update is made to a file being journaled. The system-recognized identifier for the object type is *JRNRCV*.

**JPEG.** (Joint Photographic Experts Group) The name of the committee that designed the photographic image-compression standard. JPEG is optimized for compressing full-color or gray-scale photographic-type, digital images. It doesn't work well on drawn images such as line drawings, and it does not handle black-and-white images or video images.

## K

**kbps.** (kilobits per second) A speed rating for computer modems that measures (in units of 1024 bits) the maximum number of bits the device can transfer in one second under ideal conditions.

**keyword.** (1) One of the predefined words of an artificial language. (2) One of the significant and informative words in a title or document that describes the content of that document.
(3) A name or symbol that identifies a
parameter. (4) A part of a command operand
that consists of a specific character string (such
as DSNAME=).

**keyword message.** A message that takes one or more arguments. A keyword is an identifier followed by a colon (:). Each keyword requires one argument, and the order of the keywords is important. 'hello' at: 2 put: $H is an example of a keyword message; at: and put: are keyword selectors, 2 and $H are the arguments. See also message.

**kilobyte.** A thousand bytes. Actually, usually 1024 (2^10) bytes. See also byte, bit.

L

**LAN.** See local area network.

**library.** (1) A shared repository represented by a single file. It stores source code, object (compiled) code, and persistent objects, including editions, versions, and releases of software components. (2) A system object that serves as a directory to other objects. A library groups related objects and allows the user to find objects by name. To identify a specific object to the system, a user needs only to provide the object name, the object type, and the name of the library containing the object.

**link.** (1) The logical connection between nodes including the end-to-end link control procedures.
(2) The combination of physical media, protocols, and programming that connects devices on a network.
(3) In computer programming, the part of a program, in some cases a single instruction or an address, that passes control and parameters between separate portions of the computer program.
(4) To interconnect items of data or portions of one or more computer programs.
(5) In SNA, the combination of the link connection and link stations joining network nodes.

**listserv.** An Internet application that automatically serves mailing lists by sending electronic newsletters to a stored database of

Internet user addresses. Users can handle their
own subscribe/unsubscribe actions without
requiring anyone at the server location to
personally handle the transaction.

**literal.** An object that can be created by the compiler. A literal can be a number, a character string, a single character, a symbol, or an array. All literals are unique: Two literals with the same value refer to the same object. The object created by a literal is read-only; it cannot be changed.

**literal text.** Text in an HTML Text part that is passed to the client browser exactly as entered. You can use literal text to code HTML tagging that is not directly supported by the Web Connection parts.

**load.** A system operation that links the compiled code for a software component from a library into an active image. Loading also performs other operations that enable the component to run, such as linking prerequisites.

**local address.** In SNA, an address used in a peripheral node in place of an SNA network address and transformed to or from an SNA network address by the boundary function in a subarea node.

**local area network (LAN).** (1) A network in which devices are connected to one another for communication and can be connected to a larger network. See also token ring. (2) A network in which communications are limited to a moderately sized geographic area such as a single office building, warehouse, or campus, and do not generally extend across public rights-of-way. Contrast with wide area network.

**local node.** In the subsystem, the node from which one views the rest of the OSI network—the node for which resources are defined. Contrast with remote node.

**logical file.** A description of how data is to be presented to or received from a program. This type of database file contains no data, but it defines record formats for one or more physical files. The record formats allow a developer to
present different views of the data in a physical file.

**logical unit (LU).** In SNA, a port through which a user gains access to the services of a network. A logical unit can support two types of sessions—with the host, and with other LUs. See logical unit 6.2.

**logical unit (LU) 6.2.** A type of logical unit that supports general communication between programs in a distributed processing environment. LU 6.2 is characterized by (1) a peer relationship between session partners, (2) efficient utilization of a session for multiple transactions, (3) comprehensive end-to-end error processing, and (4) a generic application program interface (API) consisting of structured verbs that are mapped to a product implementation. Synonym for Advanced Program-to-Program Communications.

**Login.** The account name used to gain access to a computer system. Not kept secret (unlike password).

**LU type.** In SNA, the classification of a LU-LU session in terms of the specific subset of SNA protocols and options supported by the logical units (LUs) for that session, namely:

* The mandatory and optional values allowed in the session activation request

* The usage of data stream controls, function management headers (FMHs), request unit (RU) parameters, and sense codes

* Presentation services protocols such as those associated with FMH usage.

LU types 0, 1, 2, 3, 4, 6.1, 6.2, and 7 are defined.

# M

**machine-readable information (MRI).** Language-sensitive information associated with a computer program, such as program integrated information or softcopy documentation.

**management services.** In SNA, one of the types of network services in control points (CPs) and physical units (PUs). Management services are the services provided to assist in the management of SNA networks, such as problem management, performance and accounting management, configuration management and change management.

**megabyte.** A million bytes. A thousand kilobytes. See also byte, bit, kilobyte.

**message.** In Smalltalk, a communication from one object to another that requests the receiving object to execute a method. A message consists of a reference to the receiving object, followed by a selector indicating the requested method, and (in many cases) arguments to be used in executing the method. There are three types of messages: binary, keyword, and unary.

**metaclass.** The specification of a class; the complete description of a class's attributes, behavior, and implementation. Every class has a metaclass, of which it is the sole instance. Contrast with *class*.

**method.** Executable code that implements the logic of a particular message for a class. In VisualAge, methods are also called scripts. See also *class method*, *instance method*, *private method*, and *public method*.

**MIME.** (Multipurpose Internet Mail Extensions) A set of Internet functions that extend normal e-mail capabilities and enable nontext computer files to be attached to e-mail. Nontext files include graphics, spreadsheets, formatted word-processor documents, sound files, and so on. Files sent by MIME arrive at their destination as exact copies of the original so that you can send fully formatted word processing files, spreadsheets, graphics images and software applications to other users via simple e-mail. Besides email software, the MIME standard is also universally used by Web servers to identify the files they are sending to Web clients, in this way new file formats can be accommodated simply by updating the browsers' list of pairs of MIME types and
appropriate software for handling each type.
See also browser, client, server.

**model.** A nonvisual part that represents the state and behavior of a real-world object, such as a customer or an account. Contrast with view.

**mode name.** A symbolic name for a set of session characteristics. For LU 6.2, a mode name and a partner LU name together define a group of parallel sessions having the same characteristics.

**module.** A program unit that is discrete and identifiable with respect to compiling, combining with other units, and loading; for example, the input to or output from an assembler, compiler, linkage editor, or executive routine.

**monitor.** (1) A functional unit that observes and records selected activities for analysis within a data processing system. Possible uses are to show significant departures from the norm, or to determine levels of utilization of particular functional units. (2) Software or hardware that observes, supervises, controls, or verifies operations of a system.

**Multiple Virtual Storage (MVS).** An IBM licensed program whose full name is the Operating System/Virtual Storage (OS/VS) with Multiple Virtual Storage/System Product for System/370. It is a software operating system controlling the execution of programs.

**multireceive dialog.** A dialog that takes one data record from the object that initiates the dialog, sends it to a remote program, and returns multiple records from the remote program to the initiating object. Compare to *simple dialog*.

N

**NetBIOS.** See *Network Basic Input/Output System*.

**network.** (1) A configuration of data processing devices and software connected for information interchange. (2) An arrangement of nodes and connecting branches. Connections are made between data stations.

**network address.** In SNA, an address, consisting of subarea and element fields, that identifies a link, a link station, or a network addressable unit. Subarea nodes use network addresses; peripheral nodes use local addresses. The boundary function in the subarea node to which a peripheral node is attached transforms local addresses to network addresses and vice versa. See *local address*.

**Network Basic Input/Output System (NetBIOS).** An operating system interface for application programs used on IBM personal computers that are attached to an IBM Token-Ring Network.

**network layer.** (1) In the Open Systems Interconnection reference model, the layer that provides for the entities in the transport layer the means for routing and switching blocks of data through the network between the open systems in which those entities reside. (2) The layer that provides services to establish a path between systems with a predictable quality of service. See *Open Systems Interconnection (OSI)*.

**network management.** The conceptual control element of a station that interfaces with all of the architectural layers of that station and is responsible for the resetting and setting of control parameters, obtaining reports of error conditions, and determining whether the station should be connected to or disconnected from the network.

**nil.** The object in Smalltalk that means *no value*. All variables initially refer to nil. It is the single instance of the *UndefinedObject* class.
**node.** (1) Any device, attached to a network, that transmits and/or receives data. (2) An endpoint of a link, or a junction common to two or more links in a network. (3) In a network, a point where one or more functional units interconnect transmission lines.

**node name.** In VTAM, the symbolic name assigned to a specific major or minor node during network definition.

**nonvisual class.** A class in a VisualAge application that specifies a nonvisual part. For example, Person, Address, and BankAccount are nonvisual classes.

**nonvisual part.** A part that has no visual representation at run time. A nonvisual part typically represents some real-world object that exists in the business environment. Contrast with *view, visual part*.

**notebook.** In VisualAge, a view that resembles a bound notebook, containing pages separated into sections by tabbed divider pages. A user can turn the pages of a notebook or select the tabs to move from one section to another.

# O

**object.** (1) The basic building block in Smalltalk development. An object is anything that exhibits behavior. All code and data in Smalltalk must be part of an object. (2) On the AS/400 system, an object is a named storage space consisting of a set of characteristics that describes itself and, in some cases, data. Some examples of objects are programs, files, and libraries.

**object code.** Compiler or assembler output that is itself executable machine code or is suitable for processing to produce executable machine code. Contrast with *source code*.

**object factory.** A nonvisual part capable of dynamically creating new instances of a specified part. For example, during the execution of an application, an object factory can create instances of a new class to collect the data being generated.

**object-oriented programming.** A programming methodology built around objects and based on sending messages back and forth between those objects. The basic concepts of object-oriented programming are encapsulation, inheritance, and polymorphism.

**object persistency.** A characteristic that enables objects to exist beyond the time in which their creating application runs. One use of object persistency is sharing objects among programmers in a development environment.

**open system.** (1) A system with specified standards that therefore can be readily connected to other systems that comply with the same standards. (2) A data communications system that conforms to the standards and protocols defined by Open Systems Interconnection (OSI).

**open systems architecture (OSA).** A model that represents a network as a hierarchical structure of layers of functions; each layer provides a set of functions that can be accessed and that can be used by the layer above it.

**Note:** Layers are independent in the sense that implementation of a layer can be changed without affecting other layers.

**Open Systems Interconnection (OSI).** (1) The interconnection of open systems in accordance with specific ISO standards. (2) The use of standardized procedures to enable the interconnection of data processing systems.

**Note:** The OSI architecture establishes a framework for coordinating the development of current and future standards for the interconnection of computer systems. Network functions are divided into seven layers. Each layer represents a group of related data processing and communication functions that can be carried out in a standard way to support different applications.

**operating system.** Software that controls the execution of programs. An operating system can provide services such as resource
allocation, scheduling, input/output control, and
data management.

**operation.** (1) A defined action, namely, the act of obtaining a result from one or more operands in accordance with a rule that completely specifies the result for any permissible combination of operands. (2) A program step undertaken or executed by a computer. (3) An action performed on one or more data items, such as adding, multiplying, comparing, or moving.

**option.** (1) A specification in a statement, a selection from a menu, or a setting of a switch that may be used to influence the execution of a program. (2) A hardware or software function that may be selected or enabled as part of a configuration process. (3) A piece of hardware (such as a network adapter) that can be installed in a device to modify or enhance device function.

# P

**panel.** (1) A formatted display of information that appears on a terminal screen. Contrast with *screen*. (2) In computer graphics, a display image that defines the locations and characteristics of display fields on a display surface.

**parameter.** (1) A data element included as part of a message to provide information that the object might need. In Smalltalk, generally referred to as an argument. (2) A variable that is given a constant value for a specified application and that may denote the application. (3) An item in a menu or for which the user specifies a value or for which the system provides a value when the menu is interpreted. (4) Data passed between programs or procedures.

**part.** A self-contained software object with a standardized public interface, consisting of a set of external features that allow the part to interact with other parts. The parts on the VisualAge parts palette can be used as templates to create instances of objects.

**parts palette.** In the VisualAge Composition Editor, an organized collection of visual and nonvisual parts used in building composite parts for an application. The parts palette is organized into categories. Application developers can add parts to the palette for use in defining applications or other parts.

**password.** In computer security, a string of characters known to the computer system and a user, who must specify it to gain full or limited access to a system and to the data stored within it.

**path.** (1) In a network, any route between any two nodes. (2) The route traversed by the information exchanged between two attaching devices in a network. (3) A command in IBM Personal Computer Disk Operating System (PC DOS) and IBM Operating System/2 (OS/2) that specifies directories to be searched for commands or batch files that are not found by a search of the current directory.

**PATH_INFO.** A CGI variable, usually transmitted to the CGI program in the form of an environment variable. The PATH_INFO variable contains all path information from the URL following the name of the CGI executable. For a Web Connection application, this information is the same as the VisualAge part name.

**persistent object.** Instances stored outside of the image. A persistent object must be loaded into virtual or real storage before it can process messages sent to it.

**personal computer (PC).** A desk-top, free-standing, or portable microcomputer that usually consists of a system unit, a display, a monitor, a keyboard, one or more diskette drives, internal fixed-disk storage, and an optional printer. PCs are designed primarily to give independent computing power to a single user and are inexpensively priced for purchase by individuals or small businesses. Examples include the various models of the IBM personal computers and the IBM Personal System/2 computer.
**physical connection.** The ability of two connectors to mate and make electrical contact. In a network, devices that are physically connected can communicate only if they share the same protocol.

**physical file.** A description of how data is to be presented to or received from a program and how data is actually stored in the database. A physical file contains one record format and one or more members.

**physical unit (PU).** In SNA, a type of network addressable unit (NAU). A physical unit (PU) manages and monitors the resources (such as attached links) of a node, as requested by a system services control point (SSCP) through an SSCP-PU session. An SSCP activates a session with the physical unit in order to indirectly manage, through the PU, resources of the node such as attached links.

**pointer.** (1) An identifier that indicates the location of an item of data. (2) A data element that indicates the location of another data element. (3) A physical or symbolic identifier of a unique target.

**polymorphism.** The ability of different objects to respond to the same message in different ways. Different objects can have very different method implementations for the same message. An object can send a message without concern for its underlying implementation.

**pool dictionary.** A dictionary object whose keys define variables that can be shared by multiple classes. All methods for a class can access the variables in a pool dictionary if the class declares the pool dictionary as part of its scope.

**port.** (1) A place where information goes into or out of a computer, or both. For example, the serial port on a personal computer is where a modem would be connected. (2) On the Internet port often refers to a number that is part of a URL, appearing after a colon (:) right after the domain name. Every *service* on an Internet server listens on a particular port number on that server. Most services have standard port numbers; Web servers normally listen on port

80. Services can also listen on nonstandard ports, in which case the port number must be specified in a URL when accessing the server. (3) Refers to translating a piece of software to bring it from one type of computer system to another. See also domain name, server, URL.

**POST.** One of the methods used in HTTP requests. A POST request is used to send data to an HTTP server. See also GET.

**prerequisite application.** An application required by another application for it to function successfully. An application can extend or reference one or more of the prerequisite application's classes. In team development, prerequisite applications are particular versions or editions of applications.

**presentation layer.** In the Open Systems Interconnection reference model, the layer that provides for the selection of a common syntax for representing information and for transformation of application data into or from this common syntax.

**primary logical unit (PLU).** In SNA, the logical unit (LU) that contains the primary half-session for a particular LU-LU session. Each session must have a PLU and secondary logical unit (SLU). The PLU is the unit responsible for the bind and is the controlling LU for the session. A particular LU may contain both primary and secondary half-sessions for different active LU-LU sessions.

**primary part.** In a composite part constructed with the VisualAge Composition Editor, the subpart whose public interface is fully exposed on the public interface of the composite part. The primary part is transparently visible to parts outside the composite part and is the subpart with which most interaction will take place.

**private class.** In VisualAge or IBM Smalltalk, a class that is not part of the system API but is provided as part of the internal functioning of the system. A private class is not visible outside its containing application. If you use a VisualAge or IBM Smalltalk class marked as private, you might have to modify your code in
order for it to work with a future release of
VisualAge or IBM Smalltalk. Contrast with
*public class*.

**private method.** In VisualAge or IBM Smalltalk, a method that is not part of the system API but is provided as part of the internal functioning of the system. If you use a method marked as private, you might have to modify your code in order for it to work with a future release of VisualAge or IBM Smalltalk. Contrast with *public method*. Individual application development projects can use the public and private designations as a means of organizing their code.

**process.** In Smalltalk, a sequence of actions described by expressions and performed by the system's virtual machine.

**property.** A unique characteristic of a part.

**protocol.** (1) The set of all messages to which an object will respond. (2) Specification of the structure and meaning (the semantics) of messages that are exchanged between a client and a server. (3) A set of semantic and syntactic rules that determine the behavior of functional units in achieving communication. (4) In SNA, the meanings of and the sequencing rules for requests and responses used for managing the network, transferring data, and synchronizing the states of network components. (5) A specification for the format and relative timing of information exchanged between communicating parties.

**proxy.** An application gateway from one network to another for a specific network application like Telnet of FTP, for example, a firewall's proxy Telnet server performs authentication of the user and then lets the traffic flow through the proxy as if it were not there. Function is performed in the firewall and not in the client workstation, causing more load in the firewall. Compare with socks.

**PRPQ.** Programming Request for Price Quotation. A customer request for a price quotation for a licensed program to be designed

especially for a particular group of customers or an application. Documentation for the program is provided only to those customers who order the PRPQ.

**pseudocode.** An artificial language used to describe computer program algorithms without using the syntax of any particular programming language. The code requires translation before execution.

**public class.** A class that is provided as part of the VisualAge or IBM Smalltalk API. A public class is visible to applications other than its containing application. Public classes are designed to function with future releases of VisualAge or IBM Smalltalk and with operating systems supported by VisualAge or IBM Smalltalk. Contrast with *private class*.

**public interface.** A set of external features that enable a part to interact with other parts. A part's public interface is made up of three characteristics: attributes, actions, and events.

**Public Interface Editor.** A VisualAge view used to create and modify attributes, actions, and events, which together make up the public interface of a part.

**public method.** A method that is provided as part of the VisualAge or IBM Smalltalk API. Public methods are designed to function with future releases of VisualAge or IBM Smalltalk and with operating systems supported by VisualAge or IBM Smalltalk. Contrast with *private method*. Individual application development projects can use the public and private designations as a means of organizing their code.

# Q

**query specification.** A database query definition. All queries issued to a database by VisualAge or IBM Smalltalk must be defined by a query specification.

**quick form.** In the VisualAge Composition Editor, a menu option that enables application
developers to quickly create a default view for a part.

R

**receive.** To obtain and store information transmitted from a device.

**receiver.** The object that receives a message. Contrast with *sender*.

**record.** (1) (ISO) In programming languages, an aggregate that consists of data objects, possibly with different attributes, that usually have identifiers attached to them. In some programming languages, records are called structures. (2) (TC97) A set of data treated as a unit. (3) A set of one or more related data items grouped for processing. (4) In VTAM, the unit of data transmission for record mode. A record represents whatever amount of data the transmitting node chooses to send.

**RecordStructure.** An object that contains information about the format, structure, and types of the data it contains.

**RecordStructure classes.** Classes that provide a flexible, open architecture for converting Smalltalk objects to and from data types of other languages.

**release.** A system operation on a component that changes its containing component's configuration. Releasing a component adds its released edition or version to the configuration for its containing component. When a containing component is loaded into an image, the released editions or versions of the components it contains are also loaded.

**remote.** Concerning the peripheral parts of a network not centrally linked to the host processor and generally using telecommunication lines with public right-of-way.

**remote node.** Any node other than the local node. Contrast with *local node*.

**repository.** (1) An organized, shared body of information that can support business and data-processing activities. (2) In VisualAge or IBM Smalltalk, the multiuser library that stores components such as applications, classes, and methods created by application developers. It stores source code, object code, and persistent objects.

**request.** A service primitive issued by a service user to call a function supported by the service provider.

**reset button.** A type of push button that can appear on a form. A reset button restores all input fields to their default states.

**resource.** (1) Any facility of the computing system or operating system required by a job or task, and including main storage, input/output devices, the processing unit, data sets, and control or processing programs. (2) In the NetView program, any hardware or software that provides function to the network.

**response.** A service primitive issued by a service user to complete the procedures associated with a confirmed service.

**return code.** (1) A value (usually hexadecimal) provided by an adapter or a program to indicate the result of an action, command, or operation. (2) A code used to influence the execution of succeeding instructions.

**return value.** An object or data type that a receiver object passes to a sender object in response to a message.

**router.** A network device that enables the network to reroute messages it receives that are intended for other networks. The network with the router receives the message and sends it on its way exactly as received. In normal operations, they do not store any of the messages that they pass through.

**routine.** Part of a program, or a sequence of instructions called by a program, that may have some general or frequent use.
**RPG.** A programming language designed for writing application programs for business data processing requirements. The application programs range from report writing and inquiry programs to applications such as payroll, order entry, and production planning.

## S

**scratch edition.** A mutable and private copy of an application for a user who is not necessarily the application's manager. The scratch edition only exists in that user's image. Using a scratch edition, one can modify an application version, and the existing classes contained in it, without actually creating a new edition. Each scratch edition has << >> displayed around the edition timestamp or version name. Contrast with edition, version.

**screen.** An illuminated display surface; for example, the display surface of a CRT or plasma panel. Contrast with *panel*.

**script.** A series of Smalltalk statements that implement an action for a part. Scripts are equivalent to Smalltalk methods.

**Script Editor.** A VisualAge view that enables a developer to implement part behavior by writing Smalltalk scripts (methods). The Script Editor shows all the objects that can be referenced by a method and all previously defined methods of a part's class.

**selector.** The component of a message that specifies the requested operation. There are three kinds of selectors: binary, keyword, and unary.

**sender.** An object that sends a message to another object. On the level of code implementation, the sender is considered to be the sending method within the class or instance that issues the message. Contrast with *receiver*.

**server.** (1) A computer that provides services to multiple users or workstations in a network; for example, a file server, print server, or mail

server. (2) An object that performs one or more tasks on behalf of a client. The server can be a computer (a file server), a specific process on a server, or a distributed object. A single server machine could have several different server software packages running on it, thus providing many different servers to clients on the network. See also client, network.

**service.** (1) A specific behavior that an object is responsible for exhibiting. (2) In network architecture, the capabilities that a layer and the layers closer to the physical media provide to the layers closer to the end user. (3) A set of service primitives that a layer provides to the layer above it.

**service object.** A nonvisual part that gives access to the outside world of a VisualAge for Smalltalk image.

**session.** (1) A connection between two application programs that allows them to communicate. (2) In SNA, a logical connection between two network addressable units that can be activated, tailored to provide various protocols, and deactivated as requested. (3) The data transport connection resulting from a call or link between two devices. (4) The period of time during which a user of a node can communicate with an interactive system, usually the elapsed time between logon and logoff. (5) In network architecture, an association of facilities necessary for establishing, maintaining, and releasing connections for communication between stations. (6) A series of CGI queries that come from the same client and belong to the same logical sequence. A session is identified by a unique session key, which is generated by VisualAge. A session begins when a client initially connects (without a session key) and ends when a specified timeout period has elapsed since the last connection.

**session key.** A unique string, generated automatically by VisualAge, that identifies a session. All requests and replies carry the session key in hidden HTML data fields.

**session layer.** The layer that provides the services that organize and synchronize
communications between functional units in
different open systems located in the
presentation layer.

**settings view.** A view of a part that provides a way to display and set the attributes and options associated with the part.

**simple dialog.** A dialog that takes one data record from the initiating object and sends it to a remote program, which returns the result to the initiating object. Compare to *multireceive dialog*.

**Smalltalk (ST).** (1) A complete programming environment for developing object-oriented applications. Smalltalk is a pure implementation of object-oriented concepts; every entity in the environment is an object. (2) The name of the programming language that the Smalltalk programming environment supports. (3) In the IBM Smalltalk programming environment, the name of the System Dictionary containing the global variables.

**SNA.** See *Systems Network Architecture*.

**socket.** (1) In the TCP/IP environment, a socket is an endpoint for communication between processes or applications. A socket that can send data to and receive data from a remote node is a connected socket. (2) Synonym for *port*.

**socks.** Software to intercept and redirect all TCP/IP requests at the firewall. It handles data to and from applications such as Telnet, FTP, Mosaic, and Gopher. Provides users in a secured network access to resources outside the network by directing data through the firewall. Firewall users must use client programs specifically designed to work with the *sockd* server.

**software.** (1) Programs, procedures, rules, and any associated documentation pertaining to the operation of a system. (2) Contrast with *hardware*.

**SOM.** See *system object model*.

**source code.** Compiler or assembler input, written in a source language. Contrast with *object code*.

**source file.** A file of programming code that is not compiled into machine language. A source file can be created by the specification of FILETYPE(*SRC*) on the Create command. A source file can contain source statements for such items as high-level language programs and data description specifications (DDS).

**SQL.** Structured Query Language. A language used to access relational databases.

**SQL Editor.** An interactive tool for creating structured query language (SQL) statements. It consists of a set of dialogs that prompt the user for information about database tables and use that information to generate SQL statements.

**statement.** A language syntactic unit consisting of an operator, or other statement identifier, followed by one or more operands.

**stored procedure.** A procedure stored in a database system that contains SQL and other control statements.

**structured query language (SQL).** A language used to access relational databases.

**subapplication.** An application contained by another application. Using subapplications, one can organize the classes of an application into a tree of subapplications or isolate the parts of an application that are platform-specific.

**subclass.** A class that inherits behaviors and specifications (in other words, methods and variables) from another class. Contrast with *superclass*.

**subclass type.** In VisualAge or IBM Smalltalk, an indication of how a subclass inherits instance variables from its superclass.

**submit button.** A type of push button that can appear on a form. A submit button initiates a connection to the HTTP server and sends a CGI
query, using the data from the input fields as
parameters.

**subpart.** A part that is embedded within a
composite part.

**subsystem.** A secondary or subordinate
system, or programming support, usually
capable of operating independently of or
asynchronously with a controlling system.

**superclass.** A class from which another class
inherits behaviors and specifications (in other
words, methods and variables). Contrast with
**subclass**.

**symbol.** In Smalltalk, an object that represents
a string used as a name within the system. A
symbol literal is a sequence of characters
preceded by the pound sign (#) with no
embedded blanks, such as #George or
#messageSelector.

**synchronous.** (1) Pertaining to two or more
processes that depend on the occurrences of a
specific event such as common timing signal.
(2) Occurring with a regular or predictable
timing relationship.

**system.** In data processing, a collection of
people, machines, and methods organized to
accomplish a set of specific functions.

**system component.** A component that manages
storage of code and access to that stored code.
A library file is a system component that stores
and manages code. A user object is a system
component that represents a person who can
use a library.

**system object model (SOM).** An
object-structured protocol that enables
applications to access and use objects and
object definitions, regardless of the
programming language created that them, with
no need to recompile the application.

**systems management.** The process of
monitoring, coordinating, and controlling
resources within open systems.

**Systems Network Architecture (SNA).** The
description of the logical structure, formats,
protocols, and operational sequences for
transmitting information units through, and
controlling the configuration and operation of,
networks.

T

**TCP/IP.** (Transmission Control Protocol/Internet
Protocol) The basic programming foundation that
carries computer messages around the globe
via the Internet. The suite of protocols that
defines the Internet. Originally designed for the
UNIX operating system, TCP/IP software is now
available for every major kind of computer
operating system. To be truly on the Internet,
your computer must have TCP/IP software.

**team programming.** Development of a system,
program, or application suite by a team of two
or more programmers or application developers.

**tear-off attribute.** An attribute that an
application developer has exposed to work with
as though it were a standalone part.

**Telnet.** An Internet protocol that lets you
connect your PC as a remote workstation to a
host computer anywhere in the world and to use
that computer as if you were logged on locally.
You often have the ability to use all of the
software and capability on the host computer,
even if it's a huge mainframe.

**temporary variable.** A variable whose scope is
limited to the Smalltalk method or block in which
it is defined. A temporary variable takes an
assigned value.

**terminal.** A device that is capable of sending
and receiving information over a link; it is
usually equipped with a keyboard and some kind
of display, such as a screen or a printer.

**token ring.** A network with a ring topology that
passes tokens from one attaching device (node)
to another. A node that is ready to send can
capture a token and insert data for transmission.
**tool bar.** In the VisualAge Composition Editor, the strip of icons along the top of the free-form surface. The tool bar contains tools to help construct composite parts. These tools are also available through the Tools pull-down menu of the Composition Editor window.

**transaction.** (1) In client/server transaction processing, a business activity or set of activities that transforms a database from one state to another (for example, making an airline reservation or custom ordering an automobile). (2) In an SNA network, an exchange between two programs that usually involves a specific set of initial input data that causes the execution of a specific task or job. Examples of transactions include the entry of a customer's deposit that results in the updating of the customer's balance, and the transfer of a message to one or more destination points.

**transaction program.** A program that processes transactions in or through a logical unit (LU) type 6.2 in an SNA network. Application transaction programs are end users in an SNA network; they process transactions for service transaction programs and for other end users. Service transaction programs are IBM-supplied programs that typically provide utility services to application transaction programs.

**Transcript window.** The main controlling window in Smalltalk.

**Transmission Control Protocol/Internet Protocol (TCP/IP).** A set of protocols that allow cooperating computers to share resources across a heterogeneous network.

# U

**uniform resource locator (URL).** A standard identifier for a resource on the World Wide Web, used by a Web browser to initiate a connection. The URL includes the communications protocol to use, the name of the server, and path information identifying the object to be retrieved on the server.

**usability.** The quality of a system, program, or device that enables users to easily understand and conveniently use it.

**user interface (UI).** The hardware, software, or both that enables a user to interact with a computer. In VisualAge, user interface normally refers to the visual presentation with which a user interacts and its underlying software.

**user profile.** A file that contains the user's password, the list of special authorities assigned to a user, and the objects the user owns. It is used by the system to verify the user's authorization to read or use objects, such as files or devices, or to run the jobs on the system. Each user profile must have a unique name.

**user space.** In OS/400 application programming interfaces, an object consisting of a collection of bytes that can be used for storing any user-defined information. The system-recognized identifier for the object type is *USRSPC.

# V

**variable.** (1) A storage place within an object for a data element. The data element is an object, such as a number or date, stored as an attribute of the containing object. (2) In VisualAge, a part that receives an identity at run time. A variable by itself contains no data or program logic; it must be connected in such a way that it receives runtime identity from a part elsewhere in the application.

**version.** In the VisualAge or IBM Smalltalk team programming environment, an edition of a software component that cannot be changed. Each version has a version name. Contrast with *edition*.

**view.** A composite visual part. A view can display and change the underlying nonvisual objects of an application. In VisualAge, views are both the end result of developing an application and the basic unit of composition of user interfaces. Compare to *visual part*.
**Virtual Storage Access Method (VSAM).** An access method for direct or sequential processing of fixed and variable-length records on direct access devices. The records in a VSAM data set or file can be organized in logical sequence by a key field (key sequence), in the physical sequence in which they are written on the data set or file (entry-sequence), or by relative-record number.

**Virtual Telecommunications Access Method (VTAM).** An IBM licensed program that controls communication and the flow of data in an SNA network. It provides single-domain, multiple-domain, and interconnected network capability.

**visible class.** A class that another class can subclass or refer to by name in a method. *Visible* refers to the scope in which the class name can be used. For a class in a given application, visible classes include:

• All classes defined in the same application

• All public classes defined in any subapplication

• All prerequisite classes, including prerequisites of prerequisites to the lowest level

**visual part.** A part that has a visual representation at run time. Visual parts, such as windows, push buttons, and entry fields, make up the user interface of an application. Compare to *view*. Contrast with *nonvisual part*.

**visual programming tool.** A tool, such as VisualAge, that provides a means for specifying programs graphically. Application programmers write applications by manipulating graphical representations of components.

# W

**WAN.** (Wide Area Network)— Any internet or network that covers an area larger than a single building or campus. See also Internet, LAN, network.

**wide area network (WAN).** A data communications network designed to serve an area of hundreds or thousands of miles—for example, public and private packet-switching networks, and national telephone networks.

**widget.** An object that provides a user-interface abstraction; for example, a scrollbar widget.Widgets support obtaining input from the user and displaying output to the user.

**window.** (1) A rectangular area of the screen with visible boundaries in which information is displayed. Windows can overlap on the screen, giving the appearance of one window being on top of another. (2) In the VisualAge Composition Editor, a part that can be used as a container for other visual parts, such as push buttons.

**workstation.** (1) An I/O device that allows either transmission of data or the reception of data (or both) from a host system, as needed to perform a job; for example, a display station or printer. (2) A configuration of I/O equipment at which an operator works. (3) A terminal or microcomputer, usually one connected to a mainframe or network, at which a user can perform tasks.

**World Wide Web.** (WWW) (W3) (the Web) An Internet client-server distributed information and retrieval system based upon HTTP that transfers hypertext documents across a varied array of computer systems. The Web was created by the CERN High-Energy Physics Laboratories in Geneva, Switzerland in 1991. CERN boosted the Web into international prominence on the Internet.
List of Abbreviations

<table><tr><td>AIX</td><td>Advanced Interactive Executive</td><td>DDCS</td><td>distributed database connection services</td></tr><tr><td>APAR</td><td>authorized program analysis report</td><td>DDL</td><td>database definition language</td></tr><tr><td>APPC</td><td>advanced program-to-program communication</td><td>DDM</td><td>Distributed Data Management</td></tr><tr><td>APPN</td><td>advanced peer-to-peer networking</td><td>DDS</td><td>data description specifications</td></tr><tr><td>BMP</td><td>bitmap</td><td>DLL</td><td>dynamic link library</td></tr><tr><td>CAE</td><td>Client Application Enabler</td><td>DSN</td><td>data set name</td></tr><tr><td>CDROM</td><td>compact disk read only memory</td><td>DSOM</td><td>distributed system object model</td></tr><tr><td>CG</td><td>common graphics</td><td>ECS</td><td>electronic customer support</td></tr><tr><td>CGI</td><td>Common Gateway Interface</td><td>EPI</td><td>external presentation interface</td></tr><tr><td>CICS</td><td>customer information control system</td><td>ESA</td><td>enterprise systems architecture</td></tr><tr><td>CLI</td><td>call level interface</td><td>FTP</td><td>File Transfer Protocol</td></tr><tr><td>CORBA</td><td>Common Object Request Broker Architecture</td><td>GIF</td><td>graphic interchange format</td></tr><tr><td>CPI-C</td><td>common programming interface for communications</td><td>GPF</td><td>general protection fault</td></tr><tr><td>CPU</td><td>central processing unit</td><td>GUI</td><td>graphical user interface</td></tr><tr><td>CRC</td><td>class responsibility collaborators</td><td>HLLAPI</td><td>high level language application program interface</td></tr><tr><td>CUA</td><td>Common User Access</td><td>HPFS</td><td>high performance file system</td></tr><tr><td>DAP</td><td>developer assistance program</td><td>HTML</td><td>Hypertext Markup Language</td></tr><tr><td>DBA</td><td>database administrator</td><td>HTTP</td><td>Hypertext Transfer Protocol</td></tr><tr><td>DBF</td><td>database file</td><td>HTTPD</td><td>Hypertext Transfer Protocol daemon</td></tr><tr><td>DBMS</td><td>database management system</td><td>IBM</td><td>International Business Machines Corporation</td></tr><tr><td>DB2</td><td>Database 2</td><td>IDL</td><td>interface definition language</td></tr></table>
<table><tr><td>ILE</td><td>integrated language environment</td><td>OMT</td><td>object modeling technique</td></tr><tr><td>IMS</td><td>information management system</td><td>OOP</td><td>object-oriented programming</td></tr><tr><td>IPC</td><td>inter-processor communication</td><td>OOSE</td><td>object-oriented software engineering</td></tr><tr><td>IPMD</td><td>IBM presentation manager debugger</td><td>ORB</td><td>object request broker</td></tr><tr><td>ISO</td><td>International Organization for Standardization</td><td>OS</td><td>operating system</td></tr><tr><td>ISP</td><td>Internet service provider</td><td>OS/2</td><td>Operating System/2</td></tr><tr><td>ISV</td><td>independent software vendor</td><td>PCS</td><td>PC/Support</td></tr><tr><td>ITSO</td><td>International Technical Support Organization</td><td>PM</td><td>presentation manager</td></tr><tr><td>JDBC</td><td>Java Database Connectivity</td><td>PTF</td><td>program temporary fix</td></tr><tr><td>LAN</td><td>local area network</td><td>RAM</td><td>random access memory</td></tr><tr><td>LF</td><td>logical file</td><td>RDBMS</td><td>relational database management system</td></tr><tr><td>MB</td><td>megabyte</td><td>RFT</td><td>request for technology</td></tr><tr><td>MIME</td><td>Multipurpose Internet Mail Extensions</td><td>RPC</td><td>remote procedure call</td></tr><tr><td>MLE</td><td>multiline edit</td><td>RPG</td><td>report program generator</td></tr><tr><td>MQ</td><td>message queueing</td><td>SGML</td><td>standard generalized mark-up language</td></tr><tr><td>MRI</td><td>machine readable information</td><td>SHTTP</td><td>Secure Hypertext Transfer Protocol</td></tr><tr><td>MVS</td><td>multiple virtual storage</td><td>SOM</td><td>system object model</td></tr><tr><td>NLS</td><td>national language support</td><td>SQL</td><td>structured query language</td></tr><tr><td>NT</td><td>new technology</td><td>SSL</td><td>secure sockets layer</td></tr><tr><td>ODBC</td><td>Open Database Connectivity</td><td>TCP/IP</td><td>Transmission Control Protocol/Internet Protocol</td></tr><tr><td>OIDL</td><td>object interface definition language</td><td>URL</td><td>uniform resource locator</td></tr><tr><td>OLTP</td><td>on-line transaction processing</td><td>VM</td><td>virtual machine</td></tr><tr><td></td><td></td><td>VMT</td><td>visual modeling technique</td></tr><tr><td></td><td></td><td>WWW</td><td>world wide web</td></tr></table>
# Index

## Numerics

3270
cursor position Vol2:79
host presentation space Vol2:79

## A

abend, transaction Vol2:72
aborting process stack 199
aboutToExecute 207
ABTPATH 213
accelerator keys 157, 230
access set Vol2:127, Vol2:145, Vol2:169
accessing COM port 178
action
closeLibrary Vol2:98
closeWidget 25, 95
default 113
destroyPart 95
activator Vol2:199, Vol2:203
active, terminating processes 25
ActiveX 14
adding
column to table 146
container icons dynamically 126
icon to list 129
items to combo box 110
menu choices 105
records to container 120
agent class 65
AIX
calling C function Vol2:103
DB2/6000 Vol2:119
DB2/6000 binding Vol2:121
DDE Vol2:108
distributing application 252
event handler 151
moving library to 255
MQSeries Vol2:73
packaging 47
reports feature Vol2:225
simplified Chinese 267

altering behavior 40
anchor block handle 135
animated busy cursor 105
ANSI
Smalltalk
  committee 2
  standardization 166
SQL Vol2:140
Anynet Vol2:51
API
break Vol2:138
common file system 176
data queue Vol2:40
DosStartSession Vol2:84
EHNAPPC_QuerySystems Vol2:17
MQ Vol2:76
nonblocking Vol2:91
OS/2 PMs Vol2:88
router Vol2:4
system Vol2:50
APPC
AS/400 configuration Vol2:33
AS/400 connection Vol2:35, Vol2:50
ASCII work station controller Vol2:4
blocking factor Vol2:15
LU 6.2 Vol2:9
proc dialog Vol2:71
router Vol2:35
stack Vol2:51
AppletAuthor 22
application
AS/400
  native Vol2:8
  packaging Vol2:8, Vol2:21
  runtime prerequisites Vol2:9
  changing database name Vol2:174
CICS Vol2:72
COBOL Vol2:71
creating new 250
delete 249
distributing 252
edition 246
editions browser 250
application (continued)
exporting 245
exporting to non-LAN PC 252
global variables 205
importing 245
launching 203
LibraryObjects 247
loading 47, 245
merging 49
MQ sample Vol2:76
multiple windows 89
native Vol2:8
not owned 61
owner 256
packaging Vol2:57, Vol2:251
packaging distributed Vol2:212
prerequisites Vol2:22
purging 250
releasing 61
reloading current edition 249
removing 250
report packaging Vol2:230
running unattended Vol2:129
sharing data Vol2:43
sharing query Vol2:145
start execution 203
synchronizing AS/400 and VisualAge Vol2:8
unable to version 61
unloading 56
using 248
versioning 61
application prerequisites 52
ApplicationLoader 47
apply push button 38
architecture
GUI 87
layered 63
archival code 32, 34, 54, 68, 246
arguments, command line 200
array Vol2:37
AS/400
5250 screen Vol2:24
accessing VisualAge application Vol2:8
APPC Vol2:7
APPC configuration Vol2:33
asynchronous job Vol2:12
blocking factor Vol2:15

AS/400 (continued)
busy cursor Vol2:17
code page Vol2:12
commit boundary Vol2:1
communication error Vol2:2
complex data structures Vol2:37
compound key Vol2:29
configured systems Vol2:2
connecting Vol2:18
connecting to Vol2:2
connection feature, reinstalling Vol2:8
connection problem Vol2:35
data queue Vol2:34
database Vol2:11
DDM Vol2:26
DDS Vol2:31
document Vol2:50
examples Vol2:14
feature installation Vol2:23
file access part Vol2:4
fixpack problem Vol2:54
ILE Vol2:24
job description Vol2:12
job queue Vol2:59
library list Vol2:57
migrating Vol2:27
multiple connections Vol2:10
multitasking Vol2:15
native application Vol2:8
ODBC default library Vol2:45
ODBC requirements Vol2:6
OfficeVision/400 Vol2:50
opening and closing file Vol2:43
packaging application Vol2:8, Vol2:21, Vol2:22
password Vol2:18
Personal Communications Vol2:37
physical file member Vol2:11
record class Vol2:3
record description Vol2:31, Vol2:35
reestablishing connection Vol2:56
referential integrity Vol2:55
repeating record structures Vol2:37
RPC Vol2:1
RPC message Vol2:51
Rumba Vol2:10
runtime prerequisites Vol2:9
screen scraping Vol2:24
AS/400 (continued)

service program Vol2:24
sign-on Vol2:2
sign-on dialog Vol2:17
sign-on screen Vol2:44
simultaneous DDM access Vol2:39
SQL Vol2:11
stored procedure Vol2:32
synchronizing VisualAge application Vol2:8
transaction program Vol2:23
user ID Vol2:18
user profile Vol2:54
using Windows 3.1 Vol2:62
work station function Vol2:10

ASCII

EBCDIC conversion Vol2:75
reporting in file Vol2:232
work station controller Vol2:4
association, pool dictionary 193
asynchronous job Vol2:12
atom 168
attribute
  changed event 213
cursorPosition Vol2:79
LastError Vol2:72
promptForUserIdAndPassword Vol2:17
resultIsReady Vol2:1
selectionValid 156
synchronizing 45
tabContents 115
updating class 205

audio cards 85

automatic

log-off 202
tab moving 132
tabbing 132, 162

AVA playback 85

B

back-tabbing in details views 74

background

process
  continuing 201
database update Vol2:155
task, garbage collection 174

background, transparent 135
beep 101
bibliography 271, Vol2:259
bind, command syntax Vol2:117
bitmap
  click-sensitive 140
color 131
colors 139
image formats 140
on notebook tab 115
push button 161
resolution 131
bitmap on button 136
block
  creating at run-time 192
  reading from file 192
blocking factor Vol2:15, Vol2:19
broker
  file Vol2:61
  registry Vol2:33
browser
  DBCS part name Vol2:255
  progress message 156
  suppressing URL query string Vol2:253
BRW format generator 43
building visual forms Vol2:3
business
  class 208
  object
    garbage collection Vol2:112
    key alteration Vol2:112
busy cursor 100, 105
button
  activation 150
  bitmap 136, 161
disabling 106, 156, Vol2:249
dynamic 160
enabling 150
mask 159
toggle 105

C

C Vol2:89, Vol2:91, Vol2:96, Vol2:103
CA/400
  ODBC Vol2:5, Vol2:42
cache 50, Vol2:19
caching compiler 192
CAE Vol2:5
calculated field Vol2:230
call stack, trace 21
call-level interface Vol2:120
callback
  CICS ECI Vol2:104
  losing focus 56
  mouse move 157
  synchronizing table scrolling 148
calling
  convention Vol2:95, Vol2:101
  OSObjects Vol2:95
capturing
  key pressed events 230
  stack information 28
caret cursor 102
carriage return, missing 162
CAT files 50, 264, Vol2:251
catalog of classes Vol2:230
catching
  all errors 181
  errors 179
category
  class methods 67
  CLIM-API 175
  ES-Internal 172
  instance methods 66
  naming 66
CCSID Vol2:12
cell
  hover help 157
  monitor changes 149
centered, opening window 93
change management 247
changing
  label color 120
  mouse pointer 98
  object class 231
  scroll bar size 124
table
  cell 149
  format 36
  size 149

channel file Vol2:73
character
  identity 240
  replacing in string 222
  strange Vol2:3
character set translation table 44
check box, container 119
CICS
  accessing COBOL Vol2:71
  callback Vol2:104
  code page translation Vol2:73
  ECI Vol2:72, Vol2:73
  EPI Vol2:115
  EPI identification Vol2:110
  harclock Vol2:110
  literal Vol2:110
  logical unit of work Vol2:72
  LU2 identification Vol2:109
  opening proc dialog Vol2:72
  program Vol2:72
  screen scraping Vol2:111
  transaction abend Vol2:72
circular reference 97
class
  AbtAppBldrPart 208
  AbtAppBldrView 32
  AbtCompoundType 62, Vol2:98
  AbtConverter 210
  AbtDatabaseSamples Vol2:140
  AbtDateConverter 212, 219
  AbtDateParse 213
  AbtDeferredUpdatedManager 31
  AbtEditDatabaseSupport Vol2:153
  AbtError Vol2:97, Vol2:165
  AbtForeign Vol2:73
  AbtForeignRecord Vol2:73
  AbtFrameView 109
  AbtlbmCliDatabaseManager Vol2:166
  AbtlbmDatabaseConnection Vol2:167
  AbtlbmResultTable Vol2:163
  AbtIntegerConverter 219, 220
  AbtObservableObject 24
  AbtOracleLongField Vol2:130
  AbtPart 208
  AbtPointer Vol2:81
  AbtProgramStarter Vol2:84
  AbtQuerySpec Vol2:127
class (continued)
AbtRecord 62
AbtResultTable Vol2:167
AbtRowColumnView 109
AbtSampleLauncherView Vol2:140
AbtShellView 69, 155
AbtTextConverterManager 152
AbtTextView 145
AbtTimeConverter 219
agent 65
alternatives 255
AS/400 record Vol2:3
AS400APPConfiguration Vol2:33
AS400DataQueueEntry Vol2:6
AS400DirectFile Vol2:49
AS400KeyedFile Vol2:49
AS400RecordDescription Vol2:35
AS400RemoteCommand Vol2:53
AS400RemoteProcedureCall Vol2:36
AS400SequentialFile Vol2:49, Vol2:50
AS400System Vol2:18
available in library 257
BplBusinessObj Vol2:112
business 208
catalog Vol2:230
CfsDirectoryDescriptor 176
changes 255
changing 231
comparing 257
controller 65
creating from script 229
CwOverrideShell 98
damaged 251
DatabaseAccessSet Vol2:192
Date 212
date stamp 247
Delay 197
delete old version 250
DsCallbackRec Vol2:196
DsDistributedSystem Vol2:202
DsTCPCommunicator Vol2:202
DsTracer Vol2:196
DtListBuilderCollection Vol2:209
E4AS400Broker Vol2:33
E4CommunicationService Vol2:54
E4FrameWorkApp Vol2:33
E4KeyedFile Vol2:61

class (continued)
E4KeyedFiles Vol2:44
E4Service Vol2:17, Vol2:33
editions 249
EmFileOutInterface 28
EmLibraryStatistics 71, 253
ensure packaging 49
EsLinearOrderedCollection 218
EwList 223
EwTableList 224
EwTextEditPolicy 224
extending 40
extending server Vol2:215
extension 40, 49, 64
facade 65
fixed decimal 182
generating with SOM prefix Vol2:238
hierarchy 172
identification 182
instance variables 225
invisible 45
load editions 249
loaded method 44
locale 210, 264
manager 66
method 175
methods at run-time 206
missing 52
missing SOM definition Vol2:243
model 65
naming 226
naming convention 63
ObjectDumper 39, 217
ObjectLoader 39, 217
OSHab Vol2:88
OSHps Vol2:88
OSObject Vol2:81, Vol2:95
OSObjectPointer Vol2:81
OSWidget 74, 225
owner 256
packaging modifications 49
PlatformFunction Vol2:95
recompiling 169
RECORD Vol2:3, Vol2:48
released version 246
renaming 29, 31
reusing 63
class (continued)

SequencableCollection 218

SequenceableCollection 186

session Vol2:114

sharing instance across object
spaces Vol2:207

SortedCollection 218

specifying policy 57

string 186

Swapper 217

SymbolTable 226

testing 173

Time Vol2:19

unreleased 257

updating attributes 205

variable 173

variables, initializing 209

with instances, deleting 35

XPlatformAdministration 87

CLI Vol2:120, Vol2:166, Vol2:193

client

concurrent processes Vol2:39

MQ Vol2:73

OS/2 optimized Vol2:21

passing data Vol2:36

run-time access Vol2:218

socket Vol2:68

transaction abend Vol2:72

unsupported 61

Client32 83

ClientAccess/400

32-bit optimized client Vol2:7

advanced connection Vol2:59

AS/400 database Vol2:11

ODBC Vol2:45, Vol2:48, Vol2:135

ODBC driver Vol2:5

ODBC requirements Vol2:7

opening automatically Vol2:59

optimized for OS/2 Vol2:50

router Vol2:37

status Vol2:17

TCP/IP Vol2:51

user ID Vol2:17

Windows Vol2:59

cloned library 248

close option, disabling 97

closing

widget 96

window 95

CM/2 Vol2:50

AS/400 access Vol2:4

configured AS/400 systems Vol2:2

conversation security Vol2:27

optimized client Vol2:21

packaging AS/400 application Vol2:21

profile list Vol2:28

setup Vol2:18, Vol2:27

user ID Vol2:17

CM/400 Vol2:7, Vol2:50

COBOL 9, 55, Vol2:83, Vol2:98, Vol2:101

COBOL, accessing through CICS Vol2:71

code page

AS/400 Vol2:12

CICS Vol2:73

connection specification Vol2:109

conversion 75, 263, 266

missing translation table 44

MPR file 263

support 263

collection

do: 218

heap-sorted 219

interval 189

reversing 186

sorted 194, 218

color

bitmap resolution 131

changing 193

iterator header Vol2:231

label 120

wallpaper 138

column

adding to table 146

hiding 145

navigating between 117

resizeing 123

COM port, accessing 178

combo box

adding items 110

behavior 114

default action 113

selected item Vol2:62
combo box (continued)
synchronizing 109
command
  bind syntax Vol2:117
  CRTL F Vol2:31
  DSPNETA Vol2:10
  OVRDBF Vol2:43
  OVRSCOPE Vol2:43
  remote Vol2:43, Vol2:53
  STRCMTCTL Vol2:1
command line, arguments 200
commitment
  boundary Vol2:1
  control Vol2:1, Vol2:59, Vol2:75, Vol2:78, Vol2:145
common file system API 176
common widgets, reinitializing 25
communication
  AS/400 Vol2:2
  saving image Vol2:35
  static session acquisition Vol2:114
  Windows 3.1 Vol2:62
Communications Manager/2
  See CM/2
comparing
  floating point 183
  floating-point 239
compatibility 10
compile time, creating object 167
compiler
  caching 192
  incremental 191
  literal strings 227
  optimization 221
  severity level 195
  warning 195
component, moving between libraries 246
composition editor, window location 90
compound key Vol2:28
CompuServe xix, 12, Vol2:9
concatenation 237
configuration
  5250PLU Vol2:2
  VisualAge 213
configuration map
  deleting application 249
  distributed load Vol2:201

configuration map (continued)
distribution matrix Vol2:206
exporting 252, 254
loaded features 253
version control 257
configured subsystems 199
connecting
  to AS/400 Vol2:2
  to remote host Vol2:2
connection menu, customizing 33
connection, releasing 95
container
  adding icons dynamically 126
  adding records 120
  back-tabbing in details views 74
  check box 119
  column list box 119
  context menu 127
  deselecting items 121
  details tree 121
  details tree children 124
  details view 124
  hiding column 125
  hiding heading 124
  icon column 125
  nonexistent attribute 129
  object attribute 128
  OLE client 260
  refreshing 128
  refreshing details view 127
  remove items 125
  removing icon 128
  resizing columns 123
  scroll bar 124
  selecting multiple rows 150
  selection 117
  sharing menu 108
  valid objects 117
context menu 74
continuing background process 201
control widget, buffering 30
controller class 65
conversation
  security Vol2:18, Vol2:27
conversion tables Vol2:13
converting numbers 210
coordinates of hot spot 138
copy-book Vol2:101
copyright 200
CORBA 2, 64, Vol2:195, Vol2:239
CPI-C Vol2:114
creating
class from script 229
object at compile time 167
Crystal Wave 85
CTL file 80
Ctrl-click events 159
CUA compliance 10, 88
cursor
animated 105
busy 100, Vol2:17
caret 102
change pointer 98
control Vol2:179
deleting rows Vol2:163
file position Vol2:4
icon 103
position in text 131
position on 3270 terminal Vol2:79
positioning window at 90
reusing Vol2:133
 scrollable Vol2:167
stability Vol2:58
customizing connection menu 33
CwConstants 41

D

damaged class 40, 251
data
  integrity Vol2:15
  structures Vol2:37
  translation Vol2:73
data converter, error message 135
data definition specification
  See DDS
data entry part 141
data queue
  filling record Vol2:6
  passing data Vol2:36
  PTF Vol2:31
  sharing Vol2:43

data queue (continued)
synchronizing applications Vol2:8
variable length Vol2:34
data types Vol2:130
database
  access set Vol2:127, Vol2:152, Vol2:157, Vol2:169, Vol2:185, Vol2:192
  active connection Vol2:193
  ANSI SQL Vol2:140
  API methods Vol2:163
  automatic connect Vol2:148
  automatic log-on Vol2:131
  bind Vol2:147
  binding Vol2:140, Vol2:173
  blocking factor Vol2:15
  CAE/2 Vol2:145
call-level interface Vol2:120
canceling request Vol2:137
changing high-level qualifier Vol2:177
changing name Vol2:174
CLI Vol2:120, Vol2:165, Vol2:167
connect Vol2:147
connection
  error Vol2:164
  information Vol2:167
  specification Vol2:144
  status Vol2:128
  via Smalltalk code Vol2:138
conversion Vol2:137
creating table Vol2:161
current date Vol2:135
cursor Vol2:163, Vol2:167
cursor control Vol2:179
date representation Vol2:135
DB2/400 Vol2:146
DB2/6000 Vol2:145
DB2/VM Vol2:146
DBF format Vol2:171
DDCS/2 Vol2:145
disabling error messages Vol2:165
DLL Vol2:166
driver problem Vol2:175
error SQL0236W Vol2:188
feature installation Vol2:173, Vol2:181
fetch Vol2:148
forking process 197
hard-coded name Vol2:144
database (continued)
high-level qualifier Vol2:157, Vol2:177
host variable Vol2:146, Vol2:162
host variable with wild card Vol2:140
insert Vol2:160
intercepting SQLCODE 100 Vol2:184
locked row Vol2:145
log-on Vol2:148
log-on prompt Vol2:128, Vol2:129
log-on specification Vol2:139
manager Vol2:120, Vol2:151
maximum number of rows Vol2:153
migrating Vol2:165
migrating to CLI Vol2:168
migration Vol2:137
minimum run-time files Vol2:191
missing query fields Vol2:171
name Vol2:144
object-oriented Vol2:171
ODBC Vol2:148, Vol2:156
ODBC to CLI migration Vol2:168
outer join Vol2:146
override Vol2:43
portability Vol2:137
query Vol2:152
reconnecting server Vol2:120
sample Vol2:190
 scrollable cursor Vol2:167
Smalltalk access Vol2:154
stored procedure Vol2:32, Vol2:156
stored procedures Vol2:146
text Vol2:132
thread Vol2:143
transaction Vol2:14
updating 197
user feedback Vol2:155
user privilege Vol2:176
wild card Vol2:140
Windows 95 Vol2:165
date
conversion Vol2:13
converting 219
defaults 212
format 212, Vol2:135
representation Vol2:135
retrieving current Vol2:135
stamp 247

DB2/2 Vol2:5, Vol2:6, Vol2:49, Vol2:124, Vol2:125
DB2/400 Vol2:135
DB2/6000 Vol2:119, Vol2:121, Vol2:124, Vol2:140
DBCS Vol2:50, Vol2:223, Vol2:255
DDCS/2 Vol2:6, Vol2:49
DDE Vol2:108
DDM Vol2:11, Vol2:14, Vol2:16
data stream Vol2:39
keyed file Vol2:26
open file Vol2:44
opening and closing file Vol2:43
performance Vol2:26
priority Vol2:41
sharing conversation Vol2:39
simultaneous access Vol2:39
ULDRECF Vol2:27
DDS
generate records Vol2:31
record name Vol2:58
temporary generated Vol2:58
debug
C DLL Vol2:96
distributed client Vol2:219
DLL Vol2:86
source breakpoint Vol2:86
decimal
converting 210
fixed 182
point 264
default action 113
default icon 27
deferred update part 30
deleting
application 249
class with instances 35
old classes 29
parts with instances 35
dependency mechanism 34
dependent attachments, widget 97
dependents, reinitializing 25
deselecting items 121
destroying
notebook page 116
object 170
widget 95
details view
  refreshing 127
details views, back-tabbing in container 74
device, COM port 178
dialog
  box 134
  message box 89
  modal 94
  nonmodal 142
  sign-on Vol2:17

dictionary
  dependent 96
global 173
global variable 205
lookup 193
versus lookup table 234

digital video player 84
directory, contents 176

disabling
  close option 97
  methods 56
  mouse pointer 101
  notebook tab 125
  push button 106, 156

disk space 233, 261
display, retreiving resolution 92
distributed

activation Vol2:199
adding client Vol2:209
client run-time access Vol2:218
DBCS Vol2:223
debugging client Vol2:219
handling TCP/IP addresses Vol2:213
headless server Vol2:200
initialization Vol2:202
loading feature Vol2:217
modifying server Vol2:209
name server Vol2:201
packaging Vol2:200, Vol2:212
port number Vol2:221
run-time startup Vol2:218
security error Vol2:199
seeing data moving Vol2:203
SOM/DSOM implementation Vol2:211
startup delay Vol2:212
testing for TCP/IP Vol2:202
threads Vol2:208

distributed (continued)
  tracing Vol2:195
  transaction management Vol2:217
  unloading feature Vol2:223
  Windows 95 server Vol2:222
  Windows for Workgroups Vol2:202
Distributed Data Management
  See DDM
distributing application 252
distribution fees 9
distribution matrix Vol2:196, Vol2:201, Vol2:206, Vol2:210

DLL
  allocating memory Vol2:96
  available platform function Vol2:96
closing 55, Vol2:98
debugging Vol2:86, Vol2:96
freeing Vol2:83
IPMD Vol2:86
LIBPATH Vol2:83
locking Vol2:98
memory leak Vol2:96
Oracle Vol2:122
passing complex structure Vol2:98
source breakpoint Vol2:86
unable to replace Vol2:83

document, OfficeVision/400 Vol2:50
double-byte character set 267
double-triggering of event 213

drag and drop
  list box 110
drag-and-drop
  link 138
  on push button 144
  porting 129

DRDA Vol2:5
driver
  audio 85
dBase Vol2:128
Jet Vol2:127
Microsoft Access Vol2:123
ODBC Vol2:123
ODBC license Vol2:191
text Vol2:132

DSOM
  accessing object Vol2:241
daemon Vol2:240
DSOM (continued)

ending VisualAge Vol2:241

hanging system Vol2:239

synchronous call Vol2:240

dynamic

menu 105, 107

push button 160

where clause Vol2:125, Vol2:147

dynamic link library

See DDL

E

EBCDIC, ASCII conversion Vol2:75

ECI Vol2:72

edition

date stamp 247

loading previous 249

reloading current 249

timestamp 247

EHLLAPI Vol2:21, Vol2:80

EMSRV 47, 82, 84, 252, 256

emulation

5250 Vol2:21

encapsulation 65

environment variable 29, Vol2:241

ENVY 2, 4, 7, 243

ENVY/400 Vol2:49

ENVY/Manager 257

EPI Vol2:115

equality 184, 221, 226, 240

error

126 connecting to Oracle Vol2:122

30081n Vol2:120

Abt.154e Vol2:83

ABT.SQL.9.w Vol2:152

AS/400 communication Vol2:2

attribute does not exist 129

block Vol2:142

bypassing prompter Vol2:142

catching 179

catching all 181, 228

CfsError Vol2:8

client not authorized Vol2:214

code 1 Vol2:124

database connection Vol2:164

disabling message Vol2:165

error (continued)

distributed load Vol2:201

file in use 43

file system 180

MCH0802 Vol2:34

NetBIOS Vol2:70

opening proc dialog Vol2:72

ORA-00942 Vol2:177

primitive 73, Vol2:97

readAll method Vol2:44

return code 72

saving part 69

security Vol2:199

somFindClass Vol2:243

SQL0236W Vol2:188

SQL0805N Vol2:173

SQLSTATE 37000 Vol2:123

SQLSTATE S1010 Vol2:124

successor uniqueness violation Vol2:109

swapper 198

SYS317x 72

TCP/IP startup Vol2:210

terminating SOM Vol2:241

time-out Vol2:111

transaction abend Vol2:72

turning off message 135

user input 133

Win32s Vol2:226

error message

displaying 36

explanation 68

escaping infinite loop 27

Ethernet Vol2:10

EtWorkspace 48

event

aboutToOpenWidget 93, 110

changed 213

Ctrl key and click 159

defaultActionRequested 70

double-triggering 213

errorOccurred Vol2:72

gettingFocus 102

handler

enter key 153

function key 143

keyboard 142, 159, 230

platform 151
event (continued)

itemChildrenRequested Vol2:62

itemCollapsed 259

itemExpanded 259

key pressed 230

losingFocus 102

not trappable 230

profiler 21

registered 260

registering 225

resized 96

selectedIndexChanged 110

selectedItemsChanged 117

selectionChanged 105, 106

triggering 44

userInputConvertError 133

userModified 141

EwDropCallbackData 144

exception

doesNotUnderstand 228

process stack 199

exception handling

catching errors 179

code 182

database code Vol2:119

debugging DLL Vol2:86

doesNotUnderstand 228

object space connection Vol2:196

open file 208

SOM Vol2:239

transaction abend Vol2:72

unique key Vol2:46

exit dialog message box 89

Explorer 260

exporting

application 245

configuration map 254

pool dictionary 254

extending

classes 40

pop-up menu 57

F

facade class 65

fatal errors 36

fault tolerance Vol2:211, Vol2:220

feature

AIX reports Vol2:225

DAT file 253

loading 80

unloading 82, Vol2:223, Vol2:254

field

break Vol2:230

calculated Vol2:230

dynamically adding to report Vol2:233

iterator Vol2:226

literal Vol2:109

unprinted Vol2:232

watch Vol2:230

FIFO Vol2:36

file

access mode Vol2:46

access part Vol2:4, Vol2:60

agent Vol2:61

AS4RTE20.MRI Vol2:44

blocking factor Vol2:15

broker Vol2:61

closing 208

commitment control Vol2:59

compound key Vol2:28

DDM Vol2:26

direct Vol2:26

existence 177

handle 208

handle limits on UNIX Vol2:224

in use error 43

join Vol2:48

keyed Vol2:26, Vol2:29, Vol2:60

library list Vol2:57

locking Vol2:45

logical record format Vol2:47

macro Vol2:113

member Vol2:11

opening and closing Vol2:43

physical Vol2:11, Vol2:14

read next Vol2:4

read previous Vol2:4

real library Vol2:61

record cache Vol2:19

record description Vol2:31

removing handles 208

sequential Vol2:26
file (continued)
  sharing Vol2:24
  sharing field names Vol2:47
  simultaneous DDM access Vol2:39
  system 176
  system, error 180
  unique key Vol2:46
  UNIX Vol2:224
file-in 28
file-out 28
filing out classes 29
final form text Vol2:50
finalization 201
finding mouse pointer location 102
fixed character field Vol2:141
fixed decimal class 182
fixed object space 219
fixes Vol2:9
flat file 247
flips 211
floating point
  behavior 182
  comparing 183
  decimal 264
  rounding 182
  subtracting 183
floating window 98
floating-point
  comparing values 239
focus
  setting 162
  widget 136
folder, shared Vol2:4
font, scaled Vol2:233
forcing packager 47
forking
  background process 197
  database read Vol2:15
form
  checker 118
  data Vol2:250
  printing 152
  reusable 140
formatting string 173
FoxPro Vol2:127

fractions 182
freeing up resources 24
function key 143, 163

## G

gadgets, icon 107
garbage collection
  business object Vol2:112
  fixed object 219
  forcing 174, 216
  instances 211
  object finalization 171
  protection 219
  rate 174
  removing dependents Vol2:33
  weak pointer 170
general protection fault 73
generating
  archival code 246
  OLE methods 260
getters and setters, generating 54
ghosts 26
GIF, on Web page Vol2:250
global variable 172, 205
graphical label, push buttons 32
graphics, priority 209
grid part 20
grouping methods 66
GUI
  architecture 87
  wrapper Vol2:25

## H

heading, hiding 124
headless server Vol2:200
help, setting 141
hiding
  container column 125
  heading on container details view 124
  notebook page 116
  table column 145
  visual objects 158
hierarchical break Vol2:235
high-level qualifier Vol2:157, Vol2:177
HLLAPI Vol2:80, Vol2:111, Vol2:114

host

3270 emulator Vol2:79

passing data Vol2:36

presentation space Vol2:79, Vol2:80

server program Vol2:36

services Vol2:12

transaction interface Vol2:113

variable Vol2:42, Vol2:127, Vol2:140, Vol2:146,
Vol2:162

ODBC, driver Vol2:42

hot spot

border 138

coordinates 138

image 140

reshaping 138

hover help

behavior 198

push buttons 32

widgets 157

HP printer Vol2:233

HTML

form Vol2:249

form data Vol2:250

image Vol2:250

links Vol2:252

literal text Vol2:252

session data Vol2:252

I

ICAPI 20

icon

adding dynamically to container 126

adding to list 129

as cursor 103

DLL 48

gadgets 107

in container column 125

missing 50

missing after packaging 50

moving 152

on menu 108

push button 157

removing from container 125, 128

VisualAge 70

identical users 256

identity 221, 226, 240

ILE Vol2:24

image

backup copy 24

base 23

calling from OS/2 Vol2:91

CAT files 264

cleaning 23

cleared cache 50

click-sensitive 140

closing windows 95

component 15

component, packaging 75

concurrently running 83

connecting to cloned library 248

copyright 200

creating 23

disconnecting remote Vol2:209

exiting 199

finding remote object space

pointers Vol2:219

formats 140

growing after packaging 26

hot spot 138

live updating 33

loading different 30

memory allocation 39

merging applications 49

missing class 52

owner 251

package size Vol2:22

packaged 46

packaging prerequisites 52

preventing growth 25

rebind strings 75

reduced runtime 47, 78

reducing size 23, 25, 232

remote Vol2:209

remote object space pointers Vol2:219

required .CAT files 50

run-time 200, 205, 264

saving Vol2:35

saving before packaging 26, 50

size 24, 48, 54

stock 47, 50

synchronizing 243
image (continued)

update 249
using iterator field break Vol2:226
using phantom instance variables Vol2:113
virgin 23
wallpaper 138

immutable object 240

importing application 245

IMS

communication Vol2:114
harclock Vol2:110
LU2 identification Vol2:109
screen scraping Vol2:111
stacked processing Vol2:114
transaction modeling Vol2:112

in-place activation 260

in-progress window 155

inactivity, log-off 202

including classes in package 46

incremental compiler 191

indexed message editor 62

inetd Vol2:73

infinite loop 27

Informix 8

inheritance

RECORD subclass Vol2:48
script 204
visual class 215
visual part 204

inherited message 175

inhibiting list selection 223

initializing class variables 209

input

error 133
validating 118

inspector

opening 38
performance Vol2:19

installation, AS/400 Connection Vol2:23

installing feature 253

instance

equality 226
garbage collection 211
identity 226
phantom variables Vol2:113
removing Vol2:209
sharing across object spaces Vol2:207

instance (continued)

testing 173

integer

as key 235
hash 235
internal representation 216
small 241

intercepting key stroke Vol2:80

interface repository Vol2:243

Internet

ITSO xvii

interrupting infinite loop 28

interval

reverse 190
to: method 189

invisible part 45

INZPFM Vol2:26

IPMD Vol2:86

IRDUMP Vol2:243

ISAPI 20

iterating over widgets 94

iterator

field break Vol2:226
header, color Vol2:231

ITSO

feedback xviii
FTP server xviii
Internet xvii
redbooks home page xvii
World Wide Web xvii

J

Java beans 22

job

asynchronous Vol2:12
DDM requests Vol2:43
description Vol2:12
library list Vol2:57
log Vol2:53
queue Vol2:59
sharing data Vol2:43
unspecified key Vol2:63

join, outer Vol2:146

JPEG support 20
K

key

accelerator 157
alteration Vol2:112
compound Vol2:28
Ctrl 159
dictionary 234
function 163
intercepting stroke Vol2:80
lookup table 234
partial Vol2:29
pressed event 230
release 134
simple Vol2:29
specifying Vol2:29
unique Vol2:46
unspecified Vol2:63

keyboard

event handler 230
foreign characters 265
handling 159
input 141

L

label

changing color 120
multiline text 130

LAN

LAN Server/400 Vol2:7
OS/2 LAN Server Vol2:7

last selected item 112
launching application 203
legacy code 9
library

access 84
available classes 257
cloned 248
closing DLL Vol2:98
consistency 253
corruption 83
deleting application 249
ENVY/Manager 257
growth rate 254
importing application 245
list Vol2:57

library (continued)

manager 249
moving
  code 251
  components 246
to AIX 255
object space Vol2:212
password protection 244
protecting 244
remote access 243
reuse 244
shared folder Vol2:4
single-user mode Vol2:23
LIFO Vol2:36
limiting lines in MLE 156
link 138
list
  adding icon 129
  widget 223
list box
  behavior 112
  container column 119
  drag-and-drop 110, 144
  scrolling 112
literal
  field Vol2:109
  string 221
  strings 227
  text Vol2:252
loading
  application 245
  application in run-time image 47
different image 30
feature 253
variable references 198
local log-on Vol2:131
locale 264
locating widget focus 136
location
  mouse pointer 102
  reference Vol2:196
  window 90
lock, releasing 83
locking
  compatibility Vol2:128
  file Vol2:45
  row Vol2:145
locking (continued)
scheme Vol2:128
log-off, automatic 202
logical
file Vol2:48
record format Vol2:47
unit of work Vol2:72, Vol2:78
long field Vol2:130
lookup table, using 234
looping walkback 56
LU 6.2 Vol2:109

M

macro file Vol2:113
manager
class 66
cloning 250
consistency 253
growth rate 254
size 250
managing network traffic Vol2:211
mapping widgets across systems 87
marshaling Vol2:216
maturity VisualAge 2
maximized window, opening 92
maximizing window 91
MCH0802 Vol2:34
member, physical file Vol2:11
memory
allocation 39
garbage collection 174
invalid location 73
leak Vol2:96
menu
accelerator key 157
adding choices 105
disabling button 106
dynamic 105
for icon gadgets 107
icon 108
on Windows NT 74
reusable 108
sharing 108
toggle button 105
merging applications 49

message
box, exit dialog 89
CPF503A Vol2:55
descriptor Vol2:74
inherited 175
misspelled Vol2:110
MQ Vol2:74
prompter, labels 139
transcript logging Vol2:205
wmUser 224
method Vol2:26, Vol2:27
## 167
= 221
= = 221
abeReinitializeDependents 24
aboutToChangeSelection 223
abrWithoutWhitespace 223
abtAddress Vol2:97
abtBuildInternals 32, Vol2:111
abtExternalizedStringBuildingInfo 263
abtPadWith:upToLength:onRight: 223
abtScanEnv 29, 213
abtScrubImage 24, 25, 211, 216
abtShowBusyCursorWhile Vol2:18
abtSignal Vol2:70
abtWait Vol2:70
activeProcess 196
allInstances 211
allMethodsReferencingLiteral: 232
allUserTableNamesIfError Vol2:170
apply 38
asDate 219
asInteger 219
asPointer Vol2:97
asTime 219
at:put: 222
availableSystemNames Vol2:34
avoiding standard names 46
basicAllInstances 56
become 187
become: 211
bindWith 173
blockingFactor Vol2:19
break Vol2:138
calculateInterfaceSpec 68
calculatePartBuilder 68
closeWidget 158
method (continued)
closeWidgetCommand 97
commandLine 200
commitUnitOfWork Vol2:145
connectionInfo Vol2:167
containing string 232
contextAtFrame: 196
convertToCodePage Vol2:76
copy 222
copyright 200
deepCopy 172
defaultActionRequested 153
deleteRow Vol2:142
destroyPart Vol2:249
disabling 56
do: 218
elements: 194
equals:to: 182
eventTableAt:put: 225
exceptionOccurred Vol2:46
execLongOperationazi message: 155
executeQueryAsTransaction Vol2:145
fileExists 178
finalInitialize 90
for:do:ifError: Vol2:167
forMutualExclusion Vol2:16
getDiskFreeSpace 233, 261
getQuerySpecNamed: Vol2:153
grabPointer 101
grouping 66
includedMethods 53
initialize 168
initializeWhereClause Vol2:125
initializeWidgetClasses 87
installToBeLoadedCode 254
interceptEvents: 230
interface specification Vol2:71
invokeAsynchronous Vol2:1, Vol2:12, Vol2:40
isRuntime 201
loaded 44, 263
makeFixed 219
makeWeak 170
maximumNumberRows Vol2:153
methodAtFrame: 196
millisecondsToRun Vol2:19
new 175
newRow Vol2:142

method (continued)
normalizeYear: 213
numberOfFrames 196
OLE, generating 260
openReadOnly Vol2:15, Vol2:19, Vol2:58
openReadWrite Vol2:15, Vol2:19
openWidget 158
packagerIncludeClasses 47
packagerIncludeClassNames 49, 53
packagerInclude selectors 49, Vol2:200
packagingRulesFor: 50
packagingRulesFor: 52
platformWidgetClass 87
platformWidgetGadget 87
postCreationInitialization 70
preferredConnectionFeatures 33
prePackagingActionsFor Vol2:22, Vol2:33
primCommitUserInput: 152
printHex 186
printNumber: on: 265
printString 210
printStringWidth 183
prompt 94
readAll Vol2:14, Vol2:41, Vol2:44
readAt Vol2:28
readNext Vol2:27
readNextKey Vol2:26
receiverAtFrame: 196
reconfigureAllSystems Vol2:27
registerLogonSpec: Vol2:139
removeFromParentPart Vol2:249
reSort 194
reverse 186, 190
rowsAsStrings Vol2:182
selectionPolicy: 223
sender context 196
sender signature 195
setGridLineStyleAndColor 36
setPosition 93
setSensitive: 106
showBusyCursor 100
showBusyCursorWhile: 100, Vol2:18
shutdownAll Vol2:33
signOff Vol2:34
size limit Vol2:111
sorted: 194
species 194
method (continued)
startUp Vol2:33
syncExecInUI: 193
to: 189
toBeLoadedCode 209, 254, Vol2:74
trace call stack 21
trimBlanks 223
unloaded 264
updateWidget 191, 193
useDashedLines 36
value 172
visibility 175
wasRemovedCode 254
widgetUnderCursor 102
windowProc:with:with: 225
method tracing 216
migration
DB2/2 Vol2:125
minimizing window 94
minimum window size 96
missing
archival code 68
carriage return 162
icons 50
method 53
modal dialog 94
model class 65
modifying system menu 41
Motif
documentation 88
widget 87
XKCancel 135
mouse
click with Ctrl key 159
cursor position 102
dragging 108
pointer
changing 98
location 102
moving
classes 29
icons 152
MPR files Vol2:251
MQ
client Vol2:73
commitment control Vol2:78
connection problem Vol2:78

MQ (continued)
EBCDIC conversion Vol2:75
logical unit of work Vol2:78
reading message Vol2:74
sample application Vol2:76
syncpoint processing Vol2:75
MQ client code Vol2:79
MQSeries, AIX Vol2:73
MRI file 63
multiline edit part
limiting lines 156
missing CR 162
parsing text 144
tab order 143
typed words 144
multiline edit window 144
multiline text 130
multimedia
example 38
opening device 84
multiple
AS/400 connections Vol2:10
inheritance 10
rows, selecting 150
select list 112
windows, application 89
multirow query Vol2:133, Vol2:231
multitasking Vol2:15
multithreading 28, 204
mutable object 241
MWave 85

N

name server
changing entries Vol2:211
persistent Vol2:213
named pipe Vol2:91
naming convention 63, 174
national language support
See NLS
navigating between columns 117
NetBIOS
asynchronous function Vol2:71
dictionary Vol2:70
random errors Vol2:70
Netware
client 84
server 84
network
managing traffic Vol2:211
node Vol2:10
NFS drive 82
NLS
decimals 210
double-byte character set 267
multiple languages 265
report writer default fonts Vol2:229
search path 266
nonmodal dialog 142
nonvisual part 208
notebook
advancing pages 114
 bitmap on tab 115
destroying page 116
disabling tab 125
hiding page 116
migrating 117
portable 117
porting across platforms 117
settings view 75
skipping through 114
tab contents 115
turning pages 114
validating input 118
Novell 83, 257
NSAPI 20
number
converting 210
floating point 182
precision 183
rounding 182

O

object
changing class 231
class identification 182
copying between spaces Vol2:198
creating at compile time 167
creation 174
destroying 170
dumper 39, 247, Vol2:229

object (continued)
finalization 171
identity 226, 240
immutable 240
list part Vol2:59
loader 39
long-living 219
marshaling Vol2:216
memory 187
mutable 241
partitioning Vol2:216
peer-to-peer communication Vol2:207
primitive 217
printer Vol2:229
read-only 227
reference 206
remote Vol2:197
sending as parameter Vol2:208
sending message to client image Vol2:203
SOM Vol2:240
space Vol2:198
surviving flips 211
table 187
traffic 21
transaction Vol2:110
undefined 69, Vol2:2
visualizer 21
writing to file 217

object linking and embedding

See OLE

object space

activator Vol2:203
connecting to different libraries Vol2:202
connection close Vol2:196
different libraries Vol2:212
duplicating Vol2:214
extending server class Vol2:215
fault tolerance Vol2:211
finding remote pointers Vol2:219
initial connection Vol2:203
moving parameters Vol2:215
partitioning object Vol2:216
performance Vol2:216
profiling Vol2:203
security files Vol2:222
sharing class instances Vol2:207
object-oriented database Vol2:171
ODBC
  administrator Vol2:135
  AS/400 access Vol2:5
  AS/400 database Vol2:11
  blocking Vol2:172
  ClientAccess/400 Vol2:45, Vol2:48
  create view Vol2:32
  data source Vol2:135
  data source name Vol2:191
  DB2/400 Vol2:135
  DBF format Vol2:171
  default library Vol2:45
  description Vol2:175
  driver manager Vol2:48
  file access part Vol2:60
  host variable Vol2:42
  keywords Vol2:157
  license Vol2:191
  log-on Vol2:128
  ODBC.INI Vol2:45, Vol2:157
  OS/2 Vol2:134
  parameter marker Vol2:42
  parameters Vol2:157
  PC Support Vol2:48
  requirements Vol2:7
  SQLSTATE 37000 Vol2:123
  SQLSTATE S1010 Vol2:124
  stored procedure Vol2:32, Vol2:193
  text driver Vol2:132
  TopLink Vol2:118
ODBC.INI Vol2:45
ODBCADM Vol2:134
OfficeVision/400 Vol2:50
OLE
  class generator 260
  client 260
  generating methods 260
  sharing objects 260
open database connectivity
  See ODBC
opening
  inspector 38
  multimedia device 84
  window centered 93
  window maximized 92

openness VisualAge 3
operating system, registering event 225
optimized 32-bit client Vol2:7
Oracle
  blocking Vol2:172
  break API Vol2:138
  connection Vol2:122
  data types Vol2:130
  DLL Vol2:122
  driver Vol2:175
  error 126 Vol2:122
  error ORA-00942 Vol2:177
organizer
  preferences 75
  views 42
OS/2
  AS/400 access through CM/2 Vol2:4
calling image from Vol2:91
calling PM API functions Vol2:88
code page conversion 266
distributing application 252
drag-and-drop 129
event handler 151
LAN Server Vol2:7
LIBPATH Vol2:83
maximize window 91
memory leak Vol2:96
MQ Vol2:79
MQSeries Vol2:75
multithreading 204
notebook 116, 117
ODBC Vol2:134
optimized client Vol2:21
PM API Vol2:88
session manager Vol2:84
shutdown 43
SOM object Vol2:246
swap file Vol2:96
task list 131
thread Vol2:143
Warp client 84
workplace shell Vol2:247
OS/400
  host servers Vol2:23
  host services Vol2:12