Next: 7. Programming Up: Introduction to Unix & Previous: 5. Learning More Contents
Subsections

- 6.1 Getting Information on SDF
- 6.2 COM Mode
  - 6.2.1 COM Commands Discussion
  - 6.2.2 COM Session Example
  - 6.2.3 What to Do if You Are Caught in the Newbie Loop
  - 6.2.4 COM History
- 6.3 Bulletin Board

# 6. Super Dimension Fortress

Here is some quick reference information about using Super Dimension Fortress (SDF). I'm not a member of SDF's staff, so the information here is not definitive. If you find a discrepancy between what I say & how things actually work on SDF, it's an error in what I've said, not in how SDF behaves.

# 6.1 Getting Information on SDF

Use the faq or help commands to get information about SDF. These are not standard unix programs. They are specific to SDF.

The help command mostly gives you lists of other commands. If you type ```help`'', you'll see a menu like this:

    SDF Help System - v8, 1993 - sdf!smj

     [a] Directory and File Utilities
     [b] Email Information
     [c] USENET Information
     [d] User and Process Information
     [e] Tutorials and Very Useful Commands
     [f] ARPA Services (internetworking)
     [g] Homepage, VHOST and MetaARPA Utilities

     [q] Quit SDF Help System

    Your Choice?
    For more help, type 'faq'
    For a list of basic UNIX commands, type 'unix'
    to remove your account, type 'delme'

Most of the letters in the menu will give you lists of commands. After you quit the help program with ```q`'', you could run the commands or read more about them in the online manual I discussed earlier. Some of the programs are specific to SDF & are not discussed in the man. SDF's excellent com program is an example of a program that is not discussed in the man.

To me, the faq program is more useful. In it, you can find short explanations of unix file permissions, uploading & downloading, SDF's policies, & the history of SDF.

To enter the faq, type ```faq`'' on the command line, & the faq program gives you a list of sections. This is faq's main menu. You can exit by typing ```q`'' here. If you type ```g`'', it will ask you for the name of a section. You enter a section name & press return, & you'll see the section's menu.

In a section's menu, you have a numbered list of questions or topics. If you type ```g`'', & press return, you'll see main menu again. If you type ```t`'', you'll be prompted for the number of a question or topic. Type that & press return. You should type the number exactly as it appears in the menu, including leading zeros.

Some things you can learn from the faq include:

- SDF's policies (& prices, methinks)
- brief history of unix

#
6.2 COM Mode

SDF has its own chat system, called `com`. It's like a stripped-down IRC, but much cooler than IRC because people actually talk, & you don't get unwanted pop-up download files & you don't have tons & tons of bots waiting to download ``warez''. Anyway, `com` is like IRC except that `com` is cool.

To use com, type ```com`'' on the command line. You'll be plopped into the lobby, which is the default room.

Com uses single-key commands mostly. If you are new to `com`, you might want to read COM Command Discussion in this same article. If you are having trouble exiting from the `com` program, then you definitely need to read COM Command Discussion.

Table 6.1 shows the most frequently needed `com` commands.

Table 6.1: The most frequently needed commands for `com`

key | meaning
h | Get a list of all the commands
? | Get a list of all the commands
space bar | Enter text that you ``say'' into the room
return | Enter text that you ``say'' into the room
g | goto another room
q | Quit COM Mode

Also, from COM Mode, you can compete with others in games of Nethack, Netris, & some others. If you can master the ``h'' command in COM, it will show you the commands for playing these games.

##
6.2.1 COM Commands Discussion

The `com` commands are hot. By that, I mean that you type a command character, & `com` immediately takes action. You must be careful to type only the command character you intend. If you type other characters along with the character you intend, one of those other characters might be interpreted as a command, & the character you intend will be interpreted as an argument to that command. It might sound like I'm being pedantic, but people who are new to `com` often have this problem.

Table 6.2 shows the proper sequence of steps for entering a command in `com`. It assumes you are already running `com` & that you are not currently processing any `com` commands. You are just reading the text in the room.

Table 6.2: The proper & detailed sequence of events for executing a command in `com`

Step number 4 in Table 6.2 is critically important & deserves further discussion. In step number 4, you touch (or ``type'') the command key. You do not touch (or type) any other keys on your keyboard or on any other keyboard. You don't need to ``enter'' the command by typing the Return or Enter key on your keyboard; `com` will acknowledge your command key immediately.6.1

A common error for new users is to type the Return (or Enter) key after they type the command key. `Com` executes the command key fine, then it notices the Return key. Return is a command, so `com` executes it. The Return command gets you a prompt so that you may enter text that you ``say'' for other people to ``hear'' in the room. Because of the Return key, `com` is not interpreting the new user's keystrokes as commands.

Then the new user tries to type another command, such as the ``q'' (quit) command, but `com` interprets it as text to say into the room. The new user is under the impression that he needs to end commands with Return, so he does that, which causes `com` to print ``q'' into the room for everyone to see. The new user is confused about why his command doesn't execute, so he types ``h'' & Return again. The ``h'' is interpreted as a command & gets him a menu, but the Return is also interpreted as a command & puts him into enter-a-line-of-text mode. He sees the ``q'' command in the menu, types it & Return, & the cycle repeats.

All of this discussion may seem silly to most people, but a lot of new users have amazingly huge amounts of trouble when they learn to enter a command into `com`.6.2

## 6.2.2 COM Session Example

Let's walk a new user named newbie through his first session in `com`.

1. Newbie starts on the unix command line.

2. Newbie enters COM Mode by typing ```com`'' & pressing the Return key.

3. Newbie might have to wait a few seconds, but she eventually sees `com` start. (I think new users see a menu of the `com` commands & have to answer Yes that they have read & understood the menu.) After `com` starts, Newbie will be in the lobby & will see a list of the people in that room. (The lobby is the default room & is where most of the chatting happens.)

4. Newbie wants to say hello to everyone, so she types the Space Bar & waits until she sees a ```[newbie]`'' prompt. Then Newbie types ``Hi all. I'm new.'' & then types the Return key.

5. Everyone in the room will see ```[newbie] Hi all. I'm new.`''.

6. Newbie is doing well so far, but now let's have her make a mistake.

7. Newbie wants to leave `com`, but she can't remember the command, so she types ``h'' to get a menu & pressed Return. This was a mistake. Newbie should have typed ``h'' alone & not pressed Return.

8. `Com` sees Newbie's ``h'' command & prints the help menu. That's good, but `com` also sees Newbies Return & assumes Newbie wants to ``say'' a line of text into the room. So `com` prints a ```[newbie]`'' prompt & waits for Newbie to type some text, but Newbie is busy reading the help menu & doesn't notice the prompt.

9. Newbie sees the ``q'' (quit) command on the help menu & types ``q'' & then Return. This is a double mistake. `Com` thinks Newbie is typing a line of text to say into the room, so her ``q'' is not interpreted as a command. Also, Newbie is still under the incorrect belief that she must end `com` commands with a Return.

10. Because of Newbie's mistake in the previous step, `com` prints ```[newbie] q`'' into the room.

11. Newbie is confused that her ``q'' command didn't work, so she types ``h'' & Return. This takes her back to step 7.

    She'll repeat this who knows how many times. Other people in the lobby will notice her problem & try to help, but Newbie has to go through the error many times before she stops typing Return after her commands.

    The problem is compounded by `com`'s modality & Newbie's failure to realize that `com` is modal. Sometimes, `com` is waiting for Newbie to type a command. Some commands are single key. (The ``q'' & ``h'' commands are examples.) Other commands wait for Newbie to type something, & during that time, `com` does not interpret her keystrokes as commands. (The Space Bar and Return commands, both of which are for saying text into the room, are examples.)

    The other people in the room see what Newbie is going through, but there isn't much they can do because they can't see Newbie's screen & help her figure out whether `com` is waiting for her to type a command or waiting for her to type text. What's more, whenever they say something like ``Type h by itself'', Newbie types an ``h'' & then a Return. So Newbie keeps going around & around.

12. Eventually, Newbie figures it out while `com` is waiting for her to type a command. At this time, Newbie types ``q'' (& does not type any other characters at all).

13. Newbie might have to wait a few seconds, but she eventually sees `com` print an ``Unlinking tty'' message, & then Newbie is dropped back into her unix command line.

## 6.2.3 What to Do if You Are Caught in the Newbie Loop

The problem is that `com` is modal & new users sometimes fail to realize that.

What does it mean for a program to be modal? It means that sometimes, `com` is waiting for you to type a command, & sometimes it is waiting for you to type arguments to a command. Some commands are single key. (The ``q'' & ``h'' commands are examples.) Other commands wait for you to type something, & during that time, `com` does not interpret her keystrokes as commands. (The Space Bar and Return commands, both of which are for saying text into the room, are examples.)

If you find yourself in the `Com` Newbie loop, here's how to get out of it. Follow the exact steps from Table 6.3. Type only what it says to type. Do not type anything else. Do not type Return unless a step in the table says to type Return.

Table 6.3: The steps to get out of the `Com` Newbie loop. Do exactly what the steps say. Do only what the steps say. Do not type anything else.

Here's why the steps in Table 6.3 work:

1. If `com` is waiting for you to type a command, then you could type the command anyway, but you type Space, which gets you a prompt (`com` isn't interpreting commands). Then you type Return, which ends that prompt. So now `com` is waiting for a command again. So the Space Bar & Return sequence was unnecessary, but it did not harm. (People in the room won't even see it because if you try to ``say'' an empty line, `com` doesn't print anything.)
2. If `com` has prompted you & is not interpreting your commands, the Space Bar won't do anything useful, but the Return key will end that prompt. If you had mistakenly typed Return earlier & `com` was waiting for you to say something into the room, the Space Bar will do nothing, but the Return will end that mode, & `com` will now wait for you to type a command.. (If you had typed things before the Space Bar, you will ``say'' them into the room.)

## 6.2.4 COM History

I have heard that early versions of COM Mode were fairly simple shell scripts that ran tail on a common file. Excellently unixly elegant. COM Mode is in about version 6 now, & it works across a bunch of computers networked at SDF, so I don't know if it's still just some shell scripts.

# 6.3 Bulletin Board

If you type ```bboard`'', you'll enter the bulletin board. Its commands resemble those of the faq:

g
  Prompts you for a section name, which you type. Then takes you to that section.
t
  From a section's menu, prompts you for a message number (which you must enter exactly, including leading zeros). Then it prints the message & all replies to your screen.
q
  Quits the bulletin board.

Next: 7. Programming Up: Introduction to Unix & Previous: 5. Learning More Contents