Before proceeding, it might be a good idea to review the three paragraphs beginning with . These discuss the various parts of a file name. 2A1

Think carefully before you assign a name to a new file. This may seem silly, but in fact, it is one of the most important things you can do to keep your files in order. The name you give a file should tell as much about the file as possible, and should remind you of its contents even if you have not looked at them for months. After a few months, it is not so easy to remember what the differences are between TOM1, TOM2, ..., TOM20. 2A2

It is also a good idea to try to make the names differ in the first few characters, rather than in the last ones. This is because the <ESC> key may be used for file name recognition as soon as enough text is typed to completely distinguish a name from any others. See also the section on <ESC>: <0243>. 2A3

If you have a number of similar files, in which the only difference in content is a date, or a customer name, or whatever, be sure to include that date or name in the file name. Examples might be: SEP79-ACCTS, AUG80-ACCTS, BLUM-INVENTORY, MILLER-INVENTORY, and so on. 2A4

In spite of your best intentions, you will occasionally find that you gave a file the wrong name and you would like to change it. One way to do so is to use the command "Update (file) Renamed newname<OK>". It works as follows: 2A5

Another way to rename a file is to use the Rename command: Rename (file named) oldname<OK> (to be named) newname<OK>. It just renames your file along with any existing modifications, without doing any updating. 2A6

Almost all of the commands in AUGMENT that refer to a file have the following feature: You are asked in the command for a name of a file, and you can either type the name or, if it is the file that happens to be on your screen at the time, simply type <OK>. The prompt is "OK/T/[M/A]:". "OK" means type <OK> for this file, and "T" means type the name of the file; you must type if you want to mark or give the address of a file name. 2B1

If you have your screen broken into two or more file windows, then you must be sure that your cursor is in the window containing the appropriate file when you type the <OK> indicating "this file". (Breaking your screen into more than one file window is discussed later; see <023>.) 2B2

If you worked with older versions of AUGMENT, what this means is that you do not have to jump to a file before you print it or check its internal structure for consistency. 2B3

The Show Directory command has been discussed elsewhere (), but remember that it is available at any time to present a list of the files resident in your (or in someone else's) directory. 2C1

There is another command, "Copy Directory", which gives exactly the same information as the Show Directory command, except that the information is actually entered in your file as text that may be edited, deleted, and so on. Remember that this option is available. Sometimes, users find it useful to have their directory presented as the first thing they see in their initial file when they enter AUGMENT. The file names are displayed as links and can be marked using the Jump (to) Link command (see <0473>). 2C2

The two commands just discussed actually offer a large number of choices. Try the Show Directory command now, and notice that after you have typed the <OK> to indicate that you want to see your own directory, you are presented with the prompt "OK/C:". The <OK> just says to show the file names, with no additional information. Type a question mark, and you will notice that there are, in fact, a large number of choices available for other information that can be displayed about each file. Such things as the protection, the dates and times of the last write, and many others can be displayed. Rather than going into detail about all of them, why don't you just try some of them out? Also, see <01536>. 2C3

This command is extremely useful. It tells many important things about the file at a glance. Try it now, and look over the information. 2D1

First you find out whether the file is being modified, and if so, by whom. 2D2

Next, the default directory for links is presented. This means that if a link is entered as text, and marked in the Jump (to) Link command, and if it points to another file, that file will be assumed to be in the directory which is the default directory for links. You probably want to have this be your directory in most cases, but there are times (usually for user documentation) when you want something else. See also <01222>. 2D3

Next, you find out when the file was last updated (creation date for this version), and you find out some information about the size of the file, including the number of statements and the number of pages used (to find out what a page is, see <0357>). Finally, since AUGMENT files can have holes in them, you are shown the percentage of the available space you have used. If this number is low, you will be advised to do an "Update Compact" (see <0467>) to attempt to remedy the problem. 2D4

Storage space on the computer comes in chunks called "pages". One computer page has (for the technically minded) exactly 512 36-bit words. This is equivalent to 2560 characters, or approximately the amount of information that can be typed on an "average" 8 1/2 by 11 inch double-spaced sheet. This last statement is, of course, not precise, but it is a good rule of thumb. 2E1

It is impossible to be assigned less than a whole page by the computer. If your file had only one character in it, a whole page would be assigned, and you would pay for the whole thing. Consequently, when AUGMENT files get holes in them (see Update Compact <0467>), it is a good idea to compress them. 2E2

Each directory has an allocation, or a number of pages allowed. If you use more pages than this allocation, you will probably have to pay extra for them. It is a good idea to get rid of any files that are junk, by deleting them, and to archive files (see <0352>) that you will not need for a while. 2E3

To find out about your total disk usage, use the command "Show Disk (space for) Directory <OK>". Try this now. It is different from the "Show Status (for file)" command in that it shows the total usage of all the files in your directory. 2E4

At present, this is done using the Executive Archive and Interrogate commands. 2F1

In other places in these tutor files, reference has been made to the fact that at any point, all of the changes you have made to a file since the last update are not "permanent", in the sense that you can delete them and get back to the condition of the file as of the last update. 2G1

The command to get rid of the modifications is "Delete Modifications". If you accidentally delete the modifications, and want to restore them, there is another command, "Undelete Modifications", that can be issued, but you must do so before you log out, before you expunge your directory, and before any automatic system expunges take place. 2G2

The mechanism is as follows: The file that you see on your screen can in fact be a combination of two files. One is the original file as of the last update; the other is called a "modifications file", and represents all the modifications that have been made to the original file. The original file knows nothing about the modifications, except that there are some. Whenever any text is to be displayed on the screen, both the original file and the modifications file are checked to see which one contains the newest information. Deleting modifications simply amounts to deleting the modifications file and marking the original file as being unmodified. The deleted modifications file is just like any other deleted file, and will disappear during an expunge operation. 2G3

In AUGMENT, when you show your directory, the existence of a modifications file shows up only as a message "[ Being Modified By SMITH (JOHN) ]". AUGMENT knows about the relationship between a file and its modifications, and never makes a mistake. If you are working from the Executive level, it is possible to err, since the Executive considers the two files to be completely different. In the Executive, the name of the updated version might be FILE-NAME.AUG;16, and the name of a corresponding modifications might be $SMITH$FILE-NAME.PC;16. The extension "PC" comes from the old name for the modifications file, which was "partial copy". 2G4

The reasons for modifications files are many. Some of the more important reasons include: 2G5

Needless to say, there are some problems that arise because of this, and they are described below: 2G6

For an elementary discussion of the Update command, see . 2H1

All of the Update commands are methods of merging the modifications file with the main file. There are four types of Update commands, and they have slightly different uses. They are: 2H2

Sometimes when you are dealing with a file, editing does not seem to work properly, and you may get an error message like "Bad statement identifier", or "blah blah blah -- file may be bad". At this point, you should issue the command "Check File (structure for internal consistency for file) <OK>". This will check through the structure of the file and make sure that it is OK. If not, a message "Bad File" will appear. If everything is OK, you will get a message like "Successful -- internal structure is OK". If you are a beginner, and you get the former message, don't do anything else with the file; call your representative or Feedback for help. If you are more advanced and want to try to fix it, read on. 2I1

Files can go bad because of a number of things. The most common include a system crash while doing an update, problems with an experimental program, and disk read errors, though there are others. Almost always, the error will be in a file opened for writing; consequently, it is almost always the modifications file that is bad, unless you are in the middle of an update when something wrong happens. If you have not done too much work since your last update, you can probably just delete the modifications, and everything will be OK. This should be another encouragement to update often, and to check your file often. 2I2

Another thing that often fixes bad files is an "Update Compact". This causes the file to be physically moved to another point on the disk, and sometimes this action magically fixes a bad file. You can try this second. 2I3

If this fails, you may have a very bad file. There are a number of courses open to you that you can try. The more experience you have, the better luck you will have at fixing the file. Try such things as copying chunks out of the file to a new file, and verifying the new file after each copy. If the file goes bad, delete the modifications, and repeat the procedure, copying smaller pieces of the file. Continue until you have gotten everything that you can. Often, there will be one bad statement, and you will not be able to get to statements beyond that statement using the usual Jump to statement number commands. Jump to SID and Jump to Name will sometimes get you past the bad statement. 2I4

You can sometimes find out the exact statement where the file went bad by printing the file. The print will fail on the bad statement. 2I5

Another alternative is to do an "Create Sequential" with viewspec "y" on, and then a "Create Augment" to a new file, using Two returns between statements. (Create Sequential and Create Augment are described in <01496> and <01327>, respectively.) 2I6

Sometimes nothing you can do will help, and you must go back to a previous version. Check this file, and if it is good, do an Update Renamed to a version number higher than the bad file. If the backup version is bad, you may have to go back to a dump tape. If the file is very important, call your Tymshare representative for help, or contact Feedback. 2I7

As is stated elsewhere in this file, AUGMENT files are not organized sequentially; new statements are just stuffed in anywhere, and pointers are used to show how to get from one statement to the next. 2I8

If the pointers get fouled up, AUGMENT may not be able to find the next statement, and a bad file results. In this case, a large portion of the file may be lost (unless it can be accessed via SIDs or statement names, which are not done with pointers). Sometimes, only a pointer to some text is lost, in which case only the text of the statement may be lost. The more you know about the internal structure of AUGMENT files, the better the chance that you will be able to fix a bad one. There is a good discussion of AUGMENT file structure in the programmer's guide, , which you might be interested in looking at if you are an experienced computer programmer. 2I9

Occasionally, no matter how good you are, you will make a mistake, and delete a file that you did not want to. If you merely delete it, you can undelete it, if you have not yet used the Expunge command or logged out. Sometimes, however, you will not give the Undelete command soon enough, and the file will be gone. You have the following options: (1) You can go to your backup version, if you simply deleted the highest version of your file. This will let you go back to the state of the file two updates ago. (2) Every night, a "dump tape" is made, and all the information on the computer is saved on temporary tapes. You can ask to have your file restored from these tapes. Contact Feedback, and include as much of the following information as possible: The full file name and version number; the last date it was known to be there; whether the file was being modified. You will lose any work done during the day, but this is usually a lot better than nothing. Let us know as soon as possible -- the dump tapes are kept for only a month or so. 2J1

In the Delete File command, a whole class of files can be referred to by using an asterisk instead of a part of the file name. For example, "Delete File (named) test.*<OK> <OK>" would delete TEST.AUG, TEST.TXT, TEST.REL, etc. "Delete File (named) *.txt<OK> <OK>" will delete all your files with extension TXT. To undelete all deleted files, you might do "Undelete File (named) *.*<OK>". 2K1

The "*" wild card can be used when describing the version number as well. 2K2

At this point, you know of two ways to change your viewspecs: You can use the "Set Viewspecs" command, or you can type viewspecs in response to the "V:" prompt that appears in most of the "Jump" commands. Often, you don't want to go anywhere, but you would like to make a quick change in the viewspecs. This can be done using the mouse. Hold down the left and middle mouse buttons, and type all the new viewspecs that you would like to take effect. When you are done, type one more special viewspec (still holding down the two buttons). The special viewspec is "f". 3A1

Try this now, perhaps turning on (or off) numbers, blank lines, etc. Remember the final "f". 3A2

The reason that a final "f" viewspec is required is to let AUGMENT know that you are finished typing the viewspecs. The idea is that you often want to change more than one viewspec at a time, and it would be quite annoying if you had to watch the screen refresh each time a new viewspec was typed. The "f" (or "F") viewspec signals the end of a sequence of viewspecs typed using the mouse buttons. 3A3

The left and middle mouse buttons designate lowercase viewspecs. If all three mouse buttons are held down while a character is typed, the character will be interpreted as an uppercase viewspec. Try turning on (or off) SIDs using only the mouse buttons and not the shift key. 3A4

Often, when you are first entering information into a file, you will find it inconvenient to have to type "is" (for "Insert Statement") before typing in each new paragraph. What you would like is a method by which you could enter paragraph after paragraph, each following the last one. AUGMENT allows for this with what is known as "insert mode". 3B1

Insert mode can be entered by pressing the INSERT key on your AUGMENT 1200 terminal. From that point on, you need only type paragraph after paragraph, and each will be inserted in succession. Before you type each such paragraph, you may give a level adjustment, which will indicate the level of the paragraph about to be typed (relative to the last one typed). To get out of insert mode, just use a command delete as usual. 3B2

There is really only one question: Where does the first statement go? The answer to this is approximately the following: It goes after the last statement you "touched". Touching includes such things as jumping to or editing. It is a complicated concept to define in the case of a move or transposition, however. In any case, if you have no idea which statement you last touched, touch one, perhaps by using the "Insert Statement" command once. In other words, insert the first statement of the series in the usual way, and then just after you have finished, press the INSERT key, and you are off. (For experts: This can be done by simply pressing the INSERT key instead of typing <OK> at the end of the first Insert Statement command). 3B3

Go ahead now, and try to insert a few (short) statements following this one. Remember that if this statement is not at the top of your screen, it is probably not the last statement you touched. 3B4

The discussion of which statement you last touched may seem a little strange, but it makes a lot more sense when thought of in the context of using AUGMENT in typewriter mode. In that mode, it is extremely important to know exactly where you are, as all the editing commands will occur there unless you specify otherwise. 3B5

Any AUGMENT command may be repeated simply by pressing the REPEAT CMD key at the end of it. All command words up until the user needs to specify some content or a MARK or address are automatically repeated, and continue to repeat until the CMD DELETE key is pressed. Try out this feature now with the "Delete Character" command. After marking the character to be deleted, press the REPEAT CMD key instead of typing the final <OK>. When you are in repeat mode, you need not continue to use the REPEAT CMD key -- <OK> works just as well. 3C1

It is very similar to the INSERT mode, and could be used on the Insert Statement command to give similar results, except that you would always need to mark the statement that the new statement was to follow. 3C2

The escape key (marked ESC or ALT on most terminals) provides a handy way to avoid a lot of typing. When you need to specify a file name, such as in a "Jump (to) Link" command, you do not need to type the entire name; simply type enough characters so that no other file in your directory begins with those characters, and press the <ESC> key. When you do this, AUGMENT will fill in the rest of the name, as if you had typed it yourself. If no such file exists, or if more than one such file exists, a "$" will appear. If you have not typed enough, backspace (to erase the "$"), and type a little more, followed by another <ESC>, if you wish. 3D1

Unfortunately, I do not know of any files that you have in your directory, except for TUTOR, TUTOR2, and TUTOR3, but they all must be typed to the bitter end before they are distinguishable. If you know of any other file in your directory, type a few characters at the beginning, and try out <ESC>. 3D2

There are a couple of tricks that make use of the <ESC> key to make life a little easier. 3D3

The <ESC> key can also be used to fill out directory names. Try typing the following (without the final <OK>!), watching the command window as you do: "jluserg<ESC>loc<ESC>". Notice that the directory name USERGUIDES was filled out first, and the second escape filled out the file name LOCATOR. Type a command delete if you do not really want to go there. 3D4

This brings up an interesting point: It is a good idea to give your files names that differ in the early characters, rather than in the later characters. The pair ACCOUNTS-PAYABLE-79 and ACCOUNTS-PAYABLE-80 is very bad compared to the pair 79-ACCOUNTS-PAYABLE and 80-ACCOUNTS-PAYABLE. The <ESC> key is virtually useless in the former case. 3D5

If you are using AUGMENT in display mode on a nonstandard terminal using cursor keys, you will remember that typing an <ESC> will put you into pointer mode, rather than file name recognition mode. If you want to use <ESC> for file name recognition, simply precede the <ESC> with <LIT> (see <01260>). 3D6

In order to make a file AUGMENT private, you must do three things. First, you must insert an AccessList of idents allowed to view the file, then you must set the file private, and finally, you must update the file. The three actions are discussed in detail below. 4C1

From the point of view of the Executive, there are three classes of people: You yourself make up the first class, your "group" (to be described later) makes up the second class, and everyone else in the universe makes up the third class. You can set the protection differently (for any particular file) for each of the three classes. 4D1

"Your group" can be any specified set of Executive directories. If you want to set up such a group, you must send a message to Tymshare (or Feedback) requesting it. If you say nothing, your group will consist of only one person -- you. Often, your group will be set to be all the other people with whom you work. It is possible to be a member of more than one group, but there is no way of setting the protection differently for the two different groups -- either both can do such and such, or both cannot. If you wish to set protection on an individual basis like this, use AUGMENT protection, as described above. 4D2

For each of the classes of people discussed above, there are five individual types of protection that can be specified (for each file). You can allow individuals in the class to (1) read the file, (2) write on the file, (3) execute the file (if it is a program), (4) append to the end of the file, and (5) list the file in a Show Directory command. For AUGMENT files, you will probably not ever need to worry about the execute and append protections -- they refer mostly to non-AUGMENT files. 4D3

The list protection, when set, will not allow other users even to see that the file exists. The read and write protections mean the obvious things. 4D4

For each of the classes of individuals mentioned above, all five types of protection are coded up into a two-digit number, and your total protection is specified by putting the three two-digit numbers together to form a six-digit number. The details of the coding will be discussed later (and can be skipped by all but the most inquisitive). A few simple examples should give you the idea of what you need to do. 4D5

The two-digit code "77" means that anything can be done to the file -- read, write, append, list, and execute. The code "52" allows all nonmodification commands to be done -- read, list, and execute. The code "00" allows absolutely no access rights to the file. 4D6

When the two-digit numbers are packed together, your protection comes first, then the protection relative to your group, and finally, the protection for everyone else in the universe. A very common protection is the following: "775200". This allows you to do anything, members of your group to look but not touch, and others to not even look. If you want to make a file that is completely secret to the rest of the universe, but which members of your group can write on, the protection should be set to "777700". To make a file so that you are the only person who even knows of its existence, use the protection "770000". To set a file so that anyone in the universe can read it (but not write), and so that you are the only person who can write on it, use the protection code "775252". These examples should give you the idea. 4D7

Now, how do you go about setting the protection, assuming that you know the appropriate combination of digits? The command is the following: "Set Protection (mode for file) <OK> (protection type:) Exec Code (in octal) NUMBER<OK>", where NUMBER is the six-digit protection code described above. As was the case with AUGMENT protection, after the noise words "(mode for file)", you may type a file name, or type <OK> to mean the current file. Unlike the AUGMENT protection, Executive protection takes effect immediately. 4D8

If you do not want to remember all the details about the code, it is possible to set the Executive protection one item at a time. Instead of typing the command word "Code", you may type a sequence of command words of the form {Permit/Restrict} {Read/Write/Append/List/Execute/All} (access for) {Self/Group/Others} (finished?) ANSWER. You may type as many sequences as you wish, followed by "y" for "yes" or <OK> to end the command. The braces above mean that you can select exactly one of the alternatives contained within. An example follows. 4D9

Suppose you want to set the protection of the current file so that members of your group can read and write on it. Give the following command: 4D10

Now, for those brave souls who want to know the details of Executive protection, here they are. To set a particular protection, proceed as follows: For each of the classes of individuals, and for each of the five protection types listed above, write down, in order, a "1" or a "0", depending upon whether you want to allow or forbid that right, respectively. For example, if you want to allow everything, your list should be made up of five "1"'s. List the five digits in the order mentioned above: read, write, execute, list, and append. Finally, add a "0" or "1" to the end of your list to make six digits. This number is not used, but must be there. It makes no difference what you put down. 4D11

Next, break down the group of six digits into two groups of three, and convert the sets of three zeros and ones to digits using the following table: 4D12

The two digits you get will be the protection for one of the classes of users described above. The following example should illustrate the procedure. You want to be able to do anything, you want your group to be able to read, list, and execute, and you want the rest of the universe to be able to do nothing. You should get the following sets of digits (where the last of the six in each case is random, and could be changed): You, 111 111; your group, 101 010; and the rest of the universe, 000 000. Using the table above, these combinations translate to: You, 77; your group, 52; and the universe, 00. Hence, the entire protection for this file will be: 775200. 4D13

Note that because of the ambiguity of the sixth "0" or "1", the protections 775200, 775201, 765301, ... are all equivalent. 4D14

In addition to the types of protection discussed above, there is still another, more arcane type called "directory protection". It has to do with entire directories. See an Executive user's manual for a discussion of this type of protection. 4D15

There is one final question that needs to be answered, and then the discussion of protection will be complete. What determines the protection of a newly created file? The answer is that each directory has a default protection associated with it, and each new file gets that protection. If you need a directory in which newly created files automatically need some special kind of protection, it must be set up that way by Tymshare. Contact your representative or Feedback to have this done. (You may, for example, want to have a very private directory, because all the material in it will be relatively confidential, or you may want to have a directory in which all information is public, as, for example, a USERGUIDES directory). If you don't say anything when you ask for a new directory, the protection automatically assigned is "775200". You can do anything, your group can read but not write, and the rest of the universe can do nothing. 4D16

Visible and Invisible are just two more nouns, similar to Text, Character, and Word. They are most similar to Word, in that they require one mark, and specify (possibly) more than one character. A visible is defined to be the marked position and as many characters to the right and left until a "nonprinting" character appears. "Nonprinting" means a character like <SP>, <TAB>, <RET>, and many others. A Visible can be thought of as a sequence of characters that are visible on the screen. 5A1

A "Visible" can be an extremely useful entity -- it will grab attached quotation marks, punctuation marks, and so on. The following file name: TRAINING,TUTOR3.AUG;2 can be identified as a visible using one mark anywhere within it. (Delete it now, with the "Delete Visible" command.) 5A2

Like the "Word" noun, the "Visible" noun can specify two adjacent visibles. Note that in the definition, it was stated that a visible is the character marked (whatever it may be) and ... Try moving, deleting, copying, etc. a few visibles in this statement until you understand fully what it means. Then, try to figure out what an invisible is before reading the next paragraph. 5A3

An "Invisible" is just the opposite of a "Visible". It is defined to be the character marked, plus any number of nonprinting characters to the right and left. Note that like "Word" and "Visible", an "Invisible" can contain one character that would normally not be a part of it -- the marked character.         Delete the invisible between this sentence and the last one now, using "Delete Invisible".   &         Now try to delete the junk between this sentence and the last, using the Delete Invisible command. (Hint: Mark the "&"). 5A4

This section begins with a disclaimer. If you need to do a lot of formatting, you should probably use the Output Processor or the Table subsystem. If you just need to make one or two statements look different, this can often be accomplished using return characters and/or tabs. 5B1

One of AUGMENT's great advantages is that there is no need, when you are typing text, to pay attention to where the lines must break. If you insert or delete a word, all of the lines in the corresponding paragraph are adjusted to make the line breaks occur as uniformly as possible. Because of this, statements can be freely moved to a lower or higher level, where a different indenting might make the lines not fit. The only time this is a problem is where you want to force a new line to begin. If you want it to begin a new line because it is a new paragraph, there is no problem -- just make a separate statement of it. There are times, however, when you want to begin a new line in the middle of a statement, as, for example, in a small table. 5B2

The text of the next statement is contained between the dashed lines. Jump or scroll that statement to the top of your screen, and follow the instructions in the statement below it. 5B3

There is a return character <RET> at the end of each of the lines (except the last line of dashes), and there is a <TAB> just before "A Poem". The easiest way to see these invisibles is to give some command like "Delete Character", and MARK where the character would be. Then type a command delete (assuming you don't want to delete the character). Try marking spaces, the characters just after the ends of the lines, and where the first character would be in the line containing "A Poem". Note the way that the highlighted characters appear. Using this technique, you can tell the difference between the various kinds of formatting invisibles. MARK the beginning of the line after "A Poem". This is how two <RET>s in a row appear. Now try deleting and inserting <RET>s and <TAB>s to get a feeling of how they behave. Be sure to try putting in more than one <RET> or <TAB> in a row. 5B4

Return characters are simple; they say: "Go to the beginning of the next line, no matter what". Tabs are more complicated. Where are the tab stops, how do you change the settings? What happens to <TAB>-formatted material when it is moved down a level? 5B5

It may even turn out that your user profile is set up so that you do not insert <TAB>s at all -- the appropriate number of spaces are inserted. For this reason, and all of the above, tabs deserve a section all of their own. 5B6

Introduction 5C1

Spaces for tabs 5C2

Inserting real <TAB> characters in your file 5C3

A Number is just another editing entity, similar to Word, Character, Text, and so on. In most cases, it behaves exactly as you would expect. For example, try deleting this number: 137.04 using the Delete Number command. Insert Number, Move, Replace, Copy, and so on, all work. 5D1

It turns out that there are times when the number entity does not behave exactly as you might expect. The reason is that to define what a number is in terms of text is very difficult. Consider the following list of things, which could all be considered to be numbers under certain circumstances: "12", "12.34", "1,234,432.5", "1.2E23", "-56E+7", "+6.02E23", "(456)", "$54.12", "- 123", ".0000003", "1.6E-19", "E-7", "E3", "775200B". Not all of the above are recognized as numbers, but many of them are. Thus, sometimes slightly surprising things happen when you move a number -- not all of it is moved, too much is moved, etc. AUGMENT just makes its best guess as to what you mean, and it is not always right. Very often, the Visible noun works better than the Number noun. 5D2

There are times when the Number noun is quite useful. One is in table-like applications. Suppose that only three-digit numbers are allowed in a particular table, as in the tiny table below. Try using the Replace Number command on various of the entries below and watch what happens. Be sure to try to replace short numbers by longer ones, and long ones by shorter ones. Be sure that all numbers are less than or equal to three characters in length in this example. 5D3

(By the way, in the example above, there is nothing special going on. There are no <TAB> characters, and the numbers are just separated by the appropriate number of spaces. The point of the exercise is that the Replace Number command does some work to preserve spacing.) 5D4

A Phrase in AUGMENT is a textual entity that behaves something like Text. You can Delete, Move, Copy, ... a Phrase, and a Phrase is simply defined to be text that begins and ends with a visible. To identify a phrase requires two marks. A typical use would be to move a group of words, or a sentence. Phrase is useful in the same way that the Word or Visible entities are useful -- your marking need not be quite so precise. All you need to do is mark a character somewhere in the first and somewhere in the last visible required. The fact that a Phrase goes from visible to visible instead of word to word is that it is usually desired to carry along the punctuation, be it periods, quotation marks, or parentheses. 5E1

The Directive noun refers to Output Processor directives. It is something like the Word noun, in that it requires only one mark to identify the directive in question. A directive is defined to go from a period on the left to a semicolon on the right. You must mark the period or semicolon or somewhere inside the directive in order to have it recognized. 5F1

Any statement (or statements) can be frozen, in the sense that it (they) will always be presented at the top of your screen, no matter where you may jump (even to other files). This is sometimes very convenient when you want to keep a statement containing reference information and use it in other places. The information in the frozen statement can be copied by marking it, and statements can be inserted to follow it, simply by marking it when you are asked "(to follow)" in the Insert Statement command. 5G1

The command is simply "Freeze Statement (at) MARK <OK>", and the command to unfreeze is "Thaw Statement (at) MARK <OK>". During a particular AUGMENT session, a statement will remain frozen until it is thawed; however, the frozen statements may be turned on and off with a viewspec. They are normally off. After you have frozen a statement, you may see it by setting viewspec "o". To turn off the frozen statements, use viewspec "p". Try freezing a statement, and then use viewspec "o" to see what it looks like. Try freezing and thawing various statements, with various combinations of the "o" and "p" viewspecs. Try jumping around, and notice that the frozen statements remain fixed. 5G2

If you want to both freeze a statement and turn on (show) the frozen statements, simply type "o" when you are prompted for viewspecs. 5G3

There is a shortcut in the Thaw command: "Thaw All (frozen statements)" does just what it says. 5G4

An advanced user will find that statement names provide one of the most useful and powerful ways of getting around in an AUGMENT file. In a large file, you may have a number of places where you regularly go, and if you are like most people you will find it hard to remember that you kept your to-do list at statement 17a, your accounting information at 41, and so on. What is worse, if you add a new statement 1 to your file, suddenly your to-do list is at statement 18a, and your accounting information can be found at statement 42. You may recall that SIDs do not change, but still it is hard to remember numbers like 0188 and 0423. In a heavily used file, it may be worse -- the SIDs may begin to look like 013245 or 088724. 5H1

It is possible, and far more convenient, to give important statements a name by which you can refer to them. Good names for the two statements mentioned in the paragraph above might be "to-do", and "accounts". In this section, we shall discuss how to go about this. 5H2

Every statement potentially has a name, and if it has a name, the name is defined by the first few characters of the statement. A name must start with a letter of the alphabet, and can then contain any combination of letters, digits, and the special characters "-", "@", and "'". For example, the following are legal statement names: "mail", "accounts-80", "name1", "qwer@-t3" (although why someone would name a statement this way is a little mysterious), and "journal". 5H3

The following are not valid names, for the reasons indicated: 5H4

Unless you do something special, the name of a statement is simply the first characters in a statement, if they form a valid name. The name of this statement, for example, is "unless". 5H5

5This statement has no name, since "5This" is not a valid name. 5H6

Note that the capitalization of a statement name makes no difference -- the statement two before this one begins with the characters "Unless", but its name could be referred to as "unless", "UNLESS", or even "UnLeSS". 5H7

Once a statement has been named, the name may be referred to as an address element in the same way that statement numbers or SIDs are used. For example, the following commands would be valid in this file: 5H8

Now it should be clear why all file names require a comma after them. Without the comma, they are interpreted as a statement name, and AUGMENT tries to find a statement with that name. Try typing "Jump (to) Link tutor<OK>" (no comma), and note that there will be an error message because no statement (in this file) has that name. 5H9

Note also that statement names can be ambiguous. In many files, for example, quite a few statements have the name "the", since many paragraphs begin with that word. If you try to "Jump (to) Link the<OK>", you will just get to one of them, and there is no way of telling which one will be reached. This may sound bad, but it does not usually cause trouble, and there are a number of ways of getting around a problem of this sort, should it be serious. 5H10

A command "Jump (to) Name" exists for looking at successive statements with the same name. This command comes in three forms: 5H11

Earlier in this section, it was stated that "unless you do something special, the name will be the first characters of a statement". In some instances, you would like to make the naming of a statement a special thing, so that not every statement will have a name (as most of them do in this file, for example). To understand fully how to do this, it is necessary to understand exactly how a statement name is determined. 5H12

There are times when you would like to jump not to the predecessor of a statement, but to the predecessor of the predecessor of the statement. You might want to jump back three statements from the top of the screen, and so on. To do these things using the commands you presently know would require two jumps in the case of the first example, and three in the case of the second. This section describes some shortcuts that can be used to combine two or more jumps into one. 5I1

It turns out that all the specialized Jump commands that you have learned up to this point are in fact special cases of the "Jump (to) Link" command, relative to the top statement on your screen. For example, if you want to jump back one statement from the top statement on your screen, you could use the command "Jump (to) Link .b<OK>". The period indicates that the following character is to be taken as a relative addressing element. In particular, "b" (or "B") means "Back". 5I2

Note that this gives exactly the same result as "Jump (to) Back" and marking the top statement on your screen. There are other addressing elements similar to .b, and they are listed below. This is a complete list, and some of them will require further explanation later. For now, just read through the list to get a flavor of the available addressing elements. Come back later when you need to use them. 5I3

Now, for the nice part. To jump back two statements from the top of the screen, simply use the command "Jump (to) Link .2b<OK>" or "Jump (to) Link .bb<OK>". 5I4

To jump two predecessors from the statement at the top of the screen, use the command "Jump (to) Link .2p<OK>". To jump to the statement down from the predecessor of the statement at the top of the screen, use the command "Jump (to) Link .pd<OK>". To advance 100 statements in the file (again, counted from the top statement on the screen), use "Jump (to) Link .100n<OK>". A useful little command, no? 5I5

Any combination of the above addressing elements can be used in a link; we have seen some examples. Also, they can be appended to the ends of other links, as follows: Suppose you would like to jump to the successor of the statement named "blap". You can do so with the command "Jump (to) Link blap.s<OK>". 5I6

Following is a short discussion of the meanings of the address elements that are probably not familiar to you. Obviously, not all of them are equally useful. 5I7

Try out some of these addressing schemes. They do take practice, but as your skill increases, you will find that you use them more and more. 5I8

The "Jump (to) Address" command is just a slightly souped up version of the Jump (to) Link command. In the Jump (to) Link command, all addressing is done relative to the statement at the top of the screen. The Jump (to) Address command allows you to mark a starting place. It also lets you enter viewspecs separately. It is slightly more powerful than the Jump (to) Link command, but it does take quite a bit more typing, so it is less useful. Play around with it if you are interested. 5J1

A large number of different capabilities are hidden away in these commands, and many of the most common of them have been described elsewhere. Some of the material in this section will repeat the information found elsewhere in the Tutor files, but all of the capabilities of these three commands are documented here. Even if you think that you already understand a particular Set, Reset, or Show command, it is recommended that you read through its description anyway. Sometimes the version presented earlier covered only a simple case of the command. Where a command has been completely covered elsewhere, a link is given to the complete description. 6A1

In many cases, a Set command has a corresponding Reset command, which returns the parameter back to a default. The Show commands allow you to see the status of various things, and the things that can be shown often can be Set or Reset. There are exceptions to all of the above, however. The easiest thing to do is to quickly read through all of the descriptions below to get some idea of the parameters covered by these commands, and then use question mark liberally when you actually need to use one of them. 6A2

As you read through the sections that follow (especially the Show command), try it out, and see the kinds of information presented. 6A3

Content 6B1

External 6B2

Force 6B3

Link 6B4

Name 6B5

Print 6B6

Protection 6B7

Status 6B8

Temporary 6B9

Terminal 6B10

Viewspecs 6B11

Profile 6B12

Force 6C1

Link 6C2

Name 6C3

Print 6C4

Protection 6C5

Sids 6C6

Status 6C7

Temporary 6C8

Terminal 6C9

Viewspecs 6C10

Profile 6C11

Changes 6D1

Content 6D2

Directory 6D3

Disk 6D4

External 6D5

Link 6D6

Marker 6D7

Modification 6D8

Name 6D9

Protection 6D10

Return 6D11

Status 6D12

Temporary 6D13

Version 6D14

Viewspecs 6D15

Profile 6D16

Most of the important AUGMENT commands have been discussed in detail elsewhere in these Tutor files. There is a certain set of commands that do not fit nicely into larger categories, so they are all lumped together here. Do not think that simply because the command appears in this section that it is not useful. The Check Mail command is very useful, for example. 7A1

This command allows you to display spaces, carriage returns and tabs as tilde (~), open angle bracket (<) and closed angle bracket (>), respectively. The displayed characters will be shown on your screen, but will not be printed on output. This feature may be extremely useful in fixing up a Table, where the formatting spaces may be invisible, but important, or in determining if a file has been prepared with spaces for tabs set on or off. 7B1

This command allows you to remain in AUGMENT and check your Executive mailbox for new mail. When the new mail system is installed, it will be used to check for the arrival of that kind of mail, too. 7C1

The top two lines on your screen are the status window, and are used to present messages from the system. In the Conference subsystem, comments typed by participants who do not hold the gavel appear in the status window. It is possible (using the Set Status command) to make any other window the status window if a larger status window is needed for some reason. 7D1

This command simply allows you to type characters that will appear on the screen; the characters will be erased as soon as an <OK> or <CD> is typed. It is useful in the Conference subsystem. This is a universal command, so it is available in all subsystems. 7E1

This command is used to give a particular character in your file a name called a "marker". 7F1

This command is also available primarily for users of the Conference subsystem. It allows the user to mark a character on the shared screens, thus pointing at it. 7G1

This command allows you to rename a file. It will not work at present if the file to be renamed is the current file. 7H1

There are really two commands here. The first reverses the color of the background of a window (on an AUGMENT 1200 terminal), and the second reverses the order of the statements in a Group or Plex. The first command is "Reverse Window (color value in window at) MARK <OK>", and the second is "Reverse {Group/Plex} (at) LOCATION <OK>". 7I1

The AUGMENT Sort command allows you to sort a branch, group, or plex of statements into various orders. If you are sorting a branch, the statements down a level from the branch head are sorted. In the case of a group or plex, the statements in that group or plex are sorted. If the statements have substructure, the substructure remains connected to the statement above it, and is moved around wherever that statement goes. If you give the command in the simplest form, "Sort Plex (at) MARK <OK>", the sorting is in standard alphabetical order. See below for descriptions of all the available sorting types. More than one type can be used at the same time. A reverse chronological sort can be done using Sort ... Date Reverse <OK>, for example. 7J1

This command is primarily of use in typewriter AUGMENT, where it prints the appropriate text and then does a jump to that statement. In display AUGMENT, it prints the structure on the screen, and leaves it there until an <OK> is typed. Viewspecs can be specified in both cases. This command can be useful in display AUGMENT to have a sort of scrolling mode. You can read a large portion of text by typing a character after the end of each screenful without having to do jumps. 7K1

Background 7L1

<TAB> (repeat content search) 7L2

<LF> (line feed) 7L3

. (period) 7L4

/ (current context) 7L5

\ (current statement) 7L6

; (comment) 7L7

^ (previous statement) 7L8

The basic idea of a commands structure is that there are occasions when you want to be able to give the exact same sequence of commands over and over again. For example, you may want to pull your messages in and format them in a certain way, and jump somewhere, etc. Here is a sample commands branch. If you give the command "Process (commands from) Branch" and mark anywhere in the word "(sample)" you will see the system jump automatically to the origin of this file and then take you back here. Do this now. 8A1

Usually commands structures are used where you do some repetitive task, like when you always go through the same sequence of file commands. If you give them a name and "Process Branch" at that name it will actually do those commands automatically. Note that there is nothing special about a branch. You can also process commands in a Statement, Group, and Plex. Most commonly, however, they are organized as a branch. 8A2

In a commands structure, you could type, for example, "G " instead of "Goto ". It is best, however, to type the whole command word out. That way when you go back to the structure later on you can easily recognize the commands you specified. Also, you must type a space after every command word. 8B1

You MUST insert the actual <OK> character. This is done by preceding it with <LIT> or <CTRL-V>. If you type <LIT> or <CTRL-V> first, then the next character you type will be literally inserted into the file. (<LIT> means take the next character literally.) Using <LIT>, you can get all of the characters you need in your commands structure. You can't get <CTRL-C> or <CTRL-T>, but any reasonable character can be inserted. In the sample commands branch in <01714> above, the actual characters typed in the first command statement were "jump origin tutor4,<LIT><OK><LIT><OK><OK>". 8C1

First of all, create a branch with an appropriate name enclosed in parentheses, such as "(mail)". Then just type the actual commands you want it to perform, using one statement for each complete command. For example: 8D1

Using parentheses as the name delimiters is recommended. You must set the delimiters with the Set Name (delimiters) command, as follows: 8D2

The Process command will skip names without processing them. 8D3

Frequently it is helpful to issue your command sequence at a typewriter terminal before writing your commands branch. That way you can see your commands and exactly how they are to be specified. 8D4

Don't expect your commands branch to work the first time. You will probably find you left out a final <OK>, for example. Remember to update your files first because the commands may modify your files. 8E1

The commands being tested may go by so quickly that you won't be able to tell when something goes wrong. Therefore, you should first process a statement at a time, preferably at a typewriter terminal so you will have printed copy of what goes wrong, if anything. 8E2

The command is "Process (commands from) Branch (at) statementname<OK>". After you do this, AUGMENT performs the commands in the named sequence until it comes to the end of the branch and is done. 8F1

If you want to run the commands branch when you are in other files you must specify the file name, as in "Process (commands from) Branch (at) filename,statementname<OK>". 8G1

You can automatically run ONE commands branch every time you enter AUGMENT. The Useroptions subsystem command "Startup (Commands Branch Address)" will automatically process the commands in the indicated branch every time you enter AUGMENT. It is just a commands branch that could be run manually. 8H1

Often you don't remember the exact sequence of a command. Use AUGMENT in typewriter mode and it will show exactly how many times you need <OK>'s, etc. 8I1

A commands structure is always much more complicated to run than you think. If you have done anything wrong, bad things can happen. 8I2

You may have filled up your program buffer and it can't load the program you request. So it is best to make the commands foolproof. Have one of your commands be: 8I3

Now you know you will have space. 8I4

Also: 8I5

Have the commands do all the things necessary to make sure they are in the right directory and the right file. 8I6

Branches are only good for going through a list of instructions from beginning to end. They are not conditional; that is, they will not execute certain commands depending on a condition. 8I7

You can't go to the Executive with a commands structure. 8J1

A commands structure that has been running for a long time may suddenly break down mysteriously. Check your commands structures periodically. For instance, let's say you wrote a branch that creates a new file in your directory each time it is run. Furthermore, let's assume that you have accidentally gotten very close to your disk allocation limit. When the branch gets to the place where it is to create the new file, it has no way of knowing that AUGMENT will not let it do so, and the branch will fail. 8J2

There is the basic question as to when you will use commands branches. While you are working, try to keep track of places where you seem to always issue the same sequence of commands over and over again. For example, if you always print out a document in a fairly funny way, where you have to set up a lot of things beforehand (e.g. set viewspecs, jump file, set up printer, etc.), and you always do these same ten things, put them in a commands branch. 8J3

Also, you may have a one-shot thing, where you want to replace the last character in every statement and it would take forever manually. Use a commands branch once and then delete it. 8J4

Remember the Useroptions way of setting up a Startup branch for every time you enter AUGMENT. 8J5

The cross-referencing in this file is an example of this. Any link that you can type in response to the "Jump (to) Link" command can be typed as text, and surrounded by "<" and ">", or by "(" and ")". Then, when you issue a "Jump (to) Link" command, you need only mark between the bracketing characters, and give the final <OK>, and you will be there. For example, <2> points to statement number 2 in the current file, and points to statement number 2 in the TUTOR file. <09:wyIGm> points to the statement in this file that discusses other viewspecs, and says that when you arrive, all lines and levels are to be shown, blank lines are to be on, and the numbers are to be SIDs, placed on the right of the screen, and turned on. 9A1

A link can be thought of as a "view" of a file, and in this section, you will learn a large number of other things that can be typed either between the link bracketing characters or directly in response to the "Jump (to) Link" command. 9A2

Every AUGMENT file has associated with it a default directory for links. This means that if you use the Jump (to) Link command and mark a link that doesn't specify a particular directory, the directory it will assume is the default directory for links for the file containing the link. 9B1

This is easiest to understand with an example. Suppose that whenever you typed "Jump (to) Link" and marked a link, AUGMENT always assumed that you meant in your own directory, unless the link specifically requested something else. Then when you are looking at someone else's file, and they have put in a link, you cannot use it, unless they specifically included the directory name in the link. What really happens is that the file itself knows what directory the links are to assume, and this is what is used whenever a directory name is not mentioned and a link is marked as text rather than typed in the command. 9B2

A link (whether typed in the "Jump (to) Link" command or typed as text) may consist of the following components: directory-name,file-name,in-file-address:viewspecs;content-pattern; Most of the components can be left out. If the directory name is included, the file name must be included as well, but anything else can be omitted. 9C1

Directory name 9C2

File name 9C3

In-file address 9C4

Viewspecs 9C5

Content pattern 9C6

e -- The level of the referenced statement. This viewspec is extremely useful for clipping. If you jump to a statement using the "Jump (to) MARK" command, and set viewspec "e", you will see levels only down to the level of the statement you marked. The nice thing is that you do not need to count how many levels it is indented. "e" just says "the same level as this one". If you want to see statements at that level, plus those down one more level, type "Jump (to) MARK eb<OK>", so the viewspecs are "eb" -- that level, plus one more. 10A1

g -- Show branch only. Only statements in the branch of the statement at the top of the screen are viewed. This command can be very useful for printing. It can be somewhat disconcerting to jump to a statement with nothing under it with this viewspec set, and have everything but this statement disappear. 10A2

h -- Show all branches. This is the default, and undoes "g", "l", or "Q". 10A3

i -- User filter on. It is possible to write content patterns, or content programs, that cause only statements satisfying some kind of pattern to be displayed on the screen. If such a pattern or program is written and loaded, viewspec "i" says to view only statements passing the pattern. It is a command for experts only. If "i" is set, and there is no program loaded, it has no effect. 10A4

j -- Don't filter statements. This is the default, and undoes viewspec "i" or "k". 10A5

k -- Show next filtered statement. If a content pattern or program as described under viewspec "i" is in effect, viewspec "k" says to find the first statement passing the filter, and to show it at the top of the screen. From that point on, all statements are displayed, regardless of whether they pass the filter or not. 10A6

l -- Show plex only. Only statements in the plex of the statement at the top of the screen are shown. It is sometimes useful for printing. 10A7

u -- Recreate window after change. This is the default, and undoes the (very dangerous) viewspec "v". 10A8

v -- Defer recreating window. Beware!! This command is for experts only. Normally, when you delete a character, the other characters on the screen shift around to show the new orientation. With this viewspec on, the screen does not change, until specifically requested with a viewspec "f". It can save time if the system response is very slow, but should be used with extreme caution. AUGMENT knows what the screen should look like after the edit, and your marks are interpreted relative to that screen, not relative to the screen you are viewing. To use this viewspec, it is best to edit backwards, since usually edits later in the file do not affect the screen positions of text earlier in the file (but not always!). If you get confused, set viewspec "f", to see where you are. If you must try out this viewspec, try it first on a file you don't mind destroying. Sometimes this viewspec gets set accidentally. If your edits do not seem to take effect, do a Show Viewspecs to see if you might have accidentally turned on viewspec "v". 10A9

A -- Level indenting on. This is the default, and undoes viewspec "B". 10A10

B -- Level indenting off. All statements, regardless of their level, are left-justified on the screen. It can let you view more of a file, and if the numbers are on, it is not too hard to deal with different levels. Note that the statements still have substatements, etc. Their structure simply is not being shown via indenting. 10A11

C -- Show statement names. This is the default, and undoes viewspec "D". 10A12

D -- Do not show statement names. The statement names and their delimiting characters (if any) are not shown on the screen. In this file, for example, if you turn on viewspec "D", the first words of most statements will disappear. See the section in this file <0188> on statement names, if you do not know what they are. 10A13

F -- Recreate display. This viewspec is essentially identical to viewspec "f". In the case of "f", AUGMENT will only redraw if it thinks something has changed. Viewspec "F" says "Redraw the screen no matter what". Sometimes there is line noise, and the screen draws incorrectly, but AUGMENT thinks it is OK. In this case, viewspec "F" forces AUGMENT to redraw the screen. 10A14

K -- Show statement signatures. Every time a statement is edited, AUGMENT notes the time and date, and the ident of the person who did the last edit. You can see that information by turning on viewspec "K". Try it and see. Viewspec "L" turns it off. 10A15

L -- Do not show statement signatures. This is the default, and undoes viewspec "K". 10A16

O -- Turn on user sequence generator. Expert users may actually write AUGMENT code files, and change the order in which statements are presented on their screen. If you have written such a program and loaded it, this viewspec turns it on. 10A17

P -- Turn off user sequence generator. This is the default, and turns off viewspec "O". 10A18

Q -- Offsets indenting to level of statement at top of file window, when used with "l" or "g". If viewspec "l" or "g" is set along with viewspec "Q", the statement at the top of the file window is left justified, and all following statements are indented in the usual way relative to it. Try it -- it sometimes saves some space on the screen. It is turned off by "h". 10A19

The gentle approach: Learn just one or two letters at a time. A good pair to start with are "j" and "l", for "Jump (to) Link". This is probably the most common command, and every time you do a "Jump (to) Link", use the keyset instead of the keyboard. Then add a few more letters, like "d" and "c" for "Delete Character", or some other common letters, and continue gradually. Before long, you will realize that you know almost all of the letters, and you can do half an hour or so of the "brute force" approach to learn all the rest of the letters. 13K1

The brute force approach: Put the keyboard out of reach, and set the viewspec card in front of you and type absolutely everything on the keyset from the beginning, including logging into the computer. This will be very painful at first, but after a couple of hours, you will be amazed at how good you have become. 13K2

There is actually a method related to the brute force approach that some people have found useful. In any file (since you are going to do a command delete at the end anyway), type "Insert Statement (to follow statement at) MARK", and then begin typing the alphabet over and over again, in order, using the keyset. Soon, your fingers will begin to learn the patterns, and you can "count up" to an uncommon character later. Thus, if you forget what the keyset combination for "k" is, but you remember the pattern for "j", just count up by one in the pattern that you have taught your fingers. 13K3

There are probably other methods that you can think up which would be best for you. It is a little extra work to learn to use this new tool, but it does pay off if you become proficient at using it. 13K4

The uppercase and lowercase letters have identical keyset combinations. The only difference is the second mouse button, which must be held down to type uppercase letters. 13L1

The control characters can all be typed with the same keyset combination as the corresponding letter, but using still a different mouse combination. 13L2

If you know anything about binary counting, notice that the letters go up in a binary progression. Hence, if you need to type a "k", and can't remember its combination, you can "count up" one from "j". 13L3

There is only a one-key difference between the digits and the corresponding punctuation mark that appears above them on the standard typewriter keyboard. 13L4

<CTRL-@> 14A1

<CTRL-A> = <BC> 14A2

<CTRL-B> = <RC> 14A3

<CTRL-C> 14A4

<CTRL-D> = <OK> 14A5

<CTRL-E> = <INS> 14A6

<CTRL-F> 14A7

<CTRL-G> 14A8

<CTRL-H> 14A9

<CTRL-I> = <TAB> 14A10

<CTRL-J> = <LF> 14A11

<CTRL-K> 14A12

<CTRL-L> 14A13

<CTRL-M> = <RET> 14A14

<CTRL-N> = <NULL> 14A15

<CTRL-O> 14A16

<CTRL-P> 14A17

<CTRL-Q> = <HELP> 14A18

<CTRL-R> 14A19

<CTRL-S> 14A20

<CTRL-T> 14A21

<CTRL-U> = <OPT> 14A22

<CTRL-V> = <LIT> 14A23

<CTRL-W> = <BW> 14A24

<CTRL-X> = <CD> 14A25

<CTRL-Y> 14A26

<CTRL-Z> 14A27

<CTRL-[> = <ESC> 14A28

<CTRL-\> 14A29

<CTRL-]> 14A30

<CTRL-^> 14A31

<CTRL-_> 14A32

AUGMENT is able to do many of the things that it does because its files are not organized in the same way as most of the files on the computer are. If you only used AUGMENT, you could probably avoid dealing with non-AUGMENT files most of the time. Unfortunately, if you want to interface with users of other systems, especially different mail systems, you will need to learn a little bit about how to deal with non-AUGMENT files. (Even as an AUGMENT user, you actually make use of non-AUGMENT files from time to time, but their use is somewhat hidden.) 15A1

Although there are a number of different file types, you will probably need to deal only with a few of them. The most important types from an AUGMENT user's point of view are AUGMENT files and sequential files. Both types are used for storing text. There are other files which contain compiled programs and other information, but you will probably not need to deal much with these. 15A2

In the vast majority of cases, a file's extension tells you its type. For AUGMENT files, the standard extension is "AUG", but for some older files the extension may be "NLS". There is no reason that an AUGMENT file must have an "AUG" extension or that a non-AUGMENT file must have a some other extension. It is just a convention that you must go out of your way a little bit to break. 15B1

Below is a list of some of the more common extensions, and a short description of their usual meaning. The list is not intended to be complete, but it should take care of most of the usual cases. 15B2

The basic command to create a sequential file from an AUGMENT file is "Create Sequential". This will create a sequential file formatted exactly the same way as the information is presented on your display screen. If numbers are on, numbers will be on in the sequential file, if blank lines are on between statements, there will be blank lines in the sequential file, and so on. The size of the sequential file created can be controlled by "g" and "l" viewspecs. 15C1

When Create Sequential is used, the statements are broken at appropriate word breaks, and return characters appear in the sequential file produced. There is another command similar to "Create Sequential" called "Create Assembler", which is very much the same, except that it does no line breaking except at the ends of statements, where a return character is inserted. Another difference is that Create Assembler does not indicate indenting with three spaces -- it uses a <TAB> character. Statements indented two levels are printed with two leading tabs, and so on. Various assemblers prefer to see the output in this form, and it can be useful for other things as well. 15C2

Converting AUGMENT files to sequential files is quite straightforward; the opposite problem can be quite difficult. There are two reasons for this. The first is that there must be some way of telling AUGMENT where one statement ends and the next one begins. The second is how to tell AUGMENT what the level indenting should be. 15D1

If the file to be converted was originally constructed with the intention of eventually converting it to an AUGMENT file, these will not be problems, but if it was not, there may be some problems. Indenting done in the original file may be interpreted as level changes in the converted file where they should not be, the spacing may not have been done in a consistent manner, and there are other problems. In many cases, the easiest thing to do is rather than get the conversion perfect the first time, copy it in as well as possible, and then use the AUGMENT editor to correct any mistakes that the automatic process may have made. 15D2

The basic conversion command for sequential-to-AUGMENT conversion is the "Create Augment" command. It will ask for the name of a sequential file to be converted, and for a place in an AUGMENT file to put the converted text. If you want to convert a sequential file into a new AUGMENT file, you must first create the new AUGMENT file with the Create File command, and then use the Create Augment command to do the conversion. You then have the choice of whether to break statements after one or two return characters in the sequential file, or you have the third option of Assembler. 15D3

Breaking after one return character makes each line of the sequential file a new AUGMENT statement; breaking after two looks for two return characters in a row (i.e. a blank line) before ending one AUGMENT statement and beginning another. The third option, Assembler, will break statements after each return character, but will convert the paragraphs into statements all of the same level. No attempt to impose AUGMENT hierarchical structure will be made. 15D4

Thus if you are creating a sequential file with the intention of eventually converting it to AUGMENT, the best way is to insert two return characters at the end of each paragraph (statement). 15D5

AUGMENT will try to guess how to do the level adjustments based on the indenting in the sequential file. If each level in the sequential file is strictly indented three spaces compared to the last one, this conversion technique will work well. If the sequential file was created without AUGMENT in mind, there are likely to be many places where the relative indenting does not come out right. 15D6

If the paragraphs in the sequential file were typed with no blank lines between them, sometimes it is easier to create the AUGMENT structure using only one return character between the statements, and then use the Append All command to append all the statements in the groups forming the actual paragraphs. This technique can take a long time if the file is large. 15D7

If you have control of the creation of the sequential file that is planned to be converted eventually for AUGMENT, make it look like an AUGMENT file printed with viewspecs "y". Then use the command "Create Augment ... (using) Two (<RET>s to end statement)". 15D8

The following is a special trick that is often quite useful. Suppose you have an AUGMENT file that does have structure, and for some reason you want to get rid of the structure. This can be important sometimes for sorting purposes, since the Sort command only sorts statements at the same level. You can simply create a sequential file from the AUGMENT file, but with viewspec "B" on (no level indenting). Then use the Create Augment command to recopy the new sequential file back into another AUGMENT file. The sequential file will have no leading spaces, so the new AUGMENT structure will have nothing but top-level statements. 15D9

When you log into Executive, you have created an Executive job. Almost all of the time, you will be running a single job, although in some cases it is possible to run more than one. Running only one job is not much of a restriction -- it is possible to do many things at once in a single job. This section describes how to control your job -- how to run more than one program, how to switch your job's attention to a different program, and so on. 16A1

Normally, a job is attached to a terminal. In other words, the characters typed on the terminal go to the job, and some of the output from the job goes back to the terminal (some things may also be written into files, etc.). Certain types of jobs do not require any user interaction, and there is really no reason that they need to be connected to any terminal to run. All of the input and output go to files, and it is silly to waste a terminal connection to run those jobs. 16B1

Jobs running without benefit of an attached terminal are called "detached jobs". Sometimes jobs get detached accidentally, too. If your network connection breaks down, or if you pull the plug on your terminal, your job will become detached. When this happens, the processing of your job stops, but the job is not logged out. 16B2

It is possible to reattach to your detached job and continue as if nothing had happened. If you do not reattach to your job, it will be automatically logged out after 15 or 20 minutes. A normal job will also be automatically logged out after that long if no characters are typed to it. If you have refused autologout, your detached job will stay around forever or until the system comes down, whichever comes first. 16B3

You can intentionally detach a job by issuing the Executive command "detach". This is sometimes a good thing to do if you really need a different job (you need to log in as someone else, for example), if you want to log into a different computer, or if you want to run the same job on a different terminal. The reason that you would detach rather than log out is that for some reason, you would like to come back to exactly where you were before you detached. 16B4

If your job has become detached (either accidentally or intentionally), you can use the Executive "attach" command to reconnect to it. Suppose your user name is "oedipus" and your password is "rex". Type the following at the Executive "@" sign to reattach: 16B5

The password will not be echoed, as usual. You will then be asked for your Executive job number, and you can just press <RET> if there is only one such job. The case where there is more than one detached job is discussed later. 16B6

If you detached intentionally, you will know the exact state of your job, and you know how to continue. If your job was detached accidentally, you may not know exactly what its condition is. In particular, if it was an AUGMENT job, when you reattach, AUGMENT continues as if nothing had happened; it has no idea anything happened -- no one typed it any characters for a while is all. For this reason, AUGMENT sees no particular reason to redraw the screen, so you should press the LOCAL RESET key on your terminal or set viewspec "F" to force a screen recreation. 16B7

Occasionally, another problem arises -- the job does not think it is detached. This happens more frequently on TYMNET than ARPANET. If this happens, you can still reattach, but the procedure is a little different. (In fact, it is possible to rip a running job away from another terminal using this method.) 16B8

First, you need to find out the Executive job number of the job. This can be done by typing: 16B9

The Executive will respond with something like: 16B10

To attach to such a job, type: 16B11

If you have more than one detached job, you can use exactly the same technique to find out the job numbers, and reattach. 16B12

When you attach to a job that is not detached, you must confirm with an extra <RET>, and a <CTRL-C> is automatically sent to the job. If you want to continue, type "continue" in the Executive. 16B13

At any time during a session, you have a certain context in which you are working. You may be in AUGMENT, you may have certain subsystems loaded, and you may be at a certain statement within a certain file. All of this information is part of your context. Your context also includes any command that happens to be executing at the time. 16C1

At any point, you can interrupt all of this by typing a <CTRL-C>. This halts any process that happens to be running, and returns you to the Executive. (Later we will see that more than one Executive may be present -- in this case, <CTRL-C> returns you to the Executive running the current program.) 16C2

This interruption does not alter your context at all -- it simply gives you the opportunity to type commands to the controlling Executive. A "continue" command typed in the Executive simply restarts everything as if nothing had happened (unless, of course, you altered your context while in the Executive). Basically, however, if you type a <CTRL-C>, followed immediately by a "continue", there will be no net effect. 16C3

There is a certain set of Executive commands that do not alter your context. Any number of them can be run, and followed by a "continue", and you can go on as if nothing had happened. Listed below are some of the more common Executive commands, together with a discussion of how each of them affects your context. 16C4

What a fork is 16D1

Using multiple forks 16D2

Simple commands 16E1

Normal programs 16E2

Ephemerals 16E3

Use the Jump (to) Locator command to find the online documentation about this subject. 16F1