Dec 122017
Text Guide to Basics of Unix.
File UNIGUIDE.ZIP from The Programmer’s Corner in
Category UNIX Files
Text Guide to Basics of Unix.
File Name File Size Zip Size Zip Type
DL 0 0 stored
UNIXG.TXT 62047 21106 deflated

Download File UNIGUIDE.ZIP Here

Contents of the UNIXG.TXT file

From [email protected] Sun May 30 23:40:45 1993
Date: Tue, 27 Apr 93 08:07:38 -0400
From: "Mr. Gopher"
To: [email protected]
Subject: unix-guide

Brian W. Kernighan
Bell Laboratories
Murray Hill, New Jersey 07974


This paper is meant to help new users get started on the UNIX (*) operating
system. It includes:

- basics needed for day-to-day use of the system - typing commands,
correcting typing mistakes, logging in and out, mail, inter-terminal
communication, the file system, printing files, redirecting I/O, pipes,
and the shell.

- document preparation - a brief discussion of the major formatting
programs and macro packages, hints on preparing documents, and capsule
descriptions of some supporting software.

- UNIX programming - using the editor, programming the shell,
programming in C, other languages and tools.

- An annotated UNIX bibliography.

(* UNIX is a Trademark of Bell Laboratories.)


>From the user's point of view, the UNIX operating system is easy to learn
and use, and presents few of the usual impediments to getting the job done.
It is hard, however, for the beginner to know where to start, and how to
make the best use of the facilities available. The purpose of this
introduction is to help new users get used to the main ideas of the UNIX
system and start making effective use of it quickly.

You should have a couple of other documents with you for easy reference as
you read this one. The most important is "The UNIX Programmer's Manual"; it's
often easier to tell you to read about something in the manual than to
repeat its contents here. The other useful document is "A Tutorial
Introduction to the UNIX Text Editor", which will tell you how to use the
editor to get text - programs, data, documents - into the computer.

A word of warning: the UNIX system has become quite popular, and there are
several major variants in widespread use. Of course details also change with
time. So although the basic structure of UNIX and how to use it is common to
all versions, there will certainly be a few things which are different on
your system from what is described here. We have tried to minimize the
problem, but be aware of it. In cases of doubt, this paper describes Version

This paper has five sections:

1. Getting Started: How to log in, how to type, what to do about
mistakes in typing, how to log out. Some of this is dependent on
which system you log into (phone numbers, for example) and what
terminal you use, so this section must necessarily be supplemented by
local information.
2. Day-to-day Use: Things you need every day to use the system
effectively: generally useful commands; the file system.
3. Document Preparation: Preparing manuscripts is one of the most common
uses for UNIX systems. This section contains advice, but not
extensive instructions on any of the formatting tools.
4. Writing Programs: UNIX is an excellent system for developing
programs. This section talks about some of the tools, but again is
not a tutorial in any of the programming languages provided by the
5. A UNIX Reading List. An annotated bibliography of documents that new
users should be aware of.


Logging In

You must have a UNIX login name, which you can get from whoever
administers your system. You also need to know the phone number, unless
your system uses permanently connected terminals. The UNIX system is
capable of dealing with a wide variety of terminals: Terminet 300's;
Execuport, TI and similar portables; video (CRT) terminals like the
HP2640, etc.; high-priced graphics terminals like the Tektronix 4014;
plotting terminals like those from GSI and DASI; and even the venerable
Teletype in its various forms. But note: UNIX is strongly oriented
towards devices with lower case. If your terminal produces only
uppercase (e.g., model 33 Teletype, some video and portable terminals),
life will be so difficult that you should look for another terminal.

Be sure to set the switches appropriately on your device. Switches
that might need to be adjusted include the speed, upper/lower case mode,
full duplex, even parity, and any others that local wisdom advises.
Establish a connection using whatever magic is needed for your terminal;
this may involve dialing a telephone call or merely flipping a switch.
In either case, UNIX should type ``login:'' at you. If it types garbage,
you may be at the wrong speed; check the switches. If that fails, push
the ``break'' or ``interrupt'' key a few times, slowly. If that fails
to produce a login message, consult a guru.

When you get a login: message, type your login name in lower case.
Follow it by a RETURN; the system will not do anything until you type
a RETURN. If a password is required, you will be asked for it, and (if
possible) printing will be turned off while you type it. Don't forget

The culmination of your login efforts is a ``prompt character,''
a single character that indicates that the system is ready to accept
commands from you. The prompt character is usually a dollar sign $ or a
percent sign %. (You may also get a message of the day just before the
prompt character, or a notification that you have mail.)

Typing Commands

Once you've seen the prompt character, you can type commands, which
are requests that the system do something. Try typing date followed by
RETURN. You should get back something like
Mon Jan 16 14:17:10 EST 1978
Don't forget the RETURN after the command, or nothing will happen. If
you think you're being ignored, type a RETURN; something should happen.
RETURN won't be mentioned again, but don't forget it - it has to be
there at the end of eachline. Another command you might try is who,
which tells you everyone who is currently logged in: who gives something
mb tty 01 Jan 16 09:11
ski tty 05 Jan 16 09:33
gam tty 11 Jan 16 13:07
The time is when the user logged in; ``ttyxx'' is the system's idea of
what terminal the user is on.

If you make a mistake typing the command name, and refer to a
non-existent command, you will be told. For example, if you type
you will be told
whom: not found
Of course, if you inadvertently type the name of some other command, it
will run, with more or less mysterious results.

Strange Terminal Behavior
Sometimes you can get into a state where your terminal acts
strangely. For example, each letter may be typed twice, or the RETURN
may not cause a line feed or a return to the left margin. You can often
fix this by logging out and logging back in. Or you can read the
description of the command stty in section I of the manual. To get
intelligent treatment of tab characters (which are much used in UNIX) if
your terminal doesn't have tabs, type the command
stty -tabs
and the system will convert each tab into the right number of blanks
for you. If your terminal does have computer-settable tabs, the command
tabs will set the stops correctly for you.

Mistakes in Typing
If you make a typing mistake, and see it before RETURN has been
typed, there are two ways to recover. The sharp-character # erases the
last character typed; in fact successive uses of # erase characters back
to the beginning of the line (but not beyond). So if you type badly,
you can correct as you go:
is the same as date.

The at-sign @ erases all of the characters typed so far on the
current input line, so if the line is irretrievably fouled up, type an
@ and start the line over.

What if you must enter a sharp or at-sign as part of the text? If
you precede either # or @ by a backslash \, it loses its erase meaning.
So to enter a sharp or at-sign in something, type \# or \@. The system
will always echo a newline at you after your at-sign, even if preceded
by a backslash. Don't worry - the at-sign has been recorded. To erase
a backslash, you have to type two sharps or two at-signs, as in \##.
The backslash is used extensively in UNIX to indicate that the following
character is in some way special.

UNIX has full read-ahead, which means that you can type as fast
as you want, whenever you want, even when some command is typing at you.
If you type during output, your input characters will appear intermixed
with the output characters, but they will be stored away and
interpreted in the correct order. So you can type several commands one
after another without waiting for the first to finish or even begin.

Stopping a Program
You can stop most programs by typing the character ``DEL''
(perhaps called ``delete'' or ``rubout'' on your terminal). The
``interrupt'' or ``break'' key found on most terminals can also be used.
In a few programs, like the text editor, DEL stops whatever the program
is doing but leaves you in that program. Hanging up the phone will stop
most programs.

Logging Out
The easiest way to log out is to hang up the phone. You can also
and let someone else use the terminal you were on. It is usually not
sufficient just to turn off the terminal. Most UNIX systems do not use
a time-out mechanism, so you'll be there forever unless you hang up.

When you log in, you may sometimes get the message
You have mail.
UNIX provides a postal system so you can communicate with other users of
the system. To read your mail, type the command
Your mail will be printed, one message at a time, most recent message
first. After each message, mail waits for you to say what to do with it.
The two basic responses are d, which deletes the message, and RETURN,
which does not (so it will still be there the next time you read your
mailbox). Other responses are described in the manual. (Earlier versions
of mail do not process one message at a time, but are otherwise

How do you send mail to someone else?

Suppose it is to go to ``joe'' (assuming ``joe'' is someone's login
name). The easiest way is this:
mail joe
now type in the text of the letter
on as many lines as you like ...
After the last line of the letter type the character
that is, hold down ``control'' and type a letter ``d''.
And that's it. The ``control-d'' sequence, often called ``EOF'' for
end-of-file, is used throughout the system to mark the end of input
from a terminal, so you might as well get used to it. For practice, send
mail to yourself. (This isn't as strange as it might sound - mail to
oneself is a handy reminder mechanism.)

There are other ways to send mail - you can send a previously prepared
letter, and you can mail to a number of people all at once. For more
details see mail(1). (The notation mail(1) means the command mail in
section 1 of the UNIX Programmer's Manual.)

Writing to other users

At some point, out of the blue will come a message like
Message from joe tty07...
accompanied by a startling beep. It means that Joe wants to talk to
you, but unless you take explicit action you won't be able to talk back.
To respond, type the command
write joe
This establishes a two-way communication path. Now whatever Joe types
on his terminal will appear on yours and viceversa. The path is slow,
rather like talking to the moon. (If you are in the middle of something,
you have to get to a state where you can type a command. Normally,
whatever program you are running has to terminate or be terminated. If
you're editing, you can escape temporarily from the editor-read the
editor tutorial.)

A protocol is needed to keep what you type from getting garbled up with
what Joe types. Typically it's like this:
Joe types write smith and waits.
Smith types write joe and waits.
Joe now types his message (as many lines as he likes).
When he's ready for a reply, he signals it by typing (o),
which stands for ``over''.
Now Smith types a reply, also terminated by (o).
This cycle repeats until someone gets tired; he then signals his
intent to quit with (oo), for ``over and out''.
To terminate the conversation, each side must type a ``control-d''
character alone on a line. (``Delete'' also works.) When the other
person types his ``control-d'', you will get the message EOF on
your terminal.

If you write to someone who isn't logged in, or who doesn't want to be
disturbed, you'll be told. If the target is logged in but doesn't answer
after a decent interval, simply type ``control-d''.

On-line Manual

The UNIX Programmer's Manual is typically kept on-line. If you get
stuck on something, and can't find an expert to assist you, you can print on
your terminal some manual section that might help. This is also useful for
getting the most up-to-date information on a command. To print a manual
section, type
``man command-name''.
Thus to read up on the who command, type
man who
and, of course,
man man
tells all about the man command.

Computer Aided Instruction

Your UNIX system may have available a program called learn, which
provides computer aided instruction on the file system and basic commands,
the editor, document preparation, and even C programming. Try typing the
If learn exists on your system, it will tell you what to do >from there.


Creating Files - The Editor
If you have to type a paper or a letter or a program, how do you
get the information stored in the machine? Most of these tasks are done
with the UNIX ``text editor'' ed. Since ed is thoroughly documented in
ed(1) and explained in A Tutorial Introduction to the UNIX Text Editor,
we won't spend any time here describing how to use it. All we want it
for right now is to make some files. (A file is just a collection of
information stored in the machine, a simplistic but adequate
To create a file called junk with some text in it, do the
ed junk (invokes the text editor)
a (command to ``ed'', to add text)
now type in
whatever text you want ...
. (signals the end of adding text)
The ``.'' that signals the end of adding text must be at the beginning
of a line by itself. Don't forget it, for until it is typed, no other
ed commands will be recognized--everything you type will be treated as
text to be added. At this point you can do various editing operations on
the text you typed in, such as correcting spelling mistakes, rearranging
paragraphs and the like. Finally, you must write the information you
have typed into a file with the editor command w:
ed will respond with the number of characters it wrote into the file
Until the w command, nothing is stored permanently, so if you hang
up and go home the information is lost.|- But after w the information is
there permanently; you can re-access it any time by typing
ed junk
Type a q command to quit the editor. (If you try to quit without
writing, ed will print a ? to remind you. A second q gets you out
Now create a second file called temp in the same manner. You should
now have two files, junk and temp.
|- This is not strictly true - if you hang up while editing, the
data you were working on is saved in a file called ed.hup, which you can
continue with at your next session.

What files are out there?
The ls (for ``list'') command lists the names (not contents) of
any of the files that UNIX knows about. If you type
the response will be
which are indeed the two files just created. The names are sorted into
alphabetical order automatically, but other variations are possible.
For example, the command
ls -t
causes the files to be listed in the order in which they were last
changed, most recent first. The -l option gives a ``long'' listing:
ls -l
will produce something like
-rw-rw-rw- 1 bwk 41 Jul 22 2:56 junk
-rw-rw-rw- 1 bwk 78 Jul 22 2:57 temp
The date and time are of the last change to the file. The 41 and 78 are
the number of characters (which should agree with the numbers you got
from ed). bwk is the owner of the file, that is, the person who created
it. The -rw-rw-rw- tells who has permission to read and write the file,
in this case everyone.

Options can be combined: ls -lt gives the same thing as ls -l, but sorted
into time order. You can also name the files you're interested in, and
ls will list the information about them only. More details can be found
in ls(1).
The use of optional arguments that begin with a minus sign, like
-t and -lt, is a common convention for UNIX programs. In general, if a
program accepts such optional arguments, they precede any filename
arguments. It is also vital that you separate the various arguments
with spaces:
ls-l is not the same as ls -l.

Printing Files
Now that you've got a file of text, how do you print it so people
can look at it? There are a host of programs that do that, probably more
than are needed.
One simple thing is to use the editor, since printing is often
done just before making changes anyway. You can say
ed junk
ed will reply with the count of the characters in junk and then print
all the lines in the file. After you learn how to use the editor, you
can be selective about the parts you print.

There are times when it's not feasible to use the editor for
printing. For example, there is a limit on how big a file ed can handle
(several thousand lines). Secondly, it will only print one file at a
time, and sometimes you want to print several, one after another. So
here are a couple of alternatives.

First is cat, the simplest of all the printing programs. cat
simply prints on the terminal the contents of all the files named in a
list. Thus
cat junk
prints one file, and
cat junk temp
prints two. The files are simply concatenated (hence the name ``cat'')
onto the terminal.

pr produces formatted printouts of files. As with cat, pr prints
all the files named in a list. The difference is that it produces
headings with date, time, page number and file name at the top of each
page, and extra lines to skipover the fold in the paper. Thus,
pr junk temp
will print junk neatly, then skip to the top of a new page and print
temp neatly.
pr can also produce multi-column output:
pr -3 junk
prints junk in 3-column format. You can use any reasonable number in
place of ``3'' and pr will do its best. pr has other capabilities as
well; see pr(1).

It should be noted that pr is not a formatting program in the sense
of shuffling lines around and justifying margins. The true formatters
are nroff and troff, which we will get to in the section on document
preparation. There are also programs that print files on a high-speed
printer. Look in your manual under opr and lpr. Which to use depends on
what equipment is attached to your machine.

Shuffling Files About

Now that you have some files in the file system and some experience
in printing them, you can try bigger things. For example, you can move
a file from one place to another (which amounts to giving it a new
name), like this:
mv junk precious
This means that what used to be ``junk'' is now ``pre-cious''. If you do
an ls command now, you will get
Beware that if you move a file to another one that already exists, the
already existing contents are lost forever. If you want to make a copy
of a file (that is, to have two versions of something), you can use the
cp command:
cp precious temp1
makes a duplicate copy of precious in temp1. Finally, when you get tired
of creating and moving files, there is a command to remove files from
the file system, called rm.
rm temp temp1
will remove both of the files named. You will get a warning message if
one of the named files wasn't there, but otherwise rm, like most UNIX
commands, does its work silently. There is no prompting or chatter, and
error messages are occasionally curt. This terseness is sometimes
disconcerting to newcomers, but experienced users find it desirable.

What's in a Filename

So far we have used filenames without ever saying what's a legal
name, so it's time for a couple of rules. First, filenames are limited
to 14 characters, which is enough to be descriptive. Second, although
you can use almost any character in a filename, common sense says you
should stick to ones that are visible, and that you should probably
avoid characters that might be used with other meanings. We have already
seen, for example, that in the ls command, ls -t means to list in time
order. So if you had a file whose name was -t, you would have a tough
time listing it by name. Besides the minus sign, there are other
characters which have special meaning. To avoid pitfalls, you would do
well to use only letters, numbers and the period until you're familiar
with the situation.

On to some more positive suggestions.

Suppose you're typing a large document like a book. Logically this
divides into many small pieces, like chapters and perhaps sections.
Physically it must be divided too, for ed will not handle really big
files. Thus you should type the document as a number of files. You might
have a separate file for each chapter, called
Or, if each chapter were broken into several files, you might have
You can now tell at a glance where a particular file fits into the
whole. There are advantages to a systematic naming convention which are
not obvious to the novice UNIX user. What if you wanted to print the
whole book? You could say
pr chap1.1 chap1.2 chap1.3 ......
but you would get tired pretty fast, and would probably even make
mistakes. Fortunately, there is a shortcut. You can say
pr chap*
The * means ``anything at all,'' so this translates into ``print all
files whose names begin with chap'', listed in alphabetical order.

This shorthand notation is not a property of the pr command, by the
way. It is system-wide, a service of the program that interprets
commands (the ``shell,'' sh(1)). Using that fact, you can see how to
list the names of the files in the book:
ls chap*
chap1.3 ...
The * is not limited to the last position in a filename - it can be
anywhere and can occur several times. Thus
rm *junk* *temp*
removes all files that contain junk or temp as any part of their name.
As a special case, * by itself matches every filename, so
pr *
prints all your files (alphabetical order), and rm *removes all files.
(You had better be very sure that's what you wanted to say!)

The * is not the only pattern-matching feature available. Suppose
you want to print only chapters 1 through 4 and 9. Then you can say
pr chap[12349]*
The [...] means to match any of the characters inside the brackets. A
range of consecutive letters or digits can be abbreviated, so you can
also do this with
pr chap[1-49]*
Letters can also be used within brackets: [a-z] matches any character in
the range a through z.

The ? pattern matches any single character, so
ls ?
lists all files which have single-character names, and
ls -l chap?.1
lists information about the first file of each chapter (chap1.1,
chap2.1, etc.).

Of these niceties, * is certainly the most useful, and you should
get used to it. The others are frills, but worth knowing. If you should
ever have to turn off the special meaning of*, ?, etc., enclose the
entire argument in single quotes, as in
ls '?'
We'll see some more examples of this shortly.

What's in a Filename, Continued

When you first made that file called junk, how did the system know
that there wasn't another junk somewhere else, especially since the
person in the next office is also reading this tutorial? The answer is
that generally each user has a private directory, which contains only
the files that belong to him. When you log in, you are ``in'' your
directory. Unless you take special action, when you create a newfile, it
is made in the directory that you are currently in; this is most often
your own directory, and thus the file is unrelated to any other file of
the same name that might exist in someone else's directory.

The set of all files is organized into a (usually big) tree, with
your files located several branches into the tree. It is possible for
you to ``walk'' around this tree, and to find any file in the system, by
starting at the root of the tree and walking along the proper set of
branches. Conversely, you can start where you are and walk toward the

Let's try the latter first. The basic tools is the command pwd
(``print working directory''), which prints the name of the directory
you are currently in.

Although the details will vary according to the system you are on,
if you give the command pwd, it will print something like
This says that you are currently in the directory your-name, which is in
turn in the directory /usr, which is in turn in the root directory
called by convention just /. (Even if it's not called /usr on your
system, you will get something analogous. Make the corresponding changes
and read on.) If you now type
ls /usr/your-name
you should get exactly the same list of file names as you get from a
plain ls: with no arguments, ls lists the contents of the current
directory; given the name of a directory, it lists the contents of that

Next, try
ls /usr
This should print a long series of names, among which is your own login
name your-name. On many systems, usr is a directory that contains the
directories of all the normal users of the system, like you.

The next step is to try
ls /
You should get a response something like this (although again the
details may be different):
This is a collection of the basic directories of files that the system
knows about; we are at the root of the tree.

Now try
cat /usr/your-name/junk
(if junk is still around in your directory). The name
is called the path name of the file that you normally think of as
``junk''. ``Pathname'' has an obvious meaning: it represents the full
name of the path you have to follow from the root through the tree of
directories to get to a particular file. It is a universal rule in the
UNIX system that anywhere you can use an ordinary filename, you can use
a pathname. Here is a picture which may make this clearer:
/ | \
/ | \
/ | \
bin etc usr dev tmp
/ | \ / | \ / | \ / | \ / | \
/ | \ / | \
adam eve mary
/ / \ \
/ \ junk
junk temp
Notice that Mary's junk is unrelated to Eve's. This isn't too exciting
if all the files of interest arein your own directory, but if you
work with someone else or on several projects concurrently, it becomes
handy indeed. For example, your friends can print your book by saying
pr /usr/your-name/chap*
Similarly, you can find out what files your neighbor has by saying
ls /usr/neighbor-name
or make your own copy of one of his files by
cp /usr/your-neighbor/his-file yourfile
If your neighbor doesn't want you poking around in his files, or vice
versa, privacy can be arranged. Each file and directory has
read-write-execute permissions for the owner, a group, and everyone
else, which can be set to control access. See ls(1) and chmod(1) for
details. As a matter of observed fact, most users most of the time find
openness of more benefit than privacy.
As a final experiment with pathnames, try
ls /bin /usr/bin
Do some of the names look familiar? When you run a program, by typing
its name after the prompt character, the system simply looks for a file
of that name. It normally looks first in your directory (where it
typically doesn't find it), then in /bin and finally in /usr/bin. There
is nothing magic about commands like cat or ls, except that they have
been collected into a couple of places to be easy to find and

What if you work regularly with someone else on common information in
his directory? You could just log in as your friend each time you want
to, but you can also say ``I want to work on his files instead of my
own''. This is done by changing the directory that you are currently in:
cd /usr/your-friend
(On some systems, cd is spelled chdir.) Now when you use a filename in
something like cat or pr, it refers to the file in your friend's
directory. Changing directories doesn't affect any permissions
associated with a file - if you couldn't access a file from your own
directory, changing to another directory won't alter that fact. Of
course, if you forget what directory you're in, type
to find out. It is usually convenient to arrange your own files so that
all the files related to one thing are in a directory separate from
other projects. For example, when you write your book, you might want
to keep all the text in a directory called book. So make one with
mkdir book
then go to it with
cd book
then start typing chapters. The book is now found in (presumably)
To remove the directory book, type
rm book/*
rmdir book
The first command removes all files from the directory; the second
removes the empty directory. You can go up one level in the tree of
files by saying
cd ..
``..'' is the name of the parent of whatever directory you are currently
in. For completeness, ``.'' is an alternate name for the directory you
are in.

Using Files instead of the Terminal

Most of the commands we have seen so far produce output on the
terminal; some, like the editor, also take their input > from the
terminal. It is universal in UNIX systems that the terminal can be
replaced by a file for either or both of input and output. As one
makes a list of files on your terminal. But if you say
ls >filelist
a list of your files will be placed in the file filelist (which will
be created if it doesn't already exist, or overwritten if it does). The
symbol > means ``put the output on the following file, rather than on
the terminal.'' Nothing is produced on the terminal. As another
example, you could combine several files into one by capturing the
output of cat in a file:
cat f1 f2 f3 >temp

The symbol >> operates very much like > does, except that it means
``add to the end of.'' That is,
cat f1 f2 f3 >>temp
means to concatenate f1, f2 and f3 to the end of whatever is already in
temp, instead of overwriting the existing contents. As with >, if temp
doesn't exist, it will be created for you.

In a similar way, the symbol < means to take the input for a
program from the following file, instead of from the terminal. Thus, you
could make up a script of commonly used editing commands and put them
into a file called script. Then you can run the script on a file by
ed file As another example, you can use ed to prepare a letter in file let, then
send it to several people with
mail adam eve mary joe

One of the novel contributions of the UNIX system is the idea of a
pipe. A pipe is simply a way to connect the output of one program to the
input of another program, so the two run as a sequence of processes - a
pipeline. For example,
pr f g h
will print the files f, g, and h, beginning each on a newpage. Suppose
you want them run together instead. You could say
cat f g h >temp
pr rm temp
but this is more work than necessary. Clearly what we want is to take
the output of cat and connect it to the input of pr. So let us use a
cat f g h | pr
The vertical bar | means to take the output from cat, which would
normally have gone to the terminal, and put it into pr to be neatly
formatted. There are many other examples of pipes. For example,
ls | pr -3
prints a list of your files in three columns. The program wc counts the
number of lines, words and characters in its input, and as we so
earlier, who prints a list of currently-logged on people, one per line.
who | wc
tells how many people are logged on. And of course
ls | wc
counts your files. Any program that reads from the terminal can read
from a pipe instead; any program that writes on the terminal can drive
a pipe. You can have as many elements in a pipeline as you wish.

Many UNIX programs are written so that they will take their input
from one or more files if file arguments are given; if no arguments are
given they will read from the terminal, and thus can be used in
pipelines. pr is oneexample:
pr -3 a b c
prints files a, b and c in order in three columns. But in
cat a b c | pr -3 pr
prints the information coming down the pipeline, still in three columns.

The Shell

We have already mentioned once or twice the mysterious ``shell,''
which is infact sh(1). The shell is the program that interprets what you
type as commands and arguments. It also looks after translating *,
etc., into lists of filenames, and <, >, and | into changes of input and
output streams.

The shell has other capabilities too. For example, you can run two
programs with one command line by separating the commands with a
semicolon; the shell recognizes the semicolon and breaks the line into
two commands. Thus
date; who
does both commands before returning with a prompt character. You can
also have more than one program running simultaneously if you wish. For
example, if you are doing something time-consuming, like the editor
script of an earlier section, and you don't want to wait around for the
results before starting something else, you can say
ed file