





     


                   UUNNIIXX FFoorr BBeeggiinnnneerrss ---- SSeeccoonndd EEddiittiioonn


                            _B_r_i_a_n _W_. _K_e_r_n_i_g_h_a_n

                    _(_U_p_d_a_t_e_d _f_o_r _4_._3_B_S_D _b_y _M_a_r_k _S_e_i_d_e_n_)


                                 _A_B_S_T_R_A_C_T

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

           +o
            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.

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

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

           +o
            An annotated UNIX bibliography.


     IINNTTRROODDUUCCTTIIOONN

       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 _T_h_e _U_N_I_X
     _P_r_o_g_r_a_m_m_e_r_'_s _M_a_n_u_a_l; 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 _T_u_t_o_r_i_a_l _I_n_t_r_o_d_u_c_t_i_o_n _t_o _t_h_e _U_N_I_X _T_e_x_t
     _E_d_i_t_o_r_,  which will tell you how to use the editor to get text --
     programs, data, documents -- into the computer.









     USD:1-2                                        UNIX For Beginners


       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 7 UNIX.

       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 sup-
       plemented 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 system.

       5.
       A UNIX Reading List.  An annotated  bibliography  of  documents
       that new users should be aware of.

     II..  GGEETTTTIINNGG SSTTAARRTTEEDD

     LLooggggiinngg IInn

       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  termi-
     nals:  Terminet 300's; Execuport, TI and similar portables; video
     (CRT) terminals like the HP2640, etc.; high-priced graphics  ter-
     minals  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
     _l_o_w_e_r _c_a_s_e_.  If your terminal produces  only  upper  case  (e.g.,
     model  33 Teletype, some video and portable terminals), life will
     be so difficult that you should look for another terminal.










     UNIX For Beginners                                        USD:1-3


       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 _`_`llooggiinn::'' 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 llooggiinn:: message, type your login name _i_n _l_o_w_e_r
     _c_a_s_e_.  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 RETURN.

       The  culmination  of  your  login efforts is a ``prompt charac-
     ter,'' 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.)

     TTyyppiinngg CCoommmmaannddss

       Once you've seen the prompt character, you can  type  commands,
     which are requests that the system do something.  Try typing

         ddaattee

     followed by RETURN.  You should get back something like

         MMoonn JJaann 1166 1144::1177::1100 EESSTT 11997788

     Don't  forget  the RETURN after the command, or nothing will hap-
     pen.  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 each line.

       Another command you might try is wwhhoo, which tells you  everyone
     who is currently logged in:

         wwhhoo

     gives something like

         mmbb   ttttyy0011JJaann 1166    0099::1111
         sskkii  ttttyy0055JJaann 1166    0099::3333
         ggaamm  ttttyy1111JJaann 1166    1133::0077

     The  time  is  when the user logged in; ``ttyxx'' is the system's
     idea of what terminal the user is on.










     USD:1-4                                        UNIX For Beginners


       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

         wwhhoomm

     you will be told

         wwhhoomm:: nnoott ffoouunndd

     Of course, if you inadvertently type the name of some other  com-
     mand, it will run, with more or less mysterious results.

     SSttrraannggee TTeerrmmiinnaall BBeehhaavviioorr

       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 ssttttyy in section 1 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

         ssttttyy --ttaabbss

     and the system will convert each tab into  the  right  number  of
     blanks for you.

     MMiissttaakkeess iinn TTyyppiinngg

       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:

         dddd##aattttee####ee

     is the same as ddaattee.[++]

       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
     -----------
     [+] In Berkeley Unix, the  command  "reset<control-j>"
     will  often  reset  a terminal apparently in a strange
     state because a fullscreen editor crashed.
     [++]  Many  installations  set the erase character for
     display terminals to  the  delete  or  backspace  key.
     "stty all" tells you what it actually is.









     UNIX For Beginners                                        USD:1-5


     \\@@.  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.

     RReeaadd--aahheeaadd

       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.

     SSttooppppiinngg aa PPrrooggrraamm

       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.[++]

     LLooggggiinngg OOuutt

       The easiest way to log out is to hang up the  phone.   You  can
     also type

         llooggiinn

     and  let  someone else use the terminal you were on.*  It is usu-
     ally not sufficient just to turn off  the  terminal.   Most  UNIX
     systems  do not use a time-out mechanism, so you'll be there for-
     ever unless you hang up.

     MMaaiill

       When you log in, you may sometimes get the message

         YYoouu hhaavvee mmaaiill..

     UNIX provides a postal system so you can communicate  with  other
     users of the system.  To read your mail, type the command
     -----------
     [+]  In Berkeley Unix, "control-c" is the usual way to
     stop programs. "stty all" tells you the value of  your
     "intr" key.
     [++]  In  most  modern shells, programs running in the
     background continue running even if you hang up.
     * "control-d" and "logout" are other alternatives.









     USD:1-6                                        UNIX For Beginners


         mmaaiill

     The  headers  of your mail will be printed, in the order of their
     receipt.  A message can be read with the pprriinntt command, or speci-
     fied  directly  by  number.   Other commands are described in the
     manual.  (Earlier versions of mmaaiill do not process one message  at
     a time, but are otherwise similar.)

       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:

         mmaaiill jjooee
         _n_o_w _t_y_p_e _i_n _t_h_e _t_e_x_t _o_f _t_h_e _l_e_t_t_e_r
         _o_n _a_s _m_a_n_y _l_i_n_e_s _a_s _y_o_u _l_i_k_e _._._.
         _A_f_t_e_r _t_h_e _l_a_s_t _l_i_n_e _o_f _t_h_e _l_e_t_t_e_r
         _t_y_p_e _t_h_e _c_h_a_r_a_c_t_e_r _`_`_._'_'_,
         _a_l_o_n_e _o_n _t_h_e _l_a_s_t _l_i_n_e_,
         _l_i_k_e _s_o_:
         _.

     And that's 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  mmaaiill(1).  (The notation mmaaiill(1)
     means the command mmaaiill in section  1  of  the  _U_N_I_X  _P_r_o_g_r_a_m_m_e_r_'_s
     _M_a_n_u_a_l.)

     WWrriittiinngg ttoo ootthheerr uusseerrss[[++]]

       At some point, out of the blue will come a message like

         MMeessssaaggee ffrroomm jjooee ttttyy0077......

     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

         wwrriittee jjooee

     This  establishes a two-way communication path.  Now whatever Joe
     types on his terminal will appear on yours and vice  versa.   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
     -----------
     [+]  Although "write" works on Berkeley UNIX, there is
     a much nicer way of communicating using display-termi-
     nals  --  "talk"  splits the screen into two sections,
     and both of you can type simultaneously (see talk(1)).









     UNIX For Beginners                                        USD:1-7


     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 wwrriittee ssmmiitthh and waits.
         Smith types wwrriittee jjooee 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 ((oo)), which
         stands for ``over''.
         Now Smith types a reply, also terminated by ((oo)).
         This cycle repeats until someone gets tired; he then  signals
         his intent to quit with ((oooo)), for ``over and out''.
         To  terminate  the conversation, each side must type a ``con-
         trol-d'' character alone on a line.  When  the  other  person
         types his ``control-d'', you will get the message EEOOFF 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  ``con-
     trol-d''.

     OOnn--lliinnee MMaannuuaall

       The _U_N_I_X _P_r_o_g_r_a_m_m_e_r_'_s _M_a_n_u_a_l 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 infor-
     mation  on a command.  To print a manual section, type ``man com-
     mand-name''.  Thus to read up on the wwhhoo command, type

         mmaann wwhhoo

     and, of course,

         mmaann mmaann

     tells all about the mmaann command.

     CCoommppuutteerr AAiiddeedd IInnssttrruuccttiioonn

       Your UNIX system may have available  a  program  called  lleeaarrnn,
     which  provides computer aided instruction on the file system and
     basic commands, the editor, document preparation, and even C pro-
     gramming.  Try typing the command

         lleeaarrnn

     If  lleeaarrnn exists on your system, it will tell you what to do from
     there.









     USD:1-8                                        UNIX For Beginners


     IIII..  DDAAYY--TTOO--DDAAYY UUSSEE

     CCrreeaattiinngg FFiilleess ---- TThhee EEddiittoorr

       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''  eedd.   Since  eedd  is
     thoroughly documented in eedd(1) and explained in _A _T_u_t_o_r_i_a_l _I_n_t_r_o_-
     _d_u_c_t_i_o_n _t_o _t_h_e _U_N_I_X _T_e_x_t _E_d_i_t_o_r_, we won't  spend  any  time  here
     describing  how  to  use  it.  All we want it for right now is to
     make some _f_i_l_e_s_.  (A file is just  a  collection  of  information
     stored in the machine, a simplistic but adequate definition.)

       To  create a file called jjuunnkk with some text in it, do the fol-
     lowing:

         eedd jjuunnkk(invokes the text editor)
         aa     (command to ``ed'', to add text)
         _n_o_w _t_y_p_e _i_n
         _w_h_a_t_e_v_e_r _t_e_x_t _y_o_u _w_a_n_t _._._.
         ..     (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 eedd 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 ww:

         ww

     eedd will respond with the number of characters it wrote  into  the
     file jjuunnkk.

       Until  the  ww command, nothing is stored permanently, so if you
     hang  up and go home the information is lost.[+]  But after ww the
     information is there permanently; you can re-access it  any  time
     by typing

         eedd jjuunnkk

     Type a qq command to quit the editor.  (If you try to quit without
     writing, eedd will print a ?? to remind you.  A second  qq  gets  you
     out regardless.)


     -----------
     [+] This is not strictly true -- if you hang up  while
     editing,  the  data  you were working on is saved in a
     file called eedd..hhuupp, which you  can  continue  with  at
     your next session.









     UNIX For Beginners                                        USD:1-9


       Now  create  a second file called tteemmpp in the same manner.  You
     should now have two files, jjuunnkk and tteemmpp.

     WWhhaatt ffiilleess aarree oouutt tthheerree??

       The llss (for ``list'') command lists the names (not contents) of
     any of the files that UNIX knows about.  If you type

         llss

     the response will be

         jjuunnkk
         tteemmpp

     which  are  indeed  the  two  files  just created.  The names are
     sorted into alphabetical order automatically,  but  other  varia-
     tions are possible.  For example, the command

         llss --tt

     causes  the  files  to  be listed in the order in which they were
     last changed, most recent first.  The --ll option gives a  ``long''
     listing:

         llss --ll

     will produce something like

         --rrww--rrww--rrww--  11 bbwwkk  uusseerrss 4411 JJuull 2222 22::5566 jjuunnkk
         --rrww--rrww--rrww--  11 bbwwkk  uusseerrss 7788 JJuull 2222 22::5577 tteemmpp

     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 num-
     bers  you  got  from eedd).  bbwwkk is the owner of the file, that is,
     the person who created it.  uusseerrss  is  the  name  of  the  file's
     group.  The --rrww--rrww--rrww-- tells who has permission to read and write
     the file, in this case everyone.

       Options can be combined: llss --lltt gives the same thing as  llss --ll,
     but  sorted  into time order.  You can also name the files you're
     interested in, and llss will list the information about them  only.
     More details can be found in llss(1).

       The  use  of  optional  arguments that begin with a minus sign,
     like --tt and --lltt, is a common convention for  UNIX  programs.   In
     general,  if a program accepts such optional arguments, they pre-
     cede any filename arguments.  It is also vital that you  separate
     the  various  arguments  with  spaces:  llss--ll  is  not the same as
     llss  --ll.













     USD:1-10                                       UNIX For Beginners


     PPrriinnttiinngg FFiilleess

       Now that you've got a file of text, how do you print it so peo-
     ple  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

         eedd jjuunnkk
         11,,$$pp

     eedd  will  reply with the count of the characters in jjuunnkk 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 eedd 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  ccaatt, the simplest of all the printing programs.  ccaatt
     simply prints on the terminal the contents of all the files named
     in a list.  Thus

         ccaatt jjuunnkk

     prints one file, and

         ccaatt jjuunnkk tteemmpp

     prints  two.   The  files are simply concatenated (hence the name
     _`_`ccaatt'') onto the terminal.

       pprr produces formatted printouts of  files.   As  with  ccaatt,  pprr
     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 skip over the fold in
     the paper.  Thus,

         pprr jjuunnkk tteemmpp

     will print jjuunnkk neatly, then skip to the top of a  new  page  and
     print tteemmpp neatly.

       pprr can also produce multi-column output:

         pprr --33 jjuunnkk

     prints  jjuunnkk in 3-column format.  You can use any reasonable num-
     ber in place of ``3'' and pprr will do  its  best.   pprr  has  other
     capabilities as well; see pprr(1).










     UNIX For Beginners                                       USD:1-11


       It  should  be noted that pprr is _n_o_t a formatting program in the
     sense of shuffling lines around and justifying margins.  The true
     formatters  are nnrrooffff and ttrrooffff, which we will get to in the sec-
     tion on document preparation.

       There are also  programs  that  print  files  on  a  high-speed
     printer.  Look in your manual under llpprr.

     SShhuufffflliinngg FFiilleess AAbboouutt

       Now  that you have some files in the file system and some expe-
     rience 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:

         mmvv jjuunnkk pprreecciioouuss

     This means that what used to be ``junk'' is now ``precious''.  If
     you do an llss command now, you will get

         pprreecciioouuss
         tteemmpp

     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 _c_o_p_y of a file (that is, to have two ver-
     sions of something), you can use the ccpp command:

         ccpp pprreecciioouuss tteemmpp11

     makes a duplicate copy of pprreecciioouuss in tteemmpp11.

       Finally, when you get tired of creating and moving files, there
     is a command to remove files from the file system, called rrmm.

         rrmm tteemmpp tteemmpp11

     will remove both of the files named.

       You will get a warning message if one of the named files wasn't
     there,  but  otherwise rrmm, 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.

     WWhhaatt''ss iinn aa FFiilleennaammee

       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  descrip-
     tive.[+]  Second, although you can use almost any character in  a
     -----------
     [+]  In  4.2 BSD the limit was extended to 255 charac-









     USD:1-12                                       UNIX For Beginners


     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 llss command, llss --tt means to list in time order.  So if
     you  had  a  file  whose name was --tt, 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 eedd 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

         cchhaapp11
         cchhaapp22
         etc...

     Or, if each chapter were broken into  several  files,  you  might
     have

         cchhaapp11..11
         cchhaapp11..22
         cchhaapp11..33
         ......
         cchhaapp22..11
         cchhaapp22..22
         ......

     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

         pprr cchhaapp11..11 cchhaapp11..22 cchhaapp11..33 ............

     but you would get tired pretty fast, and would probably even make
     mistakes.  Fortunately, there is a shortcut.  You can say

         pprr cchhaapp**

     The  ** means ``anything at all,'' so this translates into ``print
     all files whose names begin with cchhaapp'', listed  in  alphabetical
     order.

       This shorthand notation is not a property of the pprr command, by
     the way.  It is  system-wide,  a  service  of  the  program  that
     -----------
     ters.









     UNIX For Beginners                                       USD:1-13


     interprets commands (the ``shell,'' sshh(1)).  Using that fact, you
     can see how to list the names of the files in the book:

         llss cchhaapp**

     produces

         cchhaapp11..11
         cchhaapp11..22
         cchhaapp11..33
         ......

     The ** is not limited to the last position in a filename -- it can
     be anywhere and can occur several times.  Thus

         rrmm **jjuunnkk** **tteemmpp**

     removes  all files that contain jjuunnkk or tteemmpp as any part of their
     name.  As a special case, ** by itself matches every filename, so

         pprr **

     prints all your files (alphabetical order), and

         rrmm **

     removes _a_l_l _f_i_l_e_s_.  (You had better be _v_e_r_y sure that's what  you
     wanted to say!)

       The ** is not the only pattern-matching feature available.  Sup-
     pose you want to print only chapters 1 through 4 and 9.  Then you
     can say

         pprr cchhaapp[[1122334499]]**

     The  [[......]] means to match any of the characters inside the brack-
     ets.  A range of consecutive letters or digits  can  be  abbrevi-
     ated, so you can also do this with

         pprr cchhaapp[[11--4499]]**

     Letters can also be used within brackets: [[aa--zz]] matches any char-
     acter in the range aa through zz.

       The ?? pattern matches any single character, so

         llss ??

     lists all files which have single-character names, and

         llss --ll cchhaapp??..11

     lists information about the first file of each chapter  _(cchhaapp11..11,
     cchhaapp22..11, etc.).









     USD:1-14                                       UNIX For Beginners


       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

         llss ''??''

     We'll see some more examples of this shortly.

     WWhhaatt''ss iinn aa FFiilleennaammee,, CCoonnttiinnuueedd

       When you first made that file called jjuunnkk, how did  the  system
     know  that  there  wasn't another jjuunnkk somewhere else, especially
     since the person in the next office is also  reading  this  tuto-
     rial?   The  answer  is  that  generally  each user has a private
     _d_i_r_e_c_t_o_r_y, 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 new file, 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 walk-
     ing  along the proper set of branches.  Conversely, you can start
     where you are and walk toward the root.

       Let's try the latter first.  The basic tools is the command ppwwdd
     (``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 ppwwdd, it will print something like

         //uussrr//yyoouurr--nnaammee

     This  says  that  you  are  currently in the directory yyoouurr--nnaammee,
     which is in turn in the directory //uussrr, which is in turn  in  the
     root  directory  called  by convention just //.  (Even if it's not
     called //uussrr on your system, you  will  get  something  analogous.
     Make the corresponding mental adjustment and read on.)

       If you now type

         llss //uussrr//yyoouurr--nnaammee

     you  should  get  exactly  the same list of file names as you get
     from a plain llss: with no arguments, llss lists the contents of  the
     current  directory;  given  the name of a directory, it lists the
     contents of that directory.










     UNIX For Beginners                                       USD:1-15


       Next, try

         llss //uussrr

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

       The next step is to try

         llss //

     You should get a response something like this (although again the
     details may be different):

         bbiinn
         ddeevv
         eettcc
         lliibb
         ttmmpp
         uussrr

     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

         ccaatt //uussrr//yyoouurr--nnaammee//jjuunnkk

     (if jjuunnkk is still around in your directory).  The name

         //uussrr//yyoouurr--nnaammee//jjuunnkk

     is  called the ppaatthhnnaammee 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:





















     USD:1-16                                       UNIX For Beginners


                                    (root)
                                     / | \
                                    /  |  \
                                   /   |   \
                         bin    etc    usr    dev   tmp
                     / | \   / | \   / | \   / | \   / | \
                                    /  |  \
                                   /   |   \
                               adam  eve   mary
                            /        /   \        \
                                     /     \       junk
                                   junk temp


     Notice that Mary's jjuunnkk is unrelated to Eve's.

       This isn't too exciting if all the files  of  interest  are  in
     your  own directory, but if you work with someone else or on sev-
     eral projects concurrently, it becomes handy indeed.   For  exam-
     ple, your friends can print your book by saying

         pprr //uussrr//yyoouurr--nnaammee//cchhaapp**

     Similarly,  you can find out what files your neighbor has by say-
     ing

         llss //uussrr//nneeiigghhbboorr--nnaammee

     or make your own copy of one of his files by

         ccpp //uussrr//yyoouurr--nneeiigghhbboorr//hhiiss--ffiillee yyoouurrffiillee


       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 llss(1) and
     cchhmmoodd(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

         llss //bbiinn //uussrr//bbiinn

     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 //bbiinn  and
     finally  in //uussrr//bbiinn.  There is nothing magic about commands like
     ccaatt or llss, except that they have been collected into a couple  of
     places to be easy to find and administer.

       What if you work regularly with someone else on common informa-
     tion in his directory?  You could just log in as your friend each









     UNIX For Beginners                                       USD:1-17


     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  direc-
     tory that you are currently in:

         ccdd //uussrr//yyoouurr--ffrriieenndd

     (On some systems, ccdd is spelled cchhddiirr.)  Now when you use a file-
     name in something like ccaatt or pprr, it refers to the file  in  your
     friend's directory.  Changing directories doesn't affect any per-
     missions 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

         ppwwdd

     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  bbooookk.   So  make
     one with

         mmkkddiirr bbooookk

     then go to it with

         ccdd bbooookk

     then  start  typing  chapters.  The book is now found in (presum-
     ably)

         //uussrr//yyoouurr--nnaammee//bbooookk

     To remove the directory bbooookk, type

         rrmm bbooookk//**
         rrmmddiirr bbooookk

     The first command removes all files from the directory; the  sec-
     ond removes the empty directory.

       You can go up one level in the tree of files by saying

         ccdd ....

     _`_`....''  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.













     USD:1-18                                       UNIX For Beginners


     UUssiinngg FFiilleess iinnsstteeaadd ooff tthhee TTeerrmmiinnaall

       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 example,

         llss

     makes a list of files on your terminal.  But if you say

         llss >>ffiilleelliisstt

     a  list  of your files will be placed in the file ffiilleelliisstt (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 ccaatt in a file:

         ccaatt ff11 ff22 ff33 >>tteemmpp


       The symbol >>>> operates very much like >> does,  except  that  it
     means ``add to the end of.''  That is,

         ccaatt ff11 ff22 ff33 >>>>tteemmpp

     means  to  concatenate  ff11,  ff22  and ff33 to the end of whatever is
     already in tteemmpp, instead of overwriting  the  existing  contents.
     As with >>, if tteemmpp 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 com-
     mands and put them into a file called ssccrriipptt.  Then you  can  run
     the script on a file by saying

         eedd ffiillee <<ssccrriipptt

     As  another  example,  you can use eedd to prepare a letter in file
     lleett, then send it to several people with

         mmaaiill aaddaamm eevvee mmaarryy jjooee <<lleett


     PPiippeess

       One of the novel contributions of the UNIX system is  the  idea
     of  a  _p_i_p_e_.  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.










     UNIX For Beginners                                       USD:1-19


       For example,

         pprr ff gg hh

     will  print  the files ff, gg, and hh, beginning each on a new page.
     Suppose you want them run together instead.  You could say

         ccaatt ff gg hh >>tteemmpp
         pprr <<tteemmpp
         rrmm tteemmpp

     but this is more work than necessary.  Clearly what we want is to
     take the output of ccaatt and connect it to the input of pprr.  So let
     us use a pipe:

         ccaatt ff gg hh || pprr

     The vertical bar || means to take the output from ccaatt, which would
     normally  have  gone  to  the  terminal, and put it into pprr to be
     neatly formatted.

       There are many other examples of pipes.  For example,

         llss || pprr --33

     prints a list of your files in three  columns.   The  program  wwcc
     counts  the  number  of lines, words and characters in its input,
     and as we saw earlier, wwhhoo prints a list of  currently-logged  on
     people, one per line.  Thus

         wwhhoo || wwcc

     tells how many people are logged on.  And of course

         llss || wwcc

     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.  pprr is one example:

         pprr --33 aa bb cc

     prints files aa, bb and cc in order in three columns.  But in

         ccaatt aa bb cc || pprr --33

     pprr prints the information coming  down  the  pipeline,  still  in









     USD:1-20                                       UNIX For Beginners


     three columns.

     TThhee SShheellll

       We   have  already  mentioned  once  or  twice  the  mysterious
     ``shell,'' which is in fact sshh(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

         ddaattee;; wwhhoo

     does both commands before returning with a prompt character.

       You can also have more than one program running  _s_i_m_u_l_t_a_n_e_o_u_s_l_y
     if  you  wish.  For example, if you are doing something time-con-
     suming, like the editor script of an  earlier  section,  and  you
     don't  want  to wait around for the results before starting some-
     thing else, you can say

         eedd ffiillee <<ssccrriipptt &&

     The ampersand at the end of a command line says ``start this com-
     mand  running, then take further commands from the terminal imme-
     diately,'' that is, don't wait for  it  to  complete.   Thus  the
     script  will  begin,  but  you  can do something else at the same
     time.  Of course, to keep the output from interfering  with  what
     you're doing on the terminal, it would be better to say

         eedd ffiillee <<ssccrriipptt >>ssccrriipptt..oouutt &&

     which saves the output lines in a file called ssccrriipptt..oouutt.

       When  you  initiate a command with &&, the system replies with a
     number called the process number, which identifies the command in
     case you later want to stop it.  If you do, you can say

         kkiillll pprroocceessss--nnuummbbeerr

     If  you  forget  the process number, the command ppss will tell you
     about everything you have running.  (If you are desperate, kkiillll 00
     will kill all your processes.)  And if you're curious about other
     people, ppss aa will tell you about _a_l_l programs that are  currently
     running.

       You can say

         ((ccoommmmaanndd--11;; ccoommmmaanndd--22;; ccoommmmaanndd--33)) &&










     UNIX For Beginners                                       USD:1-21


     to  start  three  commands  in the background, or you can start a
     background pipeline with

         ccoommmmaanndd--11 || ccoommmmaanndd--22 &&


       Just as you can tell the editor or some similar program to take
     its  input from a file instead of from the terminal, you can tell
     the shell to read a file to get commands.  (Why not?  The  shell,
     after  all,  is  just  a  program,  albeit  a  clever  one.)  For
     instance, suppose you want to set tabs on your terminal, and find
     out the date and who's on the system every time you log in.  Then
     you can put the three necessary commands _(ttaabbss, ddaattee, wwhhoo) into a
     file, let's call it ssttaarrttuupp, and then run it with

         sshh ssttaarrttuupp

     This  says  to run the shell with the file ssttaarrttuupp as input.  The
     effect is as if you had typed the contents of ssttaarrttuupp on the ter-
     minal.

       If this is to be a regular thing, you can eliminate the need to
     type sshh: simply type, once only, the command

         cchhmmoodd ++xx ssttaarrttuupp

     and thereafter you need only say

         ssttaarrttuupp

     to run the sequence of commands.  The cchhmmoodd(1) command marks  the
     file  executable;  the  shell  recognizes  this  and runs it as a
     sequence of commands.

       If you want ssttaarrttuupp to run automatically every time you log in,
     create  a file in your login directory called ..pprrooffiillee, and place
     in it the line ssttaarrttuupp.  When the shell first gains control  when
     you log in, it looks for the ..pprrooffiillee file and does whatever com-
     mands it finds in it.[+]  We'll get back to the shell in the sec-
     tion on programming.


     IIIIII.. DDOOCCUUMMEENNTT PPRREEPPAARRAATTIIOONN

       UNIX  systems  are  used  extensively for document preparation.
     There are two major formatting programs, that is,  programs  that
     produce  a text with justified right margins, automatic page num-
     bering and titling, automatic hyphenation, and the  like.   nnrrooffff
     is  designed  to  produce  output on terminals and line-printers.
     ttrrooffff (pronounced ``tee-roff'') instead drives a phototypesetter,
     which  produces  very  high quality output on photographic paper.
     This paper was formatted with ttrrooffff.
     -----------
     [+] The c shell instead reads a file called ..llooggiinn









     USD:1-22                                       UNIX For Beginners


     FFoorrmmaattttiinngg PPaacckkaaggeess

       The basic idea of nnrrooffff and ttrrooffff is that the text to  be  for-
     matted  contains  within it ``formatting commands'' that indicate
     in detail how the formatted text is to look.  For example,  there
     might be commands that specify how long lines are, whether to use
     single or double spacing, and what running titles to use on  each
     page.

       Because  nnrrooffff  and  ttrrooffff  are relatively hard to learn to use
     effectively, several ``packages'' of canned  formatting  requests
     are  available  to  let  you  specify paragraphs, running titles,
     footnotes, multi-column output, and so on, with little effort and
     without  having  to learn nnrrooffff and ttrrooffff.  These packages take a
     modest effort to learn, but the rewards for  using  them  are  so
     great that it is time well spent.

       In  this  section,  we will provide a hasty look at the ``manu-
     script'' package known as  --mmss.   Formatting  requests  typically
     consist  of  a  period  and  two upper-case letters, such as ..TTLL,
     which is used to introduce a title, or ..PPPP to begin a  new  para-
     graph.

       A document is typed so it looks something like this:

         ..TTLL
         ttiittllee ooff ddooccuummeenntt
         ..AAUU
         aauutthhoorr nnaammee
         ..SSHH
         sseeccttiioonn hheeaaddiinngg
         ..PPPP
         ppaarraaggrraapphh ......
         ..PPPP
         aannootthheerr ppaarraaggrraapphh ......
         ..SSHH
         aannootthheerr sseeccttiioonn hheeaaddiinngg
         ..PPPP
         eettcc..

     The  lines  that begin with a period are the formatting requests.
     For example, ..PPPP calls for starting a new paragraph.  The precise
     meaning of ..PPPP depends on what output device is being used (type-
     setter or terminal, for instance), and on  what  publication  the
     document  will appear in.  For example, --mmss normally assumes that
     a paragraph is preceded by a space (one line in nnrrooffff,  1/2  line
     in  ttrrooffff),  and  the first word is indented.  These rules can be
     changed if you like, but they are changed by changing the  inter-
     pretation of ..PPPP, not by re-typing the document.

       To  actually  produce  a document in standard format using --mmss,
     use the command











     UNIX For Beginners                                       USD:1-23


         ttrrooffff --mmss ffiilleess ......

     for the typesetter, and

         nnrrooffff --mmss ffiilleess ......

     for a terminal.  The --mmss argument tells ttrrooffff and  nnrrooffff  to  use
     the manuscript package of formatting requests.

       There  are  several similar packages; check with a local expert
     to determine which ones are in common use on your machine.

     SSuuppppoorrttiinngg TToooollss

       In addition to the basic formatters, there is a  host  of  sup-
     porting  programs  that help with document preparation.  The list
     in the next few  paragraphs  is  far  from  complete,  so  browse
     through  the  manual  and  check with people around you for other
     possibilities.

       eeqqnn and nneeqqnn let you integrate mathematics into the text  of  a
     document, in an easy-to-learn language that closely resembles the
     way you would speak it aloud.  For example, the eeqqnn input

         ssuumm ffrroomm ii==00 ttoo nn xx ssuubb ii ~~==~~ ppii oovveerr 22

     produces the output

                  sum from i=0 to n x sub i ~=~ pi over 2


       The program ttbbll provides an  analogous  service  for  preparing
     tabular material; it does all the computations necessary to align
     complicated columns with elements of varying widths.

       rreeffeerr prepares bibliographic citations from  a  data  base,  in
     whatever  style  is  defined by the formatting package.  It looks
     after all the details of numbering references in sequence,  fill-
     ing in page and volume numbers, getting the author's initials and
     the journal name right, and so on.

       ssppeellll and ttyyppoo detect possible spelling  mistakes  in  a  docu-
     ment.[+]   ssppeellll works by comparing the words in your document to
     a dictionary, printing those that are not in the dictionary.   It
     knows  enough  about  English  spelling to detect plurals and the
     like, so it does a very good job.  ttyyppoo looks for words which are
     ``unusual'', and prints those.  Spelling mistakes tend to be more
     unusual, and thus show up early when the most unusual  words  are
     printed first.

       ggrreepp looks through a set of files for lines that contain a par-
     ticular text pattern (rather like  the  editor's  context  search
     -----------
     [+] "typo" is not provided with Berkeley Unix.









     USD:1-24                                       UNIX For Beginners


     does, but on a bunch of files).  For example,

         ggrreepp ''iinngg$$'' cchhaapp**

     will  find  all  lines that end with the letters iinngg in the files
     cchhaapp**.  (It is almost always a good practice to put single quotes
     around  the  pattern  you're  searching  for, in case it contains
     characters like ** or $$ that have a special meaning to the shell.)
     ggrreepp  is  often useful for finding out in which of a set of files
     the misspelled words detected by ssppeellll are actually located.

       ddiiffff prints a list of the differences between two files, so you
     can  compare  two versions of something automatically (which cer-
     tainly beats proofreading by hand).

       wwcc counts the words, lines and characters in a  set  of  files.
     ttrr  translates  characters  into other characters; for example it
     will convert upper to lower case and vice versa.  This translates
     upper into lower:

         ttrr AA--ZZ aa--zz <<iinnppuutt >>oouuttppuutt


       ssoorrtt sorts files in a variety of ways; sseedd provides many of the
     editing facilities of eedd, but can apply them to arbitrarily  long
     inputs.  aawwkk provides the ability to do both pattern matching and
     numeric computations, and to conveniently process  fields  within
     lines.   These programs are for more advanced users, and they are
     not limited to document preparation.  Put them on  your  list  of
     things to learn about.

       Most  of  these  programs  are  either independently documented
     (like eeqqnn and ttbbll), or are sufficiently simple that the  descrip-
     tion in the _U_N_I_X _P_r_o_g_r_a_m_m_e_r_'_s _M_a_n_u_a_l is adequate explanation.

     HHiinnttss ffoorr PPrreeppaarriinngg DDooccuummeennttss

       Most  documents  go  through several versions (always more than
     you expected) before they are finally finished.  Accordingly, you
     should  do  whatever  possible  to  make the job of changing them
     easy.

       First, when you do the purely mechanical operations of  typing,
     type  so  that  subsequent editing will be easy.  Start each sen-
     tence on a new line.  Make lines short, and break lines at  natu-
     ral places, such as after commas and semicolons, rather than ran-
     domly.  Since most people change documents by  rewriting  phrases
     and adding, deleting and rearranging sentences, these precautions
     simplify any editing you have to do later.

       Keep the individual files of a document down  to  modest  size,
     perhaps  ten  to  fifteen thousand characters.  Larger files edit
     more slowly, and of course if you make a dumb mistake it's better
     to  have clobbered a small file than a big one.  Split into files









     UNIX For Beginners                                       USD:1-25


     at natural boundaries in the document, for the same reasons  that
     you start each sentence on a new line.

       The  second aspect of making change easy is to not commit your-
     self to formatting details too early.  One of the  advantages  of
     formatting  packages  like  --mmss  is that they permit you to delay
     decisions to the last possible moment.  Indeed, until a  document
     is  printed, it is not even decided whether it will be typeset or
     put on a line printer.

       As a rule of thumb, for all but  the  most  trivial  jobs,  you
     should  type  a  document in terms of a set of requests like ..PPPP,
     and then define them appropriately, either by using  one  of  the
     canned  packages  (the  better way) or by defining your own nnrrooffff
     and ttrrooffff commands.  As long as you have entered the text in some
     systematic way, it can always be cleaned up and re-formatted by a
     judicious combination of editing  commands  and  request  defini-
     tions.

     IIVV..  PPRROOGGRRAAMMMMIINNGG

       There  will  be no attempt made to teach any of the programming
     languages available but a few words of advice are in order.   One
     of  the  reasons  why the UNIX system is a productive programming
     environment is that there is already a rich set of  tools  avail-
     able,  and  facilities like pipes, I/O redirection, and the capa-
     bilities of the shell often make it possible to do a job by past-
     ing  together programs that already exist instead of writing from
     scratch.

     TThhee SShheellll

       The pipe mechanism lets you fabricate quite complicated  opera-
     tions  out  of  spare parts that already exist.  For example, the
     first draft of the ssppeellll program was (roughly)

         ccaatt ......     _c_o_l_l_e_c_t _t_h_e _f_i_l_e_s
         || ttrr ......    _p_u_t _e_a_c_h _w_o_r_d _o_n _a _n_e_w _l_i_n_e
         || ttrr ......    _d_e_l_e_t_e _p_u_n_c_t_u_a_t_i_o_n_, _e_t_c_.
         || ssoorrtt      _i_n_t_o _d_i_c_t_i_o_n_a_r_y _o_r_d_e_r
         || uunniiqq      _d_i_s_c_a_r_d _d_u_p_l_i_c_a_t_e_s
         || ccoommmm      _p_r_i_n_t _w_o_r_d_s _i_n _t_e_x_t
                 _b_u_t _n_o_t _i_n _d_i_c_t_i_o_n_a_r_y

     More pieces have been added subsequently, but this  goes  a  long
     way for such a small effort.

       The editor can be made to do things that would normally require
     special programs on other systems.   For  example,  to  list  the
     first  and  last lines of each of a set of files, such as a book,
     you could laboriously type












     USD:1-26                                       UNIX For Beginners


         eedd
         ee cchhaapp11..11
         11pp
         $$pp
         ee cchhaapp11..22
         11pp
         $$pp
         etc.

     But you can do the job much more easily.  One way is to type

         llss cchhaapp** >>tteemmpp

     to get the list of filenames into a file.  Then edit this file to
     make  the  necessary series of editing commands (using the global
     commands of eedd), and write it into ssccrriipptt.  Now the command

         eedd <<ssccrriipptt

     will produce the  same  output  as  the  laborious  hand  typing.
     Alternately  (and  more  easily),  you  can use the fact that the
     shell will perform loops, repeating a set of  commands  over  and
     over again for a set of arguments:

         ffoorr ii iinn cchhaapp**
         ddoo
              eedd $$ii <<ssccrriipptt
         ddoonnee

     This  sets  the  shell variable ii to each file name in turn, then
     does the command.  You can type this command at the terminal,  or
     put it in a file for later execution.

     PPrrooggrraammmmiinngg tthhee SShheellll

       An  option  often  overlooked by newcomers is that the shell is
     itself a  programming  language,  with  variables,  control  flow
     _(iiff--eellssee, wwhhiillee, ffoorr, ccaassee), subroutines, and interrupt handling.
     Since there are many building-block programs, you  can  sometimes
     avoid  writing  a  new program merely by piecing together some of
     the building blocks with shell command files.

       We will not go into any details here; examples and rules can be
     found in _A_n _I_n_t_r_o_d_u_c_t_i_o_n _t_o _t_h_e _U_N_I_X _S_h_e_l_l, by S. R. Bourne.

     PPrrooggrraammmmiinngg iinn CC

       If you are undertaking anything substantial, C is the only rea-
     sonable choice of programming language: everything  in  the  UNIX
     system is tuned to it.  The system itself is written in C, as are
     most of the programs that run on it.  It is also an easy language
     to use once you get started.  C is introduced and fully described
     in _T_h_e _C _P_r_o_g_r_a_m_m_i_n_g _L_a_n_g_u_a_g_e  by  B.  W.  Kernighan  and  D.  M.
     Ritchie  (Prentice-Hall,  1978).   Several sections of the manual









     UNIX For Beginners                                       USD:1-27


     describe the system interfaces, that is, how you do I/O and simi-
     lar  functions.   Read  _U_N_I_X  _P_r_o_g_r_a_m_m_i_n_g  for  more  complicated
     things.

       Most input and output in C is best handled  with  the  standard
     I/O  library, which provides a set of I/O functions that exist in
     compatible form on most machines that have C compilers.  In  gen-
     eral, it's wisest to confine the system interactions in a program
     to the facilities provided by this library.

       C programs that don't depend too much on  special  features  of
     UNIX  (such as pipes) can be moved to other computers that have C
     compilers.  The list of such machines grows daily; in addition to
     the  original  PDP-11,  it  currently includes at least Honeywell
     6000, IBM 370 and PC families, Interdata 8/32, Data General  Nova
     and Eclipse, HP 2100, Harris /7, Motorola 68000 family (including
     machines like Sun Microsystems and Apple Macintosh), VAX 11  fam-
     ily,  SEL  86,  and Zilog Z80.  Calls to the standard I/O library
     will work on all of these machines.

       There are a number of supporting programs that go with C.  lliinntt
     checks C programs for potential portability problems, and detects
     errors such as mismatched argument types and uninitialized  vari-
     ables.

       For  larger programs (anything whose source is on more than one
     file) mmaakkee allows you  to  specify  the  dependencies  among  the
     source  files  and the processing steps needed to make a new ver-
     sion; it then checks the times that the pieces were last  changed
     and does the minimal amount of recompiling to create a consistent
     updated version.

       The debugger ggddbb is useful for digging through the dead  bodies
     of  C  programs,  but is rather hard to learn to use effectively.
     The most effective debugging tool is still careful thought,  cou-
     pled with judiciously placed print statements.

       The  C  compiler provides a limited instrumentation service, so
     you can find out where programs spend their time and  what  parts
     are  worth optimizing.  Compile the routines with the --ppgg option;
     after the test run, use ggpprrooff to print an execution profile.  The
     command  ttiimmee  will  give  you the gross run-time statistics of a
     program, but they are not super accurate or reproducible.

     OOtthheerr LLaanngguuaaggeess

       If you _h_a_v_e to use Fortran, there are two  possibilities.   You
     might  consider Ratfor, which gives you the decent control struc-
     tures and free-form input that characterize C, yet lets you write
     code  that is still portable to other environments.  Bear in mind
     that UNIX Fortran tends to produce large and relatively slow-run-
     ning  programs.  Furthermore, supporting software like ggddbb, pprrooff,
     etc., are all virtually useless with Fortran programs.  There may
     also  be  a Fortran 77 compiler on your system.  If so, this is a









     USD:1-28                                       UNIX For Beginners


     viable alternative to Ratfor, and has the  non-trivial  advantage
     that  it  is compatible with C and related programs.  (The Ratfor
     processor and C tools can be used with Fortran 77 too.)

       If your application requires you to translate a language into a
     set  of actions or another language, you are in effect building a
     compiler, though probably a small one.  In that case, you  should
     be  using  the  yyaacccc compiler-compiler, which helps you develop a
     compiler quickly.  The lleexx lexical analyzer  generator  does  the
     same job for the simpler languages that can be expressed as regu-
     lar expressions.  It can be used by itself, or as a front end  to
     recognize  inputs  for  a  yyaacccc-based program.  Both yyaacccc and lleexx
     require some sophistication to use, but  the  initial  effort  of
     learning  them can be repaid many times over in programs that are
     easy to change later on.

       Most UNIX systems also make available other languages, such  as
     Algol  68,  APL,  Basic, Lisp, Pascal, and Snobol.  Whether these
     are useful depends largely on the local environment:  if  someone
     cares  about the language and has worked on it, it may be in good
     shape.  If not, the odds are strong that it will be more  trouble
     than it's worth.

     VV..  UUNNIIXX RREEAADDIINNGG LLIISSTT

     GGeenneerraall::

     K.  L.  Thompson and D. M. Ritchie, _T_h_e _U_N_I_X _P_r_o_g_r_a_m_m_e_r_'_s _M_a_n_u_a_l_,
     Bell Laboratories, 1978 (PS2:3)[++] Lists commands,  system  rou-
     tines  and  interfaces, file formats, and some of the maintenance
     procedures.  You can't live without this, although you will prob-
     ably only need to read section 1.

     D.  M.  Ritchie  and K. L. Thompson, ``The UNIX Time-sharing Sys-
     tem,''  CACM,  July  1974. (PS2:1)[++] An overview of the system,
     for people interested in operating  systems.   Worth  reading  by
     anyone  who  programs.   Contains a remarkable number of one-sen-
     tence observations on how to do things right.

     The Bell System Technical Journal (BSTJ) Special Issue  on  UNIX,
     July/August,  1978, contains many papers describing recent devel-
     opments, and some retrospective material.

     The 2nd International Conference on Software  Engineering  (Octo-
     ber, 1976) contains several papers describing the use of the Pro-
     grammer's Workbench (PWB) version of UNIX.
     -----------
     [+] These documents (previously in  Volume  2  of  the
     Bell  Labs  Unix  distribution) are provided among the
     "User Supplementary" Documents for  4.3BSD,  available
     from the Usenix Association.
     [++]  These  are  among the "Programmer Supplementary"
     Documents for 4.3BSD.  PS1 is Volume 1, PS2 is  Volume
     2.









     UNIX For Beginners                                       USD:1-29


     DDooccuummeenntt PPrreeppaarraattiioonn::

     B. W. Kernighan, ``A Tutorial Introduction to the UNIX Text  Edi-
     tor''  (USD:12)  and  ``Advanced Editing on UNIX,'' (USD:13) Bell
     Laboratories, 1978.[+]   Beginners  need  the  introduction;  the
     advanced material will help you get the most out of the editor.

     M.  E.  Lesk,  ``Typing  Documents  on UNIX,'' Bell Laboratories,
     1978. (USD:20)[+] Describes the --mmss macro package, which isolates
     the  novice  from the vagaries of nnrrooffff and ttrrooffff, and takes care
     of most formatting situations.  If this  specific  package  isn't
     available  on  your  system,  something similar probably is.  The
     most likely alternative is the PWB/UNIX macro  package  --mmmm;  see
     your local guru if you use PWB/UNIX.*

     B.  W.  Kernighan  and  L.  L. Cherry, ``A System for Typesetting
     Mathematics,'' Bell Laboratories Computing Science Tech. Rep. 17.
     (USD:26)[+]

     M. E. Lesk, ``Tbl -- A Program to Format Tables,'' Bell Laborato-
     ries CSTR 49, 1976. (USD:28)[+]

     J. F. Ossanna, Jr., ``NROFF/TROFF User's Manual,'' Bell Laborato-
     ries CSTR 54, 1976. (USD:24)[+] ttrrooffff is the basic formatter used
     by --mmss, eeqqnn and ttbbll.  The reference manual  is  indispensable  if
     you  are  going  to  write or maintain these or similar programs.
     But start with:

     B. W. Kernighan, ``A TROFF Tutorial,'' Bell  Laboratories,  1976.
     (USD:25)[+] An attempt to unravel the intricacies of ttrrooffff.

     PPrrooggrraammmmiinngg::

     B.  W.  Kernighan  and D. M. Ritchie, _T_h_e _C _P_r_o_g_r_a_m_m_i_n_g _L_a_n_g_u_a_g_e_,
     Prentice-Hall, 1978.  Contains a tutorial introduction,  complete
     discussions of all language features, and the reference manual.

     B.  W.  Kernighan  and R. Pike, _T_h_e _U_n_i_x _P_r_o_g_r_a_m_m_i_n_g _E_n_v_i_r_o_n_m_e_n_t_,
     Prentice-Hall, 1984.  Contains many examples of C programs  which
     use the system interfaces, and explanations of ``why''.

     B.  W.  Kernighan  and  D. M. Ritchie, ``UNIX Programming,'' Bell
     Laboratories, 1978. (PS2:3)[++] Describes how to  interface  with
     the system from C programs: I/O calls, signals, processes.

     S. R. Bourne, ``An Introduction to the UNIX Shell,'' Bell Labora-
     tories, 1978. (USD:3)[+] An introduction and reference manual for
     the  Version  7  shell.   Mandatory reading if you intend to make
     effective use of the programming power of this shell.

     -----------
     *The  macro  package  -me is additionally available on
     Berkeley Unix Systems.  -mm is  typically  not  avail-
     able.









     USD:1-30                                       UNIX For Beginners


     S. C. Johnson, ``Yacc -- Yet  Another  Compiler-Compiler,''  Bell
     Laboratories CSTR 32, 1978. (PS1:15)[++]

     M. E. Lesk, ``Lex -- A Lexical Analyzer Generator,'' Bell Labora-
     tories CSTR 39, 1975. (PS1:16)[++]

     S. C. Johnson, ``Lint, a C Program Checker,''  Bell  Laboratories
     CSTR 65, 1977. (PS1:9)[++]

     S.  I. Feldman, ``MAKE -- A Program for Maintaining Computer Pro-
     grams,'' Bell Laboratories CSTR 57, 1977. (PS1:12)[++]

     J. F. Maranzano and S. R. Bourne, ``A  Tutorial  Introduction  to
     ADB,'' Bell Laboratories CSTR 62, 1977. (PS1:10)[++] An introduc-
     tion to a powerful but complex debugging tool.

     S. I. Feldman and P. J. Weinberger, ``A Portable Fortran 77  Com-
     piler,''  Bell  Laboratories, 1978. (PS1:2)[++] A full Fortran 77
     for UNIX systems.









































