@device(postscript)
@make(report)
@style(font allpostscriptfonts, size 13, spacing 1.1 line, indent 0.0 inches, rightmargin 0.8 inches, topmargin 0.9 inches, bottommargin 0.9 inches)
@modify(hd1, pagebreak off)
@begin(transparent, font souvenir, size 12)
@begin(titlepage)

@center(
@begin(transparent, font avantgarde, size 18)@i(M.I.T. Ocean Engineering) @end(transparent)@begin(transparent, font helvetica, size 18)@y(B)@end(transparent)@begin(transparent, font souvenir, size 18) @p(Project Athena)@end(transparent)
)

@bar(0)

@begin(titlebox)
@majorheading(An Introduction to Athena)

@majorheading(for Ocean Engineers)

@majorheading(Part I: The Basics)
@end(titlebox)

@center(
@researchcredit(
@p(By Ian Busch)

@p(7-321, x3-0050)
))
@p(Created: 12 June 1989)

@blankspace(-0.2 lines)
@p(Revision A.1: 21 August, 1989)

@blankspace(-0.2 lines)
@p(Revision B.1: 4 September, 1989)

@blankspace(-0.2 lines)
@p(Revision C.2: 24 August, 1990)

@end(titlepage)
@end(transparent)

@begin(transparent, font newcenturyschoolbook)

@unnumbered(Introduction)
@blankspace(1 line)

Project Athena is an MIT-wide multifunction, multiuser computer system created for undergraduates as an experiment in computer usage and applications.  It was recently expanded to allow use by all graduate students, although many have had accounts for some time.  It is a very powerful system, with a large number of available applications, and excellent workstation facilities.  Athena utilizes the UNIX@+(@y(R)) operating system and the X@+(@y(R)) window system to provide relatively easy use of a wide number of computer functions in a multi-tasking networked workstation environment.  But enough of buzzwords, and on to what it can do for you. 

In theory, students are only supposed to be using the system for course related work (ie. not funded research).  In practice, this is not necessarily the case.  

This document is intended to contain some basic information to get you started on Athena, give you an idea what is available, and steer you in the right direction if something peaks your interest.  I've tried to assemble the document so that you don't have to do a whole lot of reading to get started.  Use this guide to find out what you might want to read before beginning.

@tabset(2.5 inches)
@u(Experience@\What you might want to look at)

Used UNIX and X before   @\@i(Getting an Account on Athena [2])

@blankspace(-0.4 lines)

                         @\@i(Where to go for Help [6])


Used UNIX before         @\@i(Getting an Account on Athena [2])

@blankspace(-0.4 lines)

                         @\@i(The X Window System [5])

@blankspace(-0.4 lines)

                         @\@i(Where to go for Help [6])

Used minicomputers or PC's@\Parts 1 through 6

@tabclear()

After you've read a little of the basic stuff, try logging on and play around.  The best way to learn is experiment a little and then use this document and others as a reference for when you have questions.  This is a lot easier than trying to read through (and remember) this whole thing in one bite, no matter what the @i(@u(New York Times) Book Review) has to say about it.

There is a companion document to this one, which consists of the appendices.  These appendices contain a little more detailed information on how to use certain applications, and other general info.  Once you have successfully figured out how to log on and played for a little bit, I suggest picking up a copy of the appendices.  They are color coded in a complimentary shade of red.

Throughout these two documents, a certain syntax will be used for commands.  Information listed in @begin(transparent, font courier)@b(bold)@end(transparent) is provided by Athena on the screen to you.  
Information listed in @begin(transparent, font courier)@p(bold and italics)@end(transparent) is information that you would type verbatim into the machine as a command.  
Information listed only in @begin(transparent, font courier)@b(italics)@end(transparent) is information that will vary depending on what you wish to use the command for.








@chapter(Where Athena Is)
@blankspace(1 line)

Athena is a distributed system with clusters of workstations and printers located all over campus.  There are two types of clusters, public and private.  The Ocean Engineering cluster is a private cluster; this means that only ocean engineers are supposed to be using it.  In fact, you might check every now and then if you see someone with an armful of biology books using our equipment, ask just why they're here.  By the same token, there are private clusters for the other departments.  

There are more than 14 public clusters:

@begin(transparent, spacing -1.0 lines)
@tabset(2 inches)

Room #@\Location

@blankspace(-0.8 lines)@bar(0)

@blankspace(0.5 lines)
1-142@\Near Civil Engineering

11-113@\"The Fishbowl" on the infinite corridor

11-116@\"The Fishbowl" on the infinite corridor

11-124G@\"The Fishbowl" on the infinite corridor

@blankspace(0.5 line)
2-225@\Beats me; never been there

4-035@\Basement

4-167@\Not in the Basement

16-034@\Other end of the infinite corridor

@blankspace(0.5 line)
37-318@\Aero/Astro/Mech E

37-332@\Aero/Astro/Mech E

66-080@\"The Wedge" past biology

E51-007@\Sloan School

@blankspace(0.5 line)
W20-575@\Student Center

Barker Library (floors 5 and 6)

Hayden Library (basement)
@end(transparent)

@blankspace(1 line)

In addition, there are printers distributed all over campus.  @p(If you are going to make a really large printout, like more than 10-20 pages, please use linus, europa, plato, or bias, instead of our own printer.)  Our printer is called @i(oe).  

If you go down the infinite corridor to the first staircase, go down one floor, and cross the infinite corridor, you come to one of the offices of Information Systems.  This is where three Athena printers are located.  They are named @i(linus, europa), and @i(thesis).  Don't ask me who names them.  Anyway, if you go into I/S, and go down to the end of the corridor, you will see a counter on your right.  Behind this counter are 6 huge file drawers.  Three of them are named @i(linus, europa), and @i(thesis) (surprise, surprise).  Go over to the appropriate one, and look under your username (the output is filed alphabetically).  Take your output, thank the nice people, and be on your way. This office is open 8:00 AM to 11:30 PM Monday through Friday, and 10:00 AM to 5:00 PM on Saturday.

Almost all of the public clusters have printers located in or near them.  The closest are @i(plato) in 1-142 down by civil engineering, and @i(bias) down near the fishbowl in building 11.  These are good to know in case our printer should be on the fritz late at night or on a Sunday.  The bulletin board lists the locations and names of the other ones.










@chapter(Getting an Account on Athena)
@blankspace(1 line)

@b(@u(Registering:))

Each user on the system has an @i(account).  An account is part of the system that a user is allowed to use.  It has certain characteristics, such as a limit on the use of memory, and a mailbox to allow messages to be sent between users.  Each account has a @i(username) associated with it.  This is the account's name.  This name is used to identify the account for the purpose of mail messages and the designation of things like directory names.  
In order to gain access to an account you must know its username and @i(password).  This is what you do when you log on.


Getting an account on athena is a relatively simple proceedure.  Go to any workstation on athena, and hit any key to activate it.  In a few moments, there will be a window in the middle of the screen.  Grab the mouse next to the computer and use it to move the cross-hairs on the screen over to the square (or "button") that says "Click here to register for an account".  Once you have moved the cross-hairs there, press the left mouse button for a brief second without moving the mouse (known as "clicking left").  

In a few minutes, another window will appear, requesting information for registration.  Follow the instructions, remembering to wait no more than 90 seconds between entries.  For this reason it is a good idea to choose your password and username before you sit down.  Athena recommends usernames that consist of your first two initials and your last name like mine: irbusch -- from Ian R Busch.  However, you can use just about any combination of letters.  Some people use just there first or last name for example (Although if you have a name like John Huang, chances are both names are already taken by other users).  Once you set your username, it is difficult to change it so it behooves you not to choose something really stupid.  

Your password can be anything at all (although there may be maximum and minimum size requirements like 4 and 256 characters).  In contrast to your username, your password can be changed easily (with the @b(passwd) command).  In addition, it should also probably be something stupid that no one else would ever guess.  The concern for security here isn't due to other students, but rather with some of the more evil minded hackers.  Some of the best passwords are things like the name of the first car you owned, incorrectly spelled, in French, and written backwards (unless or course you happen to be French).  You really don't have to get that elaborate, but the stranger the better from a security point of view.

If all goes well, you should have an account available to you by noon of the next day.

@u(@b(Problems))

There are some problems that can occur while registering.  The most common is Athena telling you that it doesn't have your name in the data-base.  If this should happen, talk to your cluster manager.  If I'm not around, call Project Athena User Accounts at x3-1325.  They are both very helpful and will no doubt clear up the problem in a few minutes (Although you might not be able to register until the next day).

Other typical problems involve the picked username not being available because someone else is using it.  All I can say here is tough darts; pick another username.





@chapter(How Unix Is Structured)
@blankspace(1 line)

A persons account is a collection of @i(files) organized by an @i(operating system).  These files can be text documents, programs, directories, or other types.  Directories are locations in the memory where other files are stored.  The UNIX operating system uses a hierarchial structure with directories based within directories.  The best way to imagine it is to think of an upside-down tree, where the "highest" levels are at the trunk, and the "lowest" levels of directory are the ends of the branches.  The full name of a directory or file is called the @i(pathname), and is a list of every branch in the tree used to identify a particular file, from the highest level on down.

@section(Basic Structure)
@blankspace(1 line)

The structure of UNIX is very similar to that of VMS.  Of course if you've never used VMS then that tid-bit of knowledge won't help you too much.  The major difference (for you VMS people) is that UNIX is not machine specific.  In other words, you don't have to know @i(physically) where some file is stored (ie. by machine name)  in order to be able to get to it.  This is a tremendous bonus on a distributed system like Athena.  For example, all of my files are stored on a machine named Odysseus over in building E40.  But my complete pathname is "/mit/irbusch", notice that Odysseus doesn't come into it at all (He should mind his own business anyway).

The structure of the UNIX operating system is like a gigantic tree as shown in Figure 3-1.  The highest level is known simply as "/".  All of the student accounts are in a directory called "/mit".  Some other useful files are in another high level directory called "/usr".  Each of our home directories looks like a file contained in the directory above it.  This means that if you were to look at the directory "/", you would see a bunch of filenames.  Among them would be @i(mit) and @i(usr).  

In a similar fashion, our home directories look like files within "/mit".  Therefore, the full name, or @i(pathname), of my home directory is "/mit/irbusch".  Each user may want to create @i(subdirectories) within their home directory.  You usually do this to organize the files (It sometimes gets tough to see what your doing if you have 3000 files floating around in one directory).  As an example I have a subdirectory with all of my thesis information in it.  
It's called, appropriately enough, "/mit/irbusch/Thesis.dir".  
I have another one with all of my International Shipping homework and papers in it called 13.69.dir.   You can see where this leads.  I've ended up with around 30 subdirectories in my account, mostly because after about a dozen files in any one directory, I start to get confused.  Other people have as many files as I do, but only one or two directories.

@blankspace(0.6 lines)
@figure[
@begin(transparent, spacing 0 lines)
@tabclear()
@tabset(1.5 inches, 3.5 inches, 5 inches)
@begin(transparent, font courier, size 12)
/@\mit/@\irbusch/@\Thesis/
@end(transparent) 

@bar(0)

@begin(transparent, font souvenir, size 10)
The top level  @\The directory that @\My home     @\The directory where

directory.     @\contains all of the@\directory   @\I keep info about

               @\student accounts   @\            @\my Thesis

@end(transparent) 
@tabclear()
@end(transparent)
]

@blankspace(1 line)

@figure[
@center(@graphic(postscript="dirstruct_3.idraw",boundingbox="1.25 inches, 1.5 inches, 6.75 inches, 9.0 inches"))
@tag(dirstruct)
@caption(Directory Structure)
]

Please not that you do not need to use the .dir extension in your directory names.  I do this myself so I can quickly see what files are just files and what files are directories.  Other people do this by capitalizing the first letter of their directory names.

The directory structure is shown in figure 3-1, with the directory and subdirectory names.  One thing this figure illustrates is the true tree nature of a directory.  If I wanted to move from my "inbox" subdirectory to my Thesis directory, I would have to move up two levels and then back down again one. 


@section(Lockers)
@blankspace(1 line)

In addition to the structure of your account (home directory and sub-directories) you can also use other parts of the system.  This is done by @i(attaching lockers).  Attaching lockers can best be thought of as attaching a new branch to the directory tree.  This new branch can have subdirectories as well.  All lockers are "attached" to the tree at the same level as a user's account (see figure 3-1).

One example is the athenadoc locker.  This "locker" has a great many files used by a large number of students.  Any number of students can then attach this locker and use its files (like viewdoc, for example).  

In addition to attaching these lockers, which don't necessarily belong to anyone, you can also attach other users.  If I were to attach "tkiss", I would be able to use Tom Kiss's files, provided he allowed me to by setting his protection low enough.





@chapter(Doing @i(Things) on Athena)
@blankspace(1 line)

UNIX is actually one of the oldest of the operating systems (even older than VMS), and has with it a great deal of archaic language.  If you are used to using MS-DOS or VMS, learning the vocabulary of UNIX is going to seem like learning Old English.  

If you are just learning an operating system for the first time, UNIX may at first seem like a jumble of random letters to represent commands.  Fortunately, those new to UNIX won't have the problem of accidentally typing commands in the operating system you used to use, so in some ways they may be better off.

There is one very important thing to keep in mind on UNIX.  @b(UNIX is) @p(case-sensitive).  This means that typing a command in uppercase is not the same thing as typing it in lowercase, so @b(more) does not equal @b(MORE) or @b(More).  This is really annoying at first, but you'll get used to it.

The UNIX system has an enormous number of commands available, and the list is growing.  An appendix contains a compilation, created by Norbert Doerry, of common UNIX commands.  This is probably one of the best places to look for information.  In addition, I have posted some other common commands around the room as needed.  


@section(Looking at Things)
@blankspace(1 line)

There are a couple different ways to look at files other than  editing them and printing them out:

@begin(transparent, font courier)
@b(athena%) @p(cat) @i(filename)

@b(athena%) @p(more) @i(filename)
@end(transparent)

The @i(cat) command lists a whole file on the screen similar to the type command in VMS.  The more command only displays one screenful at a time.  At then end of the screen it says "more" and tells you how much you've seen so far.  If you hit the space-bar, it will show you the next screen; the <Return> will show you one more line; hitting <q> will abort the more program and return you to the prompt.  

If you want to see the contents of a directory type @p(ls).  If you want to know everything about the contents of the directory, type @p(ls -al) for list, all files, long form.  This is equivalent to typing dirs/prot on VMS.


@section(Running Applications)
@blankspace(1 line)

Running applications in UNIX is very similar to doing it in MS-DOS (on IBM PC's).  If the file is in your directory, simply type the name of the file that you want to run and it will (if it can).  

Sometimes you may wish to run files that are not located in the directory you are currently using.  To do this, first make sure that the directory is attached, or a part of your account.  Next, type the full pathname of the file you wish to run.  For example, to run SHCP (actually the file you run is called runshcp), you could do the following:

@begin(transparent, font courier)
@b(athena%) @p(attach 13.ship)

@b(athena%) @p(/mit/13.ship/shcp/runshcp)
@end(transparent)

Actually there are better ways of running SHCP, but this example will do for now, since I can't think of a better example.  Some applications do not need the full path even though they are not located in your directory.  This is true of several of the most commonly used programs such as the text post-processors (@i(Scribe)@+(@y(R)) and @i(LaTeX)@+(@y(R))) the editor, and the compilers, among others.  For example, to compile a program in the C program language, all you need to do is type:

@begin(transparent, font courier)
@b(athena%) @p(cc) @i(filename)
@end(transparent)

Where @i(filename) is the name of the file to be compiled.


@section(Editing Files)
@blankspace(1 line)
To edit a file, use the standard Athena editor, emacs.  Emacs is similar to UNIX in that it is both very powerful, and somewhat obtuse.  For more information, see the appendix on using emacs.


@section(Printing Files)
@blankspace(1 line)


As mentioned earlier, files can be printed to a number of different printers located all over campus.  The printer in our cluster is called @i(oe) for ocean engineering.  In order to print a document to a file, use the lpr command:

@begin(transparent, font courier)
@b(athena%) @p(lpr -P)@i(printername filename)
@end(transparent)

Where lpr (for line printer) says to print and the -P is a paging command.  @i(Printername) is the name of the printer you wish to go to.  Some of the ones nearby are:

@blankspace(0.5 lines)
@begin(group)
@begin(transparent, spacing -1.0 lines)
@tabclear()
@tabset(2 inches)
Printername@\Location

@bar(0)
@blankspace(0.5 lines)

oe@\Ocean Engineering 7-321

linus@\11-226

europa@\11-226

plato@\1-142

bias@\11-116
@tabclear()
@end(transparent)
@end(group)
@blankspace(0.5 lines)

As mentioned, there are several more in other locations.  @i(Filename) is the name of the file for printing.  @p(Whatever you do, @u(please, please) make sure you don't send executable, ie. machine language, files to the printers.  They consume paper like not you would believe!)  If you do send a file you didn't want, and want to stop printing it, simply do the following.  First find out what jobs are on the printer by typing:

@begin(transparent, font courier)
@b(athena%) @p(lpq -P)@i(printername)
@end(transparent)

This will print out a list of jobs in the order they are printing that will look something like this:

@begin(transparent, size 10)
@begin(verbatim)

athena% lpq -Poe
M7-321-7.MIT.EDU...  ln03-7-321 is ready and printing
Rank   Owner      Job  Files                                 Total Size
active irbusch    0    (standard input)                      37781 bytes
1st    nhdoerry   1    (standard input)                      68523 bytes
2nd    mjhughes   6    81                                     2015 bytes
3rd    irbusch    2    HW_12.x                               10247 bytes
4th    kring      3    file.c                                12321 bytes
athena%
@end(verbatim)
@end(transparent)

I (irbusch) look and see that it is the second set that I sent it that I want to not print out.  I know this, not only because I remembered it was the second set, but that I remembered the filename was HW_12.x.  Files called "(standard input)" are usually things like @i(screendumps).  These will be described later.  Now, to get rid of the job, I look for the job number.  In my case its 2.  Then just type:

@begin(transparent, font courier)
@b(athena%) @p(lprm) @i(jobnumber) @p(-P)@i(printername) @i(username)
@end(transparent)

In my case it would look like this:

@begin(transparent, font courier)
@b(athena%) @p(lprm) @i(2) @p(-P)@i(oe) @i(irbusch)
@end(transparent)

Whatever you do, @ux(@b(do not turn of the printer while it is running!))  Similarly, do not turn it off even if you have set it to offline.  Use the above command.  Sometimes it takes the printer a minute to get the idea, but that's OK.  It's better to lose $1.00 in paper than break a $5,000 laser printer and have the digital guys come out to fix it at $300 per hour.

Starting in January of 1990, Athena will begin to charge a fee for the use of the public printers.  This will only apply to printouts made after the first 500 sheets each semester.  This may not sound like a heavy limit, but it could be.  In addition, the department may start putting limits on the ammount of free hardcopy available.  Because of this, it is a good idea to get to know some ways of conserving paper.  Each of these will be detailed later on, but for now, remember:
@begin(itemize)
@b(lpr -Poe -h) @i(filename) -- will omit the coversheet.

@b(/mit/athenadoc/viewdoc) @i(filenane) -- allows previewing of postscript documents
@end(itemze)








@section(Moving Around)
@blankspace(1 line)

To move around through directories, use the change directory command (just like on an IBM):

@begin(transparent, font courier, size 12)
@b(athena%) @p(cd) @i(pathname)
@end(transparent)

Where @i(pathname) is the path of the directory you want to go to.  There are a few short-cuts to this method.  The "~" symbol (The shift of the key next to the 1) is a shorthand for you're account's home directory.  So, if you want to return to your home directory, all you need to type is:

@begin(transparent, font courier, size 12)
@b(athena%) @p(cd ~)
@end(transparent)

Similarly, if I wanted to change to my TAship directory, I could type:

@begin(transparent, font courier, size 12)
@b(athena%) @p(cd ~/TAship.dir)
@end(transparent)

You can refer to files by using the "~" in pathnames too.

Another shorthand is available if all you want to do is move up a level in the directory structure:

@begin(transparent, font courier, size 12)
@b(athena%) @p(cd ..)
@end(transparent)


@section(Some Basic Commands)
@blankspace(1 line)

@b(cp) @y(M) @i(Copies a file) -- When you use this command you can make additional identical copies of a file with different filenames and even in different directories.  For example if I wanted to make a copy of the file Howdy.mss and call the new one Hello.mss, and keep them in the same directory, I would write:

@center(@b(cp Howdy.mss Hello.mss))

To copy Howdy from my subdirectory text.dir into my subdirectory TAship.dir I would type:

@center(@b(cp /mit/irbusch/text.dir/Howdy.mss /mit/irbusch/TAship.dir/Hello.mss))

@b(mv) @y(M) @i(Moves a file) -- The equivilent to @i(rename) on VMS systems.  It works just like @b(cp):, @b(mv) @i(old_name) @i(new_name).


@b(rm) @y(M) @i(Deletes a file) -- Just type @b(rm) @i(filename) and its gone forever.

@b(passwd) @y(M) @i(Changes your password) -- Just follow the instructions.


@section(Getting out of @i(Things))
@blankspace(1 line)

There are four things you may wish to get out of:  Athena, a window, some error, or a program thats running.   To log out of Athena you can simply type logout or hit the @i(logout) button in the lower right-hand corner of the screen with the left mouse key.  If athena doesn't want to let you go, type "logout" twice in a row, and it will get the idea.

You will no doubt eventually run into occasional problems on Athena.  One of these is a program that continues to run even when you don't want it to.  Be cautious before undertaking extreme action as what you think must be a crashed program, might in fact be the slow speed of the network on a busy evening.  Unless you are sure of the problem, you should always wait at least 1-2 minutes.  Most programs will allow you to leave by typing such things as "quit", "exit", or "q".  Sometimes the command to get out is more burried than that and you will have to find it through a help screen.  Help screens can usually be brought up (if they are available at all) by "?", "PF1" (on the keypad), "Control-h", or "/". 

Sometimes a program will end up in some kind of infinite loop and have to be terminated with extreme prejudice.  There are a few ways to get rid of this pesky problem.  Usually the best way to return to a prompt is to type @b(Control-c).  This is a relatively "clean" kill in that the application is usually terminated forever.  Another method is @i(Control-z) but this is quite a bit messier, in that it leaves a stopped job that you will just have to kill off later.  

If your dificulties cannot be solved even by this, then ask me or other helpful folks such as Norbert Doerry to help you out.  IF no such person is around, consult the chapter on Where to go for Help and Information and the appendix on Useful Commands in Unix.


@section(Other Techniques)
@blankspace(1 line)

There are many other powerful and useful features in UNIX that you may wish to become introduced to.  Some of these involve the use of @i(pipes) to redirect the output of a process, wildcards for parts of filenames, aliases for certain commands, and a command history to let you retrieve frequently used commands with the arrow keys.  For information on these slightly more advanced techniques, I'l  refer you to the section on where to go for help, and part II of this document.












@chapter(The X Window System)
@blankspace(1 line)

The @b(X)@+(@y(R)) window system is what allows Athena to @i(multi-task).  Multi-tasking is the ability of a terminal to perform more than one function at a time.  Athena provides multi-tasking through the use of multiple @i(windows).  If you are used to Macs, then windows is old hat to you.  For those of you who haven't, windows simply divide up the screen into a number of smaller "screens" (each called a window), so that you can do different things in each.  In essence, it allows you to appear to be using more than one computer at the same time.

As an example, let's say you have to write up a ship design report.  You could have the following windows open at the same time:

@begin(itemize)
An @b(emacs) window to do your text editing in (where you actually type up the report)

A UNIX window to run @b(scribe) allowing you to post-process as you write.

A window running the @b(2020) spreadsheet with all of your weight and moment calculations on it.

Another window running @b(2020) with speed and power calculations.

A window running SMP to give you seakeeping results.

And so on ...
@end(itemize)




@section(Making Windows)
@blankspace(1 line)

@b(@u(Standard Method))

To create a new window, simply type:

@begin(transparent, font courier, size 12)
@b(athena%) @p(xterm &)
@end(transparent)

To create another window simply type @b(xterm &) at the prompt.  If you omit the @b(&), it will not let you continue to use the old window.  In a short amount of time (anywhere from 5 seconds to 5 minutes depending on how many people are using Athena), a small box will appear in the upper left hand corner of your screen with the words "xterm:  0x0" in it.  In addition your cursor will change to a hollow box and the mouse pointer will change into an upside-down "L".  This is prompting you to make the window.  Move the mouse to where you want the upper left hand corner of the new window to be and hit the left mouse key.  The left key makes an 80 column x 25 line window, the size of a standard IBM compatible screen.  

@b(xterm -rv &) will allow you to create a window in reverse video: white characters on a black background.

@b(@u(The Background Menu))

Another way of creating windows is to move the mouse to the background area of the screen (the gray part), and hold down the left mouse button.  You will then get a small menu like that shown in figure 4.  While still holding down the left key (don't let go yet), pull the mouse down (this is known as @i(dragging the mouse)) to where it says "New Window" and now release the key.  The menu will disappear and in a few minutes the window prompt will appear in the upper left hand corner of the screen.  Now create the window normally.

This is also a way to get out of a window if it has gotten locked up by a program.  Bring up the background menu in the same way as listed above, and then move the cursor to "KillWindow".  When you release the middle mouse key, your cursor will have changed to a picture of a hand with a pointed finger.  Move the hand to the window you want to kill and click the left mouse key.

@begin(group)
@center(@graphic(postscript="background_4.idraw",Boundingbox="1.3 inches, 6.2 inches, 5.0 inches, 10.0 inches"))

@center(@b(Figure 4: Background Menu))
@end(group)


@section(Commands)
@blankspace(1 line)

When windows are overlapping, some appear to be "above" others.  This is known as a "stack" of windows.  "Push" always implies pushing a window down underneath others, while pulling a window pulls it closer to the top.

If you are tired of looking at a window that is taking up a lot of room, you can turn it into an @i(icon).  An icon is a small representation of the window.  If you are shuffling several windows around on the screen at once, then iconifying them is a handy way to clean up the screen.

Here is a list of the window managaer commands.  These commands are for the current window manager called MWM for Motif@+(@y(R)) Window Manager. 

@blankspace(1 line)
@begin(group)
@begin(transparent, size 10, spacing -0.9 lines)
@tabclear()
@tabdivide(5)
              @\THE WAY       @\THE WAY                     @\@\ANOTHER WAY

@bar(0)

Move          @\C-M-MB3-drag  @\titlebar-drag               @\@\M-F6

Resize        @\C-M-MB1-drag  @\edge/corner-drag            @\@\M-F7

Iconify       @\M-MB2-click   @\iconify button              @\@\M-F8

Deiconify     @\M-MB2-click   @\MB1 double-click            @\@\M-F5

Shufl Up      @\M-MB3-click   @\Any MB click on edge/title    @\M-F12

Shufl Dwn     @\M-MB1-click   @\(nothing analagous)         @\@\M-F10

@blankspace(0.6 lines)
LEGEND:   @\M = META or COMPOSE key       @\C = CONTROL key

          @\MB1 = Mouse-button-1          @\ESC = ESCAPE (F11 on vax kbd)

          @\MB2 = Mouse-button-2 (On 2-button mouses, hold down both MB1 and MB2)

          @\MB3 = Mouse-button-3
@end(transparent)
@end(group)

@begin(itemize)
@u(iconify button:)  On the titlebar, there are two small boxes on the right
        side.  The one with a picture of a small box in it, when
        pressed, will iconify the window.

@u(maximize button:)  The other button on the far right of the titlebar has a
        large box in it.  Pressing this button will make the window as
        large as the screen, or as big as the program will allow the
        window to become.  Pressing it a second time will return the
        window to its former size and place.

@u(window menu:)  The left side of the titlebar has a button with a rectangle
        in it.  Holding down this button reveals a pull-down menu that
        contains all of the window operations (moving, resizing, etc.)
        as well.  

@u(Shift-ESCAPE:)  While in a window, this key combination will pop-up the
        window menu.  On the root window (gray background), this will
        pop-up the root window menus.  You can use the arrow keys to
        traverse these menus.  The escape key is only available on the IBM 
        RT workstations.

META-up_arrow/down_arrow:  Rotate window stack up/down.
@end(itemize)

Much more
information is available on request (e-mail to jefft), or by reading the (lenghty!) man
page -- simply type:

@begin(transparent, font courier)
@b(athena%) @p(man mwm)
@end(Transparent)





@section(Special Windows)
@blankspace(1 line)

Some programs that generate windows will not allow you to change them in the way that you probably would wish.  These programs include: viewdoc, xcalc, xclock and others.

@b(xclock &) @i(Creates a clock on the screen) -- This command will create a clock on the screen.  It is placed with the mouse keys (see Making Windows).  There are several options available:

@begin(itemize)
@b(xclock -rev &) makes a clock in reverse video.

@b(xclock -update 1 &) gives you a second hand.

@b(xclock -digital &) gives you a digital clock.

@b(xclock -chime &) will ring twice on the hour and once on the half-hour.
@end(itemize)

@\You can combine these commands, for example: "xclock -rev -update 1 &".  The clock will automatically disappear when you log out.

@b(xcalc &) @i(Creates a calculator) -- This command creates a calculator on the screen that you can operate by pressing the left mouse button on the calculator "keys".  You can't change the size, so just place it with the left mouse button.  You can make an HP calculator with @b(xcalc -rpn &), but don't trust it for calculations involving parentheses.



@section(Getting out of Windows)
@blankspace(1 line)

The usual way to get out of a window is the exit command:

@b{exit} -- @i{Gets you out of a window} -- Typing "exit" will simply remove the window that you typed it in.  @i(You will still be logged on even if you "exit" out of your last window.)

If you want to log out, type @b(logout) at the prompt.










@chapter(Where to Go for Help and Information)
@blankspace(1 line)

There are a great number of places to get help with Athena related problems.  These include:

@begin(itemize)
Me, the cluster manager, here in 7-321.  My phone number here is x3-0050 (253-0050).  Sometime in the near future, I will be posting a schedule of my typical office hours.  

The Athena Consultants.  They can be located down on the first floor of building 11, or by calling x3-4435 or x5-6711.

The new "help" command provides (or will provide) access to documentation from both the athenadoc documents and the olc stock answers (described below).  This system is still in its infancy, so the traditional methods are still listed below.

The on-line consultants.  Simply type the letters "olc" at the athena% prompt.  This system is pretty self-explanatory.  Because they've answered so many questions in the past the kind people at olc have recorded answers to the most common questions.  To get these, first enter olc, and then type answers instead of ask.

@begin(multiple)
There is a great deal of documentation on Athena itself, in the form of the @i(Essential Athena) documents.  These can be gotten to by attaching the athena documentation locker:

@begin(transparent, font courier, size 12)
@b(athena%) @p(attach athenadoc)

@b(athena%) @p(cd /mit/athenadoc)

@b(athena%) @p(more README)
@end(transparent)


Included in this is information on UNIX, Scribe, using C, Fortran, and Scheme on Athena, Mail messages, and much more.  These documents go into far more detail than the appendices at the end of this report.  These documents can be purchased at graphic arts in the basement of building 11 for a couple dollars each, or printed to any postscript printer.
@end(multiple)


@begin(multiple)
If you need help finding out what a command does, type:

@begin(transparent, font courier, size 12)
@b(athena%) @p(man) @i(command)
@end(transparent)

where @i(command) is the command you are interested in.  A listing of many of these commands can be found in the notebook labelled "UNIX PROG. MANUAL (ABRIDGED)."
@end(multiple)

@begin(multiple)
If you think you know what you want to do, but don't know the command, then type:

@begin(transparent, font courier, size 12)
@b(athena%) @p(apropos) @i(keyword)
@end(transparent)

where @i(keyword) describes the concept you are interested in.  This will produce a list of commands in UNIX that involve this keyword. 
@end(multiple)

Any of the students from previous years.  Remember, these people have important work to do themselves, and are not being paid to help you out (as opposed to the consultants or myself).  Norbert "Norbs" Doerry is the resident expert on Athena, UNIX, C, and just about anything else in this room.  If he can't tell you or send you on the right track, chances are there is no answer.

There is a tremendous amount of documentation available in 7-321.  We have the manuals on virtually every major piece of software.  Most things that aren't in the rack can be obtained on loan by asking me (Ian).  This includes the complete Essential series offered by Athena and Graphic Arts in hardcopy format.

SIPB (Student Information Processing Board):   This group is newly relocated over to the fifth floor of the student center, in room W20-525 or there-abouts.  These people are a bunch of 'hackers' who probably know more about ATHENA than the ATHENA people themselves.  They are usually very eager to answer questions and provide help.

@end(itemize)
@end(transparent)