@DATABASE "CHAP2"
@index BigDummy.index/MAIN
@NODE MAIN "Chapter 2: E-MAIL"
@TOC BIGDUMMY.GUIDE/MAIN
@NEXT CHAP3/MAIN
@PREV CHAP1/MAIN
     Electronic mail, or e-mail, is your personal connection to the world
of the Net.
     Every one of the millions of people around the world who use the Net
have their own e-mail address.  A growing number of "gateways" tie more
and more people to the Net every day.  When you logged onto the host
system you are now using, it automatically generated an address for you,
as well.

   @{" What is E-Mail?                 " link WHATMAIL              }
   @{" Learning E-Mail                 " link LEARNMAIL             }
   @{" Mail readers: ELM & PINE        " link ELMPINE               }
   @{" Smileys                         " link SMILEYS               }
   @{" Things that can go wrong        " link WRONG2     }

@EndNode
@Node WHATMAIL "Chapter 2: E-Mail (1 of 5) -- What is E-Mail"
@PREV MAIN
What is E-Mail

    The basic concepts behind e-mail parallel those of regular mail. You
send mail to people at their particular addresses.  In turn, they write
to you at your e-mailbox address.  You can subscribe to the electronic
equivalent of magazines and newspapers. There is even electronic junk
mail.
    E-mail has two distinct advantages over regular mail.  The most
obvious is speed. Instead of several days, your message can reach the
other side of the world in hours or even minutes (depending on where you
drop off your mail and the state of the connections between there and
your recipient).  The other advantage is that once you master the basics,
you'll be able to use e-mail to access databases and file libraries.
You'll see how to do this later, along with learning how to transfer
program and data files through e-mail.
    E-mail also has advantages over the telephone.  You send your message
when it's convenient for you.  Your recipient responds at his
convenience.  No more telephone tag.  And while a phone call across the
country or around the world can quickly result in huge phone bills,
e-mail lets you exchange vast amounts of mail for only a few pennies --
even if the other person is in New Zealand.
    E-mail is your connection to help -- your Net lifeline.  The Net can
sometimes seem a frustrating place!  No matter how hard you try, no
matter where you look, you just might not be able to find the answer to
whatever is causing you problems. But when you know how to use e-mail,
help is often just a few keystrokes away: ask your system administrator
or a friend for help in an e-mail message.

@EndNode
@Node LEARNMAIL "Chapter 2: E-Mail (2 of 5) -- Learning E-Mail "
@NEXT ELMPINE

    Somewhere along the line, we learned how to grab letters from our home
mailbox. We learned how to read the return address, open the letter, and
we learned how to respond. It all seems pretty natural by now.
    E-mail won't seem natural at first. It can be downright frustrating.
Because it can become a powerful tool, it's worth a few minutes to try it
out:

   @{" Sending a letter to yourself   " link SENDMAIL   } using Unix mail
   @{" Getting mail from your mailbox " link GETMAIL    } managing the mailbox
   @{" Responding to a message        " link RESPONDMAIL}
   @{" Deciphering the mail address   " link MAILADDRESS}
   @{" Test the mail with Almanac     " link TESTMAIL   }

@EndNode
@Node SENDMAIL "...Learning E-Mail (1 of 5) -- Send a letter to yourself"
@TOC LEARNMAIL
@PREV LEARNMAIL
    The quickest way to start learning e-mail is to send yourself a
message.  Most public-access sites actually have several different types
of mail systems, all of which let you both send and receive mail. We'll
start with the simplest one, known, appropriately enough, as "mail," and
then look at a couple of other interfaces. At your host system's command
@{" prompt " link BigDummy.Guide/LINGO 254}, type this:

             mail username

where username is the name you gave yourself when you first logged on.
Hit enter.  The computer might respond with

             subject:

     Type

             test

or, actually, anything at all (but you'll have to hit enter before you
get to the end of the screen). Hit enter.
     The cursor will drop down a line. You can now begin writing the
actual message. Type a sentence, again, anything at all.  And here's
where you hit your first Unix frustration, one that will bug you
repeatedly: you have to hit enter before you get to the very end of the
line.  Just like typewriters, many Unix programs have no word- wrapping.
     When done with your message, hit return. Now hit control-D (the
control and the D keys at the same time).  This is a Unix command that
tells the computer you're done writing and that it should close your
"envelope" and mail it off (you could also hit enter once and then, on a
blank line, type a period at the beginning of the line and hit enter
again).
     You've just sent your first e-mail message.  And because you're
sending mail to yourself, rather than to someone somewhere else on the
Net, your message has already arrived, as we'll see in a moment.
     If you had wanted, you could have even written your message on your
own computer and then @{" uploaded " link BigDummy.guide/LINGO 332} it into this electronic "envelope."
There are a couple of good reasons to do this with long or involved
messages. One is that once you hit enter at the end of a line in "mail"
you can't readily fix any mistakes on that line (unless you use some
special commands to call up a Unix text processor.  Also, if you are
paying for access by the hour, uploading a prepared message can save you
money. Remember to save the document in ASCII or text format.  Uploading
a document you've created in a word processor that uses special
formatting commands (which these days means many programs) will cause
strange effects.
     When you get that blank line after the subject line, upload the
message using the ASCII protocol.  Or you can copy and paste the text, if
your software allows that. When done, hit control-D as above.

@EndNode

@Node GETMAIL "...Learning E-Mail (2 of 5) -- Getting a letter from your mailbox"
@TOC LEARNMAIL
     Now you have mail waiting for you.  Normally, when you log on, your
public-access site will tell you whether you have new mail waiting.  To
open your mailbox and see your waiting mail, type

          mail

and hit enter.
     When the host system sees "mail" without a name after it, it knows
you want to look in your mailbox rather than send a message. Your screen,
on a plain-vanilla Unix system will display:

         Mail version SMI 4.0 Mon Apr 24 18:34:15 PDT 1989  Type ? for help.
         "/usr/spool/mail/adamg": 1 message 1 new 1 unread

         >N 1 adamg              Sun Mar 22 20:04   12/290   test

     Ignore the first line; it's just computerese of value only to the
people who run your system. You can type a question mark and hit return,
but unless you're familiar with Unix, most of what you'll see won't make
much sense at this point.
     The second line tells you the directory on the host system where
your mail messages are put.  This is your "home directory."  It's a good
name to remember.  Later, when you start transferring files across the
Net, this is where they will usually wind up, or from where you'll send
them.  The second line also tells you how many messages are in your
mailbox, how many have come in since the last time you looked and how
many messages you haven't read yet.
     It's the third line that is of real interest -- it tells you who the
message is from, when it arrived, how many lines and characters it takes
up, and what the subject is.  The "N" means it is a new message -- it
arrived after the last time you looked in your mailbox. Hit enter. And
there's your message -- only now it's a lot longer than what you wrote!

        Message 1:
        From adamg Mar 22 20:04:55 1992
        Received: by eff.org id AA28949
        (5.65c/IDA-1.4.4/pen-ident for adamg); Sun, 22 Mar 1992 20:04:55 -0400
        (ident-sender: adamg@eff.org)
        Date: Sun, 26 Apr 1992 21:34:55 -0400
        From: Adam Gaffin <adamg>
        Message-Id: <199204270134.AA28949@eff.org>
        To: adamg
        Subject: test
        Status: R

        This is only a test!

     Whoa! What is all that stuff? It's your message with a postmark gone
mad.  Just as the postal service puts its marks on every piece of mail it
handles, so do Net postal systems.  Only it's called a "header" instead
of a postmark. Each system that handles or routes your mail puts its
stamp on it.  Since many messages go through a number of systems on their
way to you, you will often get messages with headers that seem to go on
forever.  Among other things, a header will tell you exactly when a
message was sent and received (even the difference between your local
time and GMT -- as at the end of line 4 above).
     If this had been a long message, it would just keep scrolling across
and down your screen -- unless the people who run your public- access
site have set it up to pause every 24 lines.  One way to deal with a
message that doesn't stop is to use your telecommunication software's
logging or text-buffer function.  Start it before you hit the number of
the message you want to see.  Your computer will ask you what you want to
call the file you're about to create. After you name the file and hit
enter, type the number of the message you want to see and hit enter.
When the message finishes scrolling, turn off the text-buffer function,
and the message is now saved in your computer. This way, you can read the
message while not connected to the Net (which can save you money if
you're paying by the hour) and write a reply @{" offline " link BigDummy.Guide/LINGO 228}.

@EndNode
@Node RESPONDMAIL "...Learning E-Mail (3 of 5) -- Responding to E-Mail"
@TOC LEARNMAIL
     But in the meantime, now what?  You can respond to the message,
delete it or save it.  To respond, type a lower-case "r" and hit enter.
You'll get something like this:

          To: adamg
          Subject: Re:  test

     Note that this time, you don't have to enter a username.  The
computer takes it from the message you're replying to and automatically
addresses your message to its sender. The computer also automatically
inserts a subject line, by adding "RE:" to the original subject.  From
here, it's just like writing a new message. But say you change your mind
and decide not to reply after all. How do you get out of the message? Hit
control-C once. You'll get this:

          (Interrupt -- one more to kill letter)

If you hit control-C once more, the message will disappear and you'll get
back to your mail's command line.
     Now, if you type a lower-case "d" and then hit enter, you'll delete
the original message.  Type a lower-case "q" to exit your mailbox.
     If you type a "q" without first hitting "d", your message is
transferred to a file called mbox.  This file is where all read, but
un-deleted messages go.  If you want to leave it in your mailbox for now,
type a lower-case "x" and hit enter.  This gets you out of mail without
making any changes.
     The mbox file works a lot like your mailbox.  To access it, type

           mail -f mbox

at your host system's @{" command line " link BigDummy.Guide/LINGO 50} and hit enter.
     You'll get a menu identical to the one in your mailbox from which
you can read these old messages, delete them or respond to them.  It's
probably a good idea to clear out your mailbox and mbox file from time to
time, if only to keep them uncluttered.

    Are there any drawbacks to e-mail?  There are a few.  One is that
people seem more willing to fly off the handle electronically than in
person, or over the phone.  Maybe it's because it's so easy to hit R and
reply to a message without pausing and reflecting a moment. That's why we
have @{" smileys " link Chap2/SMILEYS 0}!  There's no online equivalent yet of a return receipt:
chances are your message got to where it's going, but there's no absolute
way for you to know for sure unless you get a reply from the other
person.  Also, because computers are quite literal, you have to be very
careful when addressing a message. Misplace a period or a single letter
in the address, and your message could come back to you, undelivered.

@EndNode
@Node MAILADDRESS "...Learning E-Mail (4 of 5) -- Deciphering addresses"
@TOC LEARNMAIL
     So now you're ready to send e-mail to other people on the Net. Of
course, you need somebody's address to send them mail.  How do you get it?
     Alas, the simplest answer is not what you'd call the most elegant:
you call them up on the phone or write them a letter on paper and ask
them.  Residents of the electronic frontier are only beginning to develop
the equivalent of phone books, and the ones that exist today are far from
complete (still, later on, we'll show you how to use some of these
directories).
     Eventually, you'll start corresponding with people, which means
you'll want to know how to address mail to them.  It's vital to know how
to do this, because the smallest mistake -- using a comma when you should
have used a period, for instance, can bounce the message back to you,
undelivered.  In this sense, Net addresses are like phone numbers: one
wrong digit and you get the wrong person.  Fortunately, most net
addresses now adhere to a relatively easy-to-understand system.
     Earlier, you sent yourself a mail message using just your user-
name.  This was sort of like making a local phone call -- you didn't have
to dial a 1 or an area code.  This also works for mail to anybody else
who has an account on the same system as you.
     Sending mail outside of your system, though, will require the use of
the Net equivalent of area codes, called "domains." A basic Net address
will look something like this:

              tomg@world.std.com

     Tomg is somebody's user ID, and he is at (hence the @ sign) a site
or "domain" known as std.com.  Large organizations often have more than
one computer linked to the Internet; in this case, the name of the
particular machine is world (you will quickly notice that, like boat
owners, Internet computer owners always name their machines).
     Domains tell you the name of the organization that runs a given
e-mail site and what kind of site it is or, if it's not in the U.S., what
country it's located in.  Large organizations may have more than one
computer or gateway tied to the Internet, so you'll often see a two-part
domain name; and sometimes even three- or four-part domain names.
     In general, American addresses end in an organizational suffix, such
as ".edu," which means the site is at a college or university. Other
American suffixes include:

          .com for businesses
          .org for non-profit organizations
          .gov and .mil for government and military agencies
          .net for companies or organizations that run large networks.

     Sites in the rest of the world tend to use a two-letter code that
represents their country.  Most make sense, such as .ca for Canadian
sites, but there are a couple of seemingly odd ones.  Swiss sites end in
.ch, while South African ones end in .za.  Some smaller U.S. sites are
beginning to follow this international convention (such as
unixland.natick.ma.us).
    You'll notice that the above addresses are all in lower-case. Unlike
almost everything else having anything at all to do with Unix, Most Net
mailing systems don't care about case, so you can capitalize names if you
want, but you generally don't have to. Alas, there are a few exceptions
-- some public-access sites do allow for capital letters in user names.
When in doubt, ask the person you want to write to, or let her send you a
message first (recall how a person's e-mail address is usually found on
the top of her message).
   The "domain" name, the part of the address after the @ sign, never has
to be capitalized. The reason has to do with the presence on the Net of a
number of old IBM mainframes.  These machines tend to produce output
entirely in capital letters, so the original designers of the Net decided
to create something more flexible than the Unix they were used to.
     It's all a fairly simple system that works very well, except, again,
it's vital to get the address exactly right -- just as you have to dial a
phone number exactly right.  Send a message to tomg@unm.edu (which is the
University of New Mexico) when you meant to send it to tomg@umn.edu (the
University of Minnesota), and your letter will either bounce back to you
undelivered, or go to the wrong person.
     If your message is bounced back to you as undeliverable, you'll get
an ominous looking-message from MAILER-DAEMON (actually a rather benign
Unix program that exists to handle mail), with an evil-looking header
followed by the text of your message. Sometimes, you can tell what went
wrong by looking at the first few lines of the bounced message.  Besides
an incorrect address, it's possible your host system does not have the
other site in the "map" it maintains of other host systems. Or you could
be trying to send mail to another network, such as @{" Bitnet " link Chap5/BITNET 0} or
CompuServe, that has special addressing requirements.
    Sometimes, figuring all this out can prove highly frustrating. But
remember the prime Net commandment: Ask.  Send a message to your system
administrator.  He or she might be able to help decipher the problem.
    There is one kind of address that may give your host system
particular problems.  There are two main ways that Unix systems exchange
mail.  One is known as @{" UUCP " link BigDummy.Guide/LINGO 327} and started out with a different addressing
system than the rest of the Net.  Most UUCP systems have since switched
over to the standard Net addressing system, but a few traditional sites
still cling to their original type, which tends to have lots of
exclamation points in it, like this:

               uunet!somesite!othersite!mybuddy

     The problem for many host sites is that exclamation points (also
known as "bangs") now mean something special to the operating system that
runs the computer, so that addressing mail to such an site (or even
responding to a message you received from one) could confuse the poor
computer to no end and your message never gets sent out. If that happens,
try putting "forward" backslashes in front of each exclamation point, so
that you get an address that looks like this:

               uunet\!somesite\!othersite\!mybuddy

Note that this means you may not be able to respond to such a message by
typing a lower-case "r"  -- you'll get an error message that says "event
not found" and you'll have to create a brand-new message.

@EndNode
@Node TESTMAIL "...Learning E-Mail (5 of 5) -- Test mail with the almanac"
@TOC LEARNMAIL
@NEXT LEARNMAIL

    If you want to get a taste of what's possible through e-mail,
start an e-mail message to

              almanac@oes.orst.edu

Leave the "subject:" line blank.  As a message, write this:

              send quote

Or, if you're feeling a little down, write this instead:

              send moral-support

     In either case, you will get back a message within a few seconds to
a few hours (depending on the state of your host system's Internet
connection).  If you simply asked for a quote, you'll get back a
fortune-cookie-like saying.  If you asked for moral support, you'll also
get back a fortune-cookie-like saying, only supposedly more uplifting.
      This particular "mail server" is run by the University of Oregon.
Its main purpose is actually to provide a way to distribute agricultural
information via e-mail.  If you'd like to find out how to use the
server's full range of services, send a message to the above address with
this line in it:

              send help

You'll quickly get back a lengthy document detailing just what's
available and how to get it.

@EndNode
@Node ELMPINE "Chapter 2: E-Mail (3 of 5) -- Alternate readers: ELM and PINE"
@PREV LEARNMAIL

     The "mail" program is actually a very powerful one and a Netwide
standard, at least on Unix computers.  But it can be hard to figure out
-- you can type a question mark to get a list of commands, but these may
be of limited use unless you're already familiar with Unix. Fortunately,
there are a couple of other mail programs that are easier to use.

ELM
~~~
     Elm is a combination mailbox and letter-writing system that uses
menus to help you navigate through mail.  Most Unix-based host systems
now have it online. To use it, type

                elm

and hit enter.  You'll get a menu of your waiting mail, along with a list
of commands you can execute, that will look something like this:


       Mailbox is '/usr/spool/mail/adamg' with 38 messages [ELM 2.3 PL11]


     1   Sep 1  Christopher Davis  (13)   here's another message.
     2   Sep 1  Christopher Davis  (91)   This is a message from Eudora
     3   Aug 31 Rita Marie Rouvali (161)  First Internet Hunt !!! (fwd)
     4   Aug 31 Peter Scott/Manage (69)   New File <UK077> University of Londo
     5   Aug 30 Peter Scott/Manage (64)   New File <DIR020> X.500 service at A
     6   Aug 30 Peter Scott/Manage (39)   New File <NET016> DATAPAC Informatio
     7   Aug 28 Peter Scott/Manage (67)   Proposed Usenet group for HYTELNET n
     8   Aug 28 Peter Scott/Manage (56)   New File <DIR019> JANET Public Acces
     9   Aug 26 Helen Trillian Ros (15)   Tuesday
     10  Aug 26 Peter Scott/Manage (151)  Update <CWK004> Oxford University OU


   You can use any of the following commands by pressing the first character;
 d)elete or u)ndelete mail,  m)ail a message,  r)eply or f)orward mail,  q)uit
    To read a message, press <return>.  j = move down, k = move up, ? = help

     Each line shows the date you received the message, who sent it, how
many lines long the message is, and the message's subject.
     If you are using VT100 emulation, you can move up and down the menu
with your up and down arrow keys.  Otherwise, type the line number of the
message you want to read or delete and hit enter.
     When you read a message, it pauses every 24 lines, instead of
scrolling until it's done.  Hit the space bar to read the next page. You
can type a lower-case "r" to reply or a lower-case "q" or "i" to get back
to the menu (the I stands for "index").
     At the main menu, hitting a lower-case "m" followed by enter will
let you start a message.  To delete a message, type a lower-case "d".
You can do this while reading the message.  Or, if you are in the menu,
move the cursor to the message's line and then hit D.
     When you're done with Elm, type a lower-case "q".  The program will
ask if you really want to delete the messages you marked. Then, it will
ask you if you want to move any messages you've read but haven't marked
for deletion to a "received" file.  For now, hit your n key.
     Elm has a major disadvantage for the beginner. The default text
editor it generally calls up when you hit your "r" or "m" key is often a
program called emacs. Unixoids swear by emacs, but everybody else almost
always finds it impossible.  Unfortunately, you can't always get away
from it (or vi, another text editor often found on Unix systems), so
later on we'll talk about some basic commands that will keep you from
going totally nuts.

PINE
~~~~
     Pine is based on elm but includes a number of improvements that make
it an ideal mail system for beginners.   Like elm, pine starts you with a
menu.  It also has an "address book" feature that is handy for people
with long or complex e-mail addresses. Hitting A at the main menu puts
you in the address book, where you can type in the person's first name
(or nickname) followed by her address. Then, when you want to send that
person a message, you only have to type in her first name or nickname,
and pine automatically inserts her actual address. The address book also
lets you set up a @{" mailing list " link BigDummy.Guide/LINGO 177}.  This feature allows you to send the
same message to a number of people at once.
     What really sets pine apart is its built-in text editor, which looks
and feels a lot more like word-processing programs available for MS-DOS
and Macintosh users.  Not only does it have wordwrap (a revolutionary
concept if ever there was one, it also has a spell-checker and a search
command. Best of all, all of the commands you need are listed in a
two-line mini-menu at the bottom of each screen.  The commands look like
this:

               ^W Where is

The little caret is a synonym for the key marked "control" on your
keyboard.  To find where a particular word is in your document, you'd hit
your control key and your W key at the same time, which would bring up a
@{" prompt " link BigDummy.Guide/LINGO 254} asking you for the word to look for.
     Some of pine's commands are a tad peculiar (control-V for "page
down" for example), which comes from being based on a variant of @{" emacs " link BigDummy.Guide/LINGO 94}
(which is utterly peculiar).  But again, all of the commands you need are
listed on that two-line mini-menu, so it shouldn't take you more than a
couple of seconds to find the right one.
     To use pine, type

               pine

at the @{" command line " link BigDummy.Guide/LINGO 50} and hit enter.  It's a relatively new program, so
many systems do not yet have it online.  But it's so easy to use, you
should probably send e-mail to your system administrator urging him to
get it!

@EndNode
@Node SMILEYS "Chapter 2: E-Mail (4 of 5) -- Smileys"
SMILEYS


    When you're involved in an online discussion, you can't see the
smiles or shrugs that the other person might make in a live conversation
to show he's only kidding.  But online, there's no body language. So what
you might think is funny, somebody else might take as an insult.  To try
to keep such misunderstandings from erupting into bitter disputes, we
have smileys.  Tilt your head to the left and look at the following
sideways. :-).  Or simply :).  This is your basic "smiley." Use it to
indicate people should not take that comment you just made as seriously
as they might otherwise.  You make a smiley by typing a colon, a hyphen
and a right parenthetical bracket. Some people prefer using the word
"grin," usually in this form:

          <grin>

Sometimes, though, you'll see it as *grin* or even just <g> for short.

Some other smileys include:

          ;-)      Wink;
          :-(      Frown;
          :-O      Surprise;
          8-)      Wearing glasses;
          =|:-)=   Abe Lincoln.

         OK, so maybe the last two are a little bogus :-).

@EndNode
@Node WRONG2 "Chapter 2: E-Mail (5 of 5) -- When things go wrong"
@NEXT MAIN
--------------------
WHEN THINGS GO WRONG

     * You send a message but get back an ominous looking message from
MAILER-DAEMON containing up to several dozen lines of computerese
followed by your message.  Somewhere in those lines you can often find a
clue to what went wrong.  You might have made a mistake in spelling the
e-mail address.  The site to which you're sending mail might have been
down for maintenance or a problem. You may have used the wrong
"translation" for mail to a non-Internet network.
     * You call up your host system's text editor to write a message or
reply to one and can't seem to get out.  If it's @{" emacs " link BigDummy.Guide/LINGO 94}, try control-X,
control-C.  If worse comes to worse, you can hang up.
     * In Elm, you accidentally hit the D key for a message you want to
save.  Type the number of the message, hit enter and then U, which will
"un-delete" the message.  This works only before you exit Elm; once you
quit, the message is gone.
     * You try to @{" upload " link BigDummy.Guide/LINGO 332} an ASCII message you've written on your own
computer into a message you're preparing in Elm or Pine and you get a lot
of left brackets, capital Ms, Ks and Ls and some funny-looking
characters.  Believe it or not, your message will actually wind up
looking fine; all that garbage is temporary and reflects the problems
some Unix text processors have with ASCII uploads.  But it will take much
longer for your upload to finish.  One way to deal with this is to call
up the simple mail program, which will not produce any weird characters
when you upload a text file into a message.  Another way (which is better
if your prepared message is a response to somebody's mail), is to create
a text file on your host system with cat, for example,

          cat>file

and then upload your text into that.  Then, in Elm or Pine, you can
insert the message with a simple command (control-r in Pine, for
example); only this time you won't see all that extraneous stuff.

@EndNode
