HOW TO GET STARTED
This section provides the basic information you need to get
started on UNIX: how to log in and log out, how to communicate
through your terminal, and how to run a program. See ``UNIX for
Beginners'' by Brian W. Kernighan for a more complete introduc-
tion to the system. Logging in. You must call UNIX from an ap-
propriate terminal. UNIX supports ASCII terminals typified by
the TTY 37, the GE Terminet 300, the Dasi 300, and various graph-
ical terminals. You must also have a valid user name, which may
be obtained, together with the telephone number, from the system
administrators. The same telephone number serves terminals oper-
ating at all the standard speeds. After a data connection is es-
tablished, the login procedure depends on what kind of terminal
you are using.
300-baud terminals: Such terminals include the GE Terminet
300, most display terminals, Execuport, TI, GSI, and certain
Anderson-Jacobson terminals. These terminals generally have
a speed switch which should be set at ``300'' (or ``30'' for
30 characters per second) and a half/full duplex switch
which should be set at full-duplex. (This switch will often
have to be changed since many other systems require half-du-
plex). When a connection is established, the system types
``login:''; you type your user name, followed by the ``re-
turn'' key. If you have a password, the system asks for it
and turns off the printer on the terminal so the password
will not appear. After you have logged in, the ``return'',
``new line'', or ``linefeed'' keys will give exactly the
same results. TTY 37 terminal: When you have established
a data connection, the system types out a few garbage char-
acters (the ``login:'' message at the wrong speed). Depress
the ``break'' (or ``interrupt'') key; this is a speed-inde-
pendent signal to UNIX that a 150-baud terminal is in use.
The system then will type ``login:,'' this time at the cor-
rect speed; you respond with your user name. From the TTY
37 terminal, and any other which has the ``new-line'' func-
tion (combined carriage return and linefeed), terminate each
line you type with the ``new-line'' key (not the ``return''
key).
For all these terminals, it is important that you type your name
in lower-case if possible; if you type upper-case letters, UNIX
will assume that your terminal cannot generate lower-case letters
and will translate all subsequent upper-case letters to lower
case. The evidence that you have successfully logged in is that
the Shell program will type a ``%'' to you. (The Shell is de-
scribed below under ``How to run a program.'') For more informa-
tion, consult getty(VIII), which discusses the login sequence in
more detail, and tty(IV), which discusses typewriter I/O. Log-
ging out. There are three ways to log out:
You can simply hang up the phone. You can log out by typing
an end-of-file indication (EOT character, control ``d'') to
the Shell. The Shell will terminate and the ``login: ''
message will appear again. You can also log in directly as
another user by giving a login command(I).
How to communicate through your terminal. When you type to
UNIX, a gnome deep in the system is gathering your characters and
saving them in a secret place. The characters will not be given
to a program until you type a return (or new-line), as described
above in Logging in. UNIX typewriter I/O is full-duplex. It has
full read-ahead, which means that you can type at any time, even
while a program is typing at you. Of course, if you type during
output, the output will have the input characters interspersed.
However, whatever you type will be saved up and interpreted in
correct sequence. There is a limit to the amount of read-ahead,
but it is generous and not likely to be exceeded unless the sys-
tem is in trouble. When the read-ahead limit is exceeded, the
system throws away all the saved characters. On a typewriter in-
put line, the character ``@'' kills all the characters typed be-
fore it, so typing mistakes can be repaired on a single line.
Also, the character ``#'' erases the last character typed. Suc-
cessive uses of ``#'' erase characters back to, but not beyond,
the beginning of the line. ``@'' and ``#'' can be transmitted to
a program by preceding them with ``\''. (So, to erase ``\'', you
need two ``#''s). The ASCII ``delete'' (a.k.a. ``rubout'') char-
acter is not passed to programs but instead generates an inter-
rupt signal. This signal generally causes whatever program you
are running to terminate. It is typically used to stop a long
printout that you don't want. However, programs can arrange ei-
ther to ignore this signal altogether, or to be notified when it
happens (instead of being terminated). The editor, for example,
catches interrupts and stops what it is doing, instead of termi-
nating, so that an interrupt can be used to halt an editor print-
out without losing the file being edited. The quit signal is
generated by typing the ASCII FS character. It not only causes a
running program to terminate but also generates a file with the
core image of the terminated process. Quit is useful for debug-
ging. Besides adapting to the speed of the terminal, UNIX tries
to be intelligent about whether you have a terminal with the new-
line function or whether it must be simulated with carriage-re-
turn and line-feed. In the latter case, all input carriage re-
turns are turned to new-line characters (the standard line delim-
iter) and both a carriage return and a line feed are echoed to
the terminal. If you get into the wrong mode, the stty command
(I) will rescue you. Tab characters are used freely in UNIX
source programs. If your terminal does not have the tab func-
tion, you can arrange to have them turned into spaces during out-
put, and echoed as spaces during input. The system assumes that
tabs are set every eight columns. Again, the stty command(I)
will set or reset this mode. Also, there is a file which, if
printed on TTY 37 or TermiNet 300 terminals, will set the tab
stops correctly (tabs(V)). Section tty(IV) discusses typewrit-
er I/O more fully. How to run a program; the Shell. When you
have successfully logged into UNIX, a program called the Shell is
listening to your terminal. The Shell reads typed-in lines,
splits them up into a command name and arguments, and executes
the command. A command is simply an executable program. The
Shell looks first in your current directory (see next section)
for a program with the given name, and if none is there, then in
a system directory. There is nothing special about system-pro-
vided commands except that they are kept in a directory where the
Shell can find them. The command name is always the first word
on an input line; it and its arguments are separated from one an-
other by spaces. When a program terminates, the Shell will ordi-
narily regain control and type a ``%'' at you to indicate that it
is ready for another command. The Shell has many other capabili-
ties, which are described in detail in section sh(I). The cur-
rent directory. UNIX has a file system arranged in a hierarchy
of directories. When the system administrator gave you a user
name, he also created a directory for you (ordinarily with the
same name as your user name). When you log in, any file name you
type is by default in this directory. Since you are the owner of
this directory, you have full permissions to read, write, alter,
or destroy its contents. Permissions to have your will with oth-
er directories and files will have been granted or denied to you
by their owners. As a matter of observed fact, few UNIX users
protect their files from destruction, let alone perusal, by other
users. To change the current directory (but not the set of per-
missions you were endowed with at login) use chdir(I). Path
names. To refer to files not in the current directory, you must
use a path name. Full path names begin with ``/'', the name of
the root directory of the whole file system. After the slash
comes the name of each directory containing the next sub-directo-
ry (followed by a ``/'') until finally the file name is reached.
E.g.: /usr/lem/filex refers to the file filex in the directory
lem; lem is itself a subdirectory of usr; usr springs directly
from the root directory. If your current directory has subdirec-
tories, the path names of files therein begin with the name of
the subdirectory (no prefixed ``/''). Without important excep-
tion, a path name may be used anywhere a file name is required.
Important commands which modify the contents of files are cp(I),
mv(I), and rm(I), which respectively copy, move (i.e. rename)
and remove files. To find out the status of files or directo-
ries, use ls(I). See mkdir(I) for making directories; rmdir
(I) for destroying them. For a fuller discussion of the file
system, see ``The UNIX Time-Sharing System,'' by the present au-
thors. It may also be useful to glance through section II of
this manual, which discusses system calls, even if you don't in-
tend to deal with the system at that level. Writing a program.
To enter the text of a source program into a UNIX file, use ed
(I). The three principal languages in UNIX are assembly language
(see as(I)), Fortran (see fc(I)), and C (see cc(I)). After
the program text has been entered through the editor and written
on a file, you can give the file to the appropriate language pro-
cessor as an argument. The output of the language processor will
be left on a file in the current directory named ``a.out''. (If
the output is precious, use mv to move it to a less exposed name
soon.) If you wrote in assembly language, you will probably need
to load the program with library subroutines; see ld(I). The
other two language processors call the loader automatically.
When you have finally gone through this entire process without
provoking any diagnostics, the resulting program can be run by
giving its name to the Shell in response to the ``%'' prompt.
Next, you will need cdb(I) or db(I) to examine the remains of
your program. The former is useful for C programs, the latter
for assembly-language. No debugger is much help for Fortran.
Your programs can receive arguments from the command line just as
system programs do. See exec(II). Text processing. Almost
all text is entered through the editor. The commands most often
used to write text on a terminal are: cat, pr, roff, nroff, and
troff, all in section I. The cat command simply dumps ASCII text
on the terminal, with no processing at all. The pr command pagi-
nates the text, supplies headings, and has a facility for multi-
column output. Troff and nroff are elaborate text formatting
programs, and require careful forethought in entering both the
text and the formatting commands into the input file. Troff
drives a Graphic Systems phototypesetter; it was used to produce
this manual. Nroff produces output on a typewriter terminal.
Roff (I) is a somewhat less elaborate text formatting program,
and requires somewhat less forethought. Surprises. Certain
commands provide inter-user communication. Even if you do not
plan to use them, it would be well to learn something about them,
because someone else may aim them at you. To communicate with
another user currently logged in, write(I) is used; mail(I)
will leave a message whose presence will be announced to another
user when he next logs in. The write-ups in the manual also sug-
gest how to respond to the two commands if you are a target.
When you log in, a message-of-the-day may greet you before the
first ``%''.