                        

        FROM THE INTRODUCTION, PAGE 3: 
        The  buzzword, of  course, is  "user-friendly".   But  user-friendly
        can be user-exploitative. When you pop a disk into the slot and obed-
        iently  follow  the  cursor around the screen, you are not operating
        the computer, it is operating you.  Far  more than you might want to 
        admit, your  intelligence and your imagination are being manipulated
        by a will other than your own.   And  for  good  reason.   The  more
        user-friendly  the  system, the more sophisticated its software, the
        more sophisticated the machines that service it, the gaudier the ads
        in the computer magazines and the more merrily  the  cash  registers 
        ring. And, of course, the more strident the hype that if you are con-
        tent  with  anything less than a 200 megabyte drive, a bookcase full
        of  store-bought  software  and enough material on your CD's to last
        three and a half lifetimes, you are not  keeping up with the times.
             But  so what if you are not? It is important to remember that a
        computer is a tool, an elegant tool, yes, but no more elegant than a
        musical instrument or an artist's brush.  Further, that a tool is no
        better than the quality of the effort dedicated to its use. And just
        as  a  poor workman blames his tools, so, I suspect, do all too many
        computer people, amateurs  and  professionals alike, chase after the
        latest developments in hardware and software to compensate for their
        own lack of imagination and skill.  
        .........................................................................    
    
        FROM THE INTRODUCTION, PAGE 8:  
        A few words about QBASIC.  QBASIC has many features that interpreted
        BASIC  does  not.  Its  data  structure is more highly developed, it
        allows recursion and semi-autonomous subroutines, its variables  are
        more  flexibly  defined  and  more easily localized, it is arithmeti-
        caly more precise and because it is self-compiling, not only can its
        programs be made to run from DOS, they can be loaded from DOS.  
             This  means  that  the pull-down menus, the warning signals and
        the tutorials have no part in the construction of the program itself,
        which  can  just  as easily be composed in EDLIN or, for that matter,
        on a word processor.  You need only save it in ASCII format, copy it
        into the QBASIC directory, open QBASIC's file  menu, type  the  file-
        name, hit F5, and  the program will execute, provided that the inter-
        preter does not encounter a  syntactical error or an illegal command.
             In that case, a diagnostic panel in the center of the screen of-
        fers to tell you what you did wrong.   This is in contrast to BASICA
        or GWBASIC where your error can be flagged during the writing of the
        program  by performing a quick check of the line. You still may have
        difficulty correcting it but at least you are informed of the  error
        on  the  spot  rather than later on, when it could be many times com-
        pounded before you put the program to the test.
             My personal opinion about all of this is that the real value of
        QBASIC  is in its extended functions, not in its rather heavy-handed
        displays, and that if you are sufficiently advanced to need the func-
        tions, you no longer need the displays, which usually are too  gener-
        alized  or too abbreviated to be of any use.  I have no quarrel with
        displays when displays are the name of the game as, for  example, in
        desktop  publishing  or  in  the creation of graphs and spreadsheets.
        But programming is by nature ideative and I find the clutter on  the
        screen  at  best  an  annoyance, at  worst a corruption of the clean,
        abstract logic upon which even  the  most  display-oriented  program
        depends.
      ........................................................................
        
        FROM THE INTRODUCTION, PAGE 9:
        One  last  thing.  Whatever  else  it may be, this book is a kind of
        intellectual memoir, a recounting of my own  struggle  to  demystify
        the  computer culture and to understand what this thing called BASIC
        is all about.  It is, in fact, the book that I  wish  I  had  in  my
        hands when first I tried to fathom such seemingly idiotic statements
        as X=X+1 or IF X=1 THEN X=2 or came face to face with variables that
        don't  vary and inputs that are really outputs and random files that
        are the model of order.  I sincerely hope that it will be  similarly
        useful to  you, whether by itself or in conjunction with other texts.
             Mindful of the abstract nature of the various functions and com-
        mands  and of the tendency of the commercial interests to intimidate
        and to obfuscate, I have tried to make both  programs  and  text  as
        interesting  as  possible  and I have tried to recapture some of the
        excitement of discovery that I felt when it all was new to me.  That
        does not mean that the material can be ingested without effort, only
        that  I  hope  that you, like myself, will find that the rewards are
        more than worth the effort and that the effort, when taken  step  by
        step, is  really  not  that  burdensome.   But it is still up to you;
        I can sympathize with you and I can try to ease the way but I cannot
        do  your  thinking  for  you, even less can I make you want to think.
        And  however  you  may  choose  to  interpret the title of this book,
        BASIC FOR BONEHEADS it is not.
       ......................................................................
       
        FROM GOTO.FIN, EXERCISE 1, PAGE 11:         
        GOTO  is  seen by many as a rogue command.  And for very good reason.
        It tends to garble the logical flow of a program and as you can  see
        for yourself by looking  at this exercise, its wanton use results in
        a  circuitous  progression  that  is  difficult to follow, let alone 
        decipher.  Such a condition is known as "spaghetti code" (after  the
        snarl  of  spaghetti  on a plate), and should be avoided.  And while
        there are times when rejecting GOTO can be more of a  nuisance  than
        yielding  to  it, it  almost inevitably can be replaced by something
        more appropriate and the program made cleaner by  the  change.  This
        should  become  apparent  later on.  For the present, I suggest that
        you simply accept it for what it is, namely a  device  to  divert  a
        program from its normally linear mode.
       ......................................................................
        
        FROM SECRET.FIN, EXERCISE 3, PAGE 14:
        BASIC  variables  differ  slightly  from the variables in elementary
        algebra.  Generally speaking, the value of an algebraic variable can
        be changed only by the intervention of another  variable; the  value
        of  a  BASIC  variable  can  be  changed both by the intervention of
        another variable and by external manipulation. In mathematical terms,
        an algebraic variable is more often than not a  continuous  function
        of another variable with infinitesimal increments of change. A BASIC
        variable  may  or  may not be a function of another variable and its
        increments of change are usually finite and discontinuous.
       ......................................................................
        
        FROM DATA1.FIN, EXERCISE 10, PAGE 28:
        An  array, very  loosely defined, is a collection of data in tabular
        form. A vertical display of the days of the week or  the  months  of
        the  year  is  an  example  of  a one-dimensional array.  A calendar,
        where the days of the week are displayed in columns  and  the  weeks
        themselves  displayed  in  rows  is  an example of a two-dimensional
        array.  If the pages of the calendar were to be printed on  a  trans-
        parent substance and fastened to a rack, the result would be a three-
        dimensional array. In such a case, July 15, 1992, which falls on the
        third  Wednesday of the month would occupy the position 4,3,7, the 4
        specifying  the  day of the week (Wednesday), the 3, the week of the
        month (the third), the 7, the month of the year (July). 
             Taking this one step further, the series 4,3,7,92 would specify 
        the  date in a four dimensional array, the 92 specifying the year of
        the century. There is no theoretcal limit to  the  number  of  dimen-
        sions  of  an  array, provided  of course that it does not become so
        complex and so  abstract  that  our  poor  three-dimensional  brains
        cannot handle it. 
        ....................................................................
      
        FROM NONSENSE.FIN & CAPS1.FIN, EXERCISES 12A & 12B, PAGE 33:
        Be aware of the difference between an IF...AND...THEN  condition and
        an  IF...OR...THEN  condition, the  first  mandating that both condi-
        tions must be met, the second mandating that only one  must  be  met.
        In  elementary  programming, these  are the two most likely to be en-
        countered.   More  uncommon  but  occasionally  very  useful  is the
        IF...XOR...THEN  function.   XOR is a qualified OR that demands that
        one and only one of the conditions be met, in effect stating that OR
        cannot also function as AND.
             For  example, "Two is less than three AND/OR/XOR  seven is less
        than nine"  would qualify as an OR statement and as an AND statement
        but not as an XOR  statement.  "Two  is  less  than three AND/OR/XOR
        nine is less than seven"  would qualify as an OR statement and as an
        XOR statement but not as an AND statement.
       .....................................................................
       
        FROM TIMEDATE.FIN, EXERCISE 14, PAGE 36-37:
        Like  the  individual  beads in a string of beads, the elements of a
        string variable have both individual and collective identities. That
        is to say, if Z$=YXWVU$, then Z$ can be understood as the string sum
        of Y$+X$+W$+V$+U$, where Y$, X$, W$, V$ and U$ are both  independent
        values and components or, more exactly, substrings of Z$.
             The  function  MID$  extracts  a  substring  from  a string and
        assigns it to a separate variable.  To  make  an  example, it is now
        nineteen minutes and three  seconds after eight on  the  evening  of
        May 28th, 1992.  The  configuration  of the string variable TIME$ is
        "20:19:03",  the  configuration  of  the  string  variable  DATE$ is
        "05-28-1992", the  configuration  of  the concatenated string TIME$+
        DATE$ is "20:19:0305-28-1992". 
               Continuing,  if  A$  is  set  equal  to  "20:19:0305-28-1992",
        then  A1$=MID$(A$,1,2)  will clone the first two characters from the
        string A$  and  set  them  equal  to  A1$  (specifically, 2  and  0).
        A2$= MID$(A$,4,2)  will clone the 2 characters beginning with charac-
        ter   4  and   set  them  equal  to  A2$  (specifically,  1  and  9).
        A3$=MID$(A$,7,2)  the  two characters beginning with character 7 and
        so  on  until  all of the components had been separated and assigned.
        None of this activity disrupts the structure of  A$  or in  any  way
        affects its value.
       ......................................................................
     
        FROM HEXIDEC.FIN, EXERCISE 15, 38-39:
        On a superficial level, the cashier in a modern supermarket is a com-
        puter  operator.  Every  time she rings up a sale an enormous amount
        of information is transmitted to a central unit  which  stores  that
        information  and interprets it in terms of shelf life, profit margin
        and inventory.  But none of this is of concern to her. Her knowledge
        of  what is happening need extend no further than the keys that ring
        up meat or produce or whatever and the keys that send the  total  to
        an illuminated display and open the register drawer.   
             On  a  deeper level, the  accountant  who  interprets this data
        must  make  judgement  as to what input is important and what is not
        and how such input should be arrayed.  Perhaps the data tabulated by
        key "A" should be combined with the data tabulated by key "B" or per-
        haps the data tabulated by key "C" is  too broad in scope and should
        be  divided  between keys "D" and "E".  He then adjusts their assign-
        ment in accordance with the program resident within the machine, and
        if  such  assignment  happens to be beyond the scope of that program,
        he is all but powerless to do anything about it.  It is worth noting
        that  most  packaged  software, however extravagant may be its claim,
        falls with in this category.
             On  a  still  deeper level, the system analyst who services the
        computer is (or should be) able to  understand  the  keystrokes  not
        only in terms of  what block of functions they evoke but in terms of
        the underlying logic behind them and, at the deepest  level  of  all,
        how they are defined by the electronic matrix that lies between them
        and  the  registers  and accumulators and logic gates and flip-flops
        that process the input and spell out the return.  
             In  what  is  known  as   machine  language, the keystrokes are
        linked directly to the innermost workings of  the  machine  and  the 
        programs, while highly efficient, are lengthy  and  complex. In  the
        "high-level" languages, such as BASIC, much of this linkage has been
        skillfully translated into relatively straightforward  commands, mak-
        ing it possible to write programs  of  a  fair  degree of complexity
        without understanding the inner workings of the machine. 
       .......................................................................

        FROM HEXIDEC.FIN, EXERCISE 15, PAGE 39:
        BASIC,  like  other  high-leve  languages  (and most low-level ones),
        reduces all computation to a manipulation of numbers to  the  base 2.
        Such  numbers begin with 1 (binary notation, 00000001) through 2 and
        3 (binaries 0000010 and 00000011) to 255 (binary 11111111)  and  are
        arranged  in "bytes" consisting of "1"s and "0"s, each exactly eight
        digits or "bits" in length.    Not  only  are  these  configurations
        understood  in terms of their numerical values, they are combined to
        form arrays where the relative positions of the "1"s  and  the  "0"s
        have their own value and significance. 
             Just  as a binary number is a number to the base 2, so an octal
        number is a number to the base 8 and a hexidecimal number is  a  num-
        ber to  the base 16.  In hexidecimal notation, 9 is still "9" but 10
        becomes "A", 11 becomes "B", 12, 13, 14 and 15  become "C", "D", "E"
        and "F" respectively.   The hexidecimal value of 16 is the two-digit
        configuration  "10" (which of course is no more "ten" than "00000011"
        is "eleven").  Notice  that the highest possible two-digit configura-
        tion is hexidecimal 255 or "FF", at once the maximum capacity of the
        eight  bit  binary format  and  the  number  of ASCII characters.
             The  conversion  of  decimal  numbers to their binary form is a
        rather tedious operation.   The conversion of hexidecimal numbers to
        binary numbers is much easier and an experienced practitioner can do
        it on sight.  This is because each block of four  binary  digits  is 
        equivalent to a hexidecimal number.   Binary  01101101 (decimal 109),
        for example, breaks down into 0110 and 1101, which is hexidecimal "6"
        and hexidecimal "D" or taken together, hexidecimal  6D.   Going  the
        other direction, hexidecimal "AB" (decimal 171)  converts  into  the
        binary  value  of "A"  and  the binary value of "B" or 1010 and 1011
        respectively or, when combined, 10101011.
       ......................................................................

        FROM BINARY.FIN, EXERCISE 22, PAGE 52:
        A  decimal number is a number as we ordinarily think of it, namely a
        number that expresses its value by the sum of its digits, each multi-
        plied  by  an incremental power of 10.   The number 523, for example,
        is equal to the sum of five times ten to the second power (or 5*100)
        plus two times ten to the first power (or 2*10) plus three times ten
        to the zero power (or 3*1). 
             We  count  in tens because we have ten fingers on our hands and
        ten toes on our feet.  This, however, is not the only way. There are
        sixty seconds in a minute, sixty minutes  in  an  hour, twenty  four
        hours in a day, twelve inches in a foot, twelve units in a dozen and,
        of course, twelve months in a year. In fact, it has been argued that
        because twelve is divisible by two, three, four and six while ten is
        divisible  only by two and five, the 10-base convention may not have
        been the best choice.
             Curiously, the  2-base system used by the Australian aborigines,
        the one that counts "one, then two, then two and one, then  two twos,
        then two twos and one, then two twos and two" is fundamental to what
        some like to call computer intelligence.  Because it recognizes only
        two digits, which in turn can be unequivocally assigned to "yes" and
        "no" or to "this" and "that", its compatibility with the  theory  of
        logic is obvious.   And, as was mentioned in Exercise 15, the config-
        uration  of the 1's and 0's in an 8-bit byte (or in a 16-bit byte or
        in a 32-bit byte) has a significance beyond its numeric value.
             "1" is "1" whether in decimal or binary.  "2", however, is "10";
        "3" is "11"; "4" is "100" and so forth.   Notice that the expression
        grows  by one digit each time its decimal equivalent attains a power
        of two. I have often wondered why the pundits who cooked up  such  a
        system didn't  take  the  sensible next step and replace the decimal
        digits with symbols unique to the base.   But  they didn't and so we
        have the confusing  business  of  a one followed by a pair of zeroes
        carrying the  value of  256  in  hexidecimal, of  100 in decimal and
        of 4 in binary.   
            The easiest way to convert a decimal number into a binary number
        is  to  assign  the number to a HEX$ string and then to use the MID$
        function  and  a  two-dimensional  array  to extract the four binary
        digits that correspond to each hexidecimal digit. (See Exercise 15).
        Here it is done arithmetically.
             When  a  whole  number  is  divided  by 2, the remainder (which
        obviously must be one or zero) will be the last digit in the  binary
        conversion.  If the quotient is similarly divided, that remainder is
        the  second to last digit in the conversion, and so on until further
        reduction yields nothing but zeroes.
             If, for  example, 121 is  divided by 2, the quotient is 60, the
        remainder is 1 and the tentative binary value is ?????1. On the next
        pass, 60  divided  by  two is 30 with a remainder of zero and the bi-
        nary  value  is  ????01.   Continuing, 30  divided by 2 is 15 with a
        remainder of zero and the binary value is ???001; 15 divided by 2 is
        7  with  a remainder of 1 and the binary value is ??1001; 7  divided
        by 2 is 3  with  a  remainder  of  1  and  the  binary conversion is
        ?11001;  3  divided by 2 is 1 with a remainder of 1 and  the  binary
        conversion is  111001.   At  this  point, no  further  whole  number
        division is possible and the process comes to an end. 
       ......................................................................

        FROM OFFSET.FIN, EXERCISE 23, PAGE 54:
        Try  this:  LOAD  any  program  in this  book and without RUNning it,
        clear the screen and while in direct mode  type  out  the  following:
        DEF SEG:  FOR N=472 to 482:  PRINT CHR$(PEEK(N));:  NEXT N  and  hit
        <ENTER>.  This  should  display the name of that program in the form
        that  it  was  LOADed but with no period between the name and the ex-
        tension.  (These are GWBASIC 3.23 values; for BASICA, use FOR N=1265
        to  1275.)  By giving this series of commands a line number and plac-
        ing it before the END command, the program will display its name  as
        it terminates, a valuable reminder if it is to be SAVEd.
             To  understand  how this happens, it is necessary to understand
        something about how values are stored and  accessed.  Bear  in  mind
        that  the  following  discussion  deals with what happens within the
        computer, not with what may or may not have been consigned to disk. 
             Every  constant  and  the  variable  that governs it is given a
        specific location or "address" in the  computer's  immediate  memory.
        This is true not only of the commands and data that make up an indiv-
        idual  program  but of the commands and data that make the execution
        of that program  possible, namely the resident  values of  BASIC  it-
        self.  Some  of  these  values  are  functions of other values; some
        change only when specifically ordered to do so  by  a  specific  key-
        board command, others are in ROM and cannot be changed at all.
        ......................................................................

        FROM OFFSET.FIN, EXERCISE 23, PAGE 55:
        Program commands and the data that accompanies them are fugitive and
        are  purged  from  memory when another program is LOADed, CHAINed or
        RUN.  The electonic matrix that we call BASIC, however,  remains  in
        memory until the computer is returned to DOS.  
             In  either case, each unit of data is assigned to one of over a
        million  memory  locations  and  remains  there until reassigned  or
        erased.  These locations, however,  are  not accesssed by invoking a
        single "address" but  by  the "segment" and  the "offset" that  they
        occupy.  There  are  65,536  such segments with each segment divided
        into  65,535  offsets  in somewhat the same manner that a nine-digit
        zipcode is divided into post offices and box numbers.
             The offset numbers do not run sequentially but are local to the
        segments.  That  is to say, the segments overlap, each repeating all
        but sixteen of the data items (or bytes) in  the  segment  preceding
        it.  Therefore each data item can be accessed by many segment-offset
        commands.  For  example, the   byte  held  by  segment 61439, offset
        57368 (in  IBM  machines, the  beginning  of the readout of the copy-
        right  notice), is the identical byte held by segment  61440, offset
        57352.  This  means  that  as the number of the segment increases by
        one, the number of the equivalent offset decreases by 16.
       ......................................................................
        
        FROM CODE.FIN, EXERCISE 25, PAGE 59: 
        When  we  look  at a screen full of ASCII symbols, there is a tempta-
        tion to assign them far more importance than they deserve, as though
        the secret inner workings of the computer would be secrets no longer
        if only we knew what they meant.  The truth is that they are nothing
        but  fillers, something  to  occupy  those ASCII values that are not
        directly accessible from the keyboard. For  all  of  their  esotetic
        appeal, they  are  utterly meaningless except as they can be used as
        textures or borders or foreign characters or  punctuation  marks  or
        dingbats or whatever.   Their real importance, as we shall see later,
        lies  not  in  their substance but in the binary and hexidecimal num-
        bers that they happen to represent.
       ...................................................................... 
 
        FROM WHEEL1.FIN, EXERCISE 28, PAGE 65: 
        Unless  specified  otherwise, when  numeric  values are PRINTed, all 
        zeroes to the right of the last digit in their decimal component are 
        ignored.  50.00 is understood simply as  50, 50.20 as 50.2 and so on. 
        The  PRINT  USING "###.##"; function not only supplies the zeroes in  
        the decimal component, it can be used to round off a number  to  the  
        desired number of digits.   The  command  PRINT  USING "#.##";3.3333, 
        for example, returns 3.33. 
       ...................................................................... 
 
        FROM TOTAL2.FIN, EXERCISE 31, PAGE 70: 
        In  previous  exercises, the STR$  function has been used to convert
        numeric values into strings. If, for example, A=678.34, then STR$(A)
        is  what  amounts  to  a  concatenation  of the string values of the
        digits  ("6"+"7"+"8"+"."+"3"+"4")  together  with  an  indicator sub-
        string at the begining of the series  that  determines  whether  the 
        number is positive or negative. The digits are then stored as single 
        bytes  in  single  offsets, the  total  number  of which is equal to 
        LEN(A$)+1  or  the  number  of characters in the string plus a minus 
        sign if the number is negative, a space if the number is positive. 
             But  this  is extremely wasteful of memory, especially when the
        values  are stored in a random file where, as in a naval convoy, the
        requirements  and/or limitations of the most demanding must be borne
        by all the others.  The MKS$ function  provides a far more efficient
        way.  Unlike  STR$, which  uses only the ASCII values of the 10-base
        digits (1 to zero inclusive), MKS$  uses  the  full set of the ASCII
        values, in effect creating a numbering system to the base 256.   
             The  value  that a given number of digits can express is geomet-
        rically proportional to its base.  A  two-digit number to the base 2
        has a range of 1 to 2. A two-digit number to the base 10 has a range
        of 1 to 99.  A  two-digit  number to the base 16 has a range of 1 to
        255.  A two-digit number  to  the base 256 has a range of 1 to 65535,
        which means that every integer from minus 32768 to plus 32767 can be 
        defined by only two digits.  And  the  MKS$ function, which uses not 
        two  but  four digits has the mind-boggling range of 1 to 256^4 or 1 
        to 4,294,967,296, allowing definition to seven  signficiant  figures, 
        whether the number is positive or negative, integer or decimal.   
       ...................................................................... 
         
        FROM RANDFIL1.FIN, EXERCISE 34, PAGE 76: 
        RANDFIL1.FIN  is  the first of a series of programs that demonstrate 
        the  properties  of  a  random  file.  RANDFIL1.FIN creates the file  
        RAND.DAT and enters a series of names, addresses, purchase codes and 
        amounts of purchase.  
             One  way  to  visualize  a random file is to imagine a stack of
        narrow  strips  of  paper, each  marked off into a precise number of
        intervals.  Imagine  further that there are exactly 128 intervals in
        each strip (or record) and that each interval is capable  of holding
        one  and  only  one  letter, numeral or symbol.  Let us now inscribe
        these intervals with data pertinent to a specific transaction, say a
        mail order purchase.   To  do  this, we  group  these intervals into
        larger intervals  (or fields), each  of a length  suitable  for  the 
        information to be contained within it. 
             Let us say that the first "field" will consist of exactly eight 
        intervals to identify the record, the second will consist of exactly 
        twenty  intervals to store the customer's last name, the next twenty 
        his  or her first name, the next twenty five the street address, the 
        next thirty five the city, state and zipcode, the next  ten, a  code 
        that  contains the date of purchase, the credit rating and how often 
        he or she has placed an order, the last ten the amount  of  the  pur- 
        chase.  Notice  that  each  field occupies the identical position in 
        each record, regardless of how many intervals have been used. 
             There is a lot of flexibility in the length of the  record  and
        in the number of fields that the records contain but in any one file,
        the number, the length and the relative positions of the fields  are 
        rigorously  defined and cannot be changed.  Each entry will normally 
        be either right-justified or left-justified within the field that it 
        occupies;  that  is to say, it will either begin at the beginning of 
        the field or it will end at the end of the  field  with  all  unused 
        spaces remaining blank and carrying the value of CHR$(32). 
             Once  a  random file entry has been fully executed, it is trans-
        ferred  to  permanent memory by transcribing it onto the disk of the 
        current drive, where it will remain there until modified or erased.   
       ...................................................................... 
 
        FROM RANDFIL2.FIN, EXERCISE 35, PAGE 78: 
        Another way to visualize a random file is to think of it in terms of 
        successive offsets.   In the case of RAND.DAT, the first 128 offsets 
        of  some unamed segment would hold the seven fields of record 1, the 
        next 128 offsets, the seven fields of record 2, the Jth set  of  128 
        offsets the seven fields of record J.  Hence, if the location of the 
        first  byte  of the first record is known, the location of the first 
        byte of any record can be known.   Because all seven fields are iden- 
        tically positioned within their respective records, any field in any 
        record  can  be recalled by specifying the number of the record that 
        contains it together with the "field" variable (AF$,  BF$,  whatever) 
        that identifies it. 
             Be aware, however, that not only can the chain of offsets begin
        anywhere in the segment, they are constantly  being  transferred  to 
        permanent  memory  by the PUT command and their relative position on 
        the disk need not be the same  as  their  position  in  the  segment. 
        But  whether  in immediate memory or on disk, their locations remain
        fixed  and  knowable and consequently any field of any record of any
        file can be easily retrieved at any time. 
       ...................................................................... 
         
        FROM SEQUENTL.FIN, EXERCISE 39, PAGE 86: 
        A  random  file  is  anything  but random.  Each entry, whatever its 
        length or complexity, is contained within a precisely defined  field. 
        In addition, each set of fields, whether full, empty or something in
        between, is contained within a  precisely  defined  record.  Finally,
        each record is exactly the same size and of exactly the same configu-
        ration as the records preceeding and following it.  This is not true
        of a sequential file.   If a random  file is like a course of bricks
        in  a neatly laid wall, a sequential file is like a course of rubble
        masonry with each stone its own size and shape.  In  a  random  file,
        there  is no demarcation between  record and record, field and field
        and byte and byte because each can be exactly located  by  its  posi-
        tion  in  the  file, much as a certain point on a certain brick on a
        certain wall can be exactly located by a carefully defined  and  pro-
        gressively limitative sequence of measurments. 
             On  the  other hand, entries in a sequential file require physi-
        cal delimiters to mark where one entry ends and another entry begins.
        And because they are put together without regard to their individual
        lengths, it is impossible  to  correct them or to make substitutions.
        Not only do we have no way of knowing where the  substituion  is  to
        occur, the  byte-length  of  the  entry to be substitued will almost
        never be equal to the  byte-length  of  the  entry  to  be  replaced.
        Consequently, the only way that data can be added is to APPEND it to
        the  end of the file and the only way that data can be deleted is to
        delete the entire file with it.  
       ...................................................................... 
 
        FROM ROUNDOFF.FIN, EXERCISE 44, PAGE 96:
        ROUNDOFF.FIN  displays  some  of  the  characteristics  of the three
        species of numeric values resident in BASIC, specifically the number
        of decimal places to which each can be carried and how these  values
        are interpreted and stored.
             Unless otherwise defined, numeric values are  accurate to seven
        digits, the last of which has been rounded up or down depending upon
        the  value  of  the eighth.  These are known as single-precision num-
        bers and, as we have seen in Exercise 31, are defined by  a  permuta-
        tion of four ASCII values.   A double precision number is defined by
        a  permutation  of eight ASCII quantities and is accurate to sixteen
        significant figures.  An integer  is  a  whole  number, positive  or
        negative, and  is  defined  by a permutation of two ASCII characters
        with a range of -32768 to +32767.  Numbers less or greater than this,
        whether integers or not, must be of single or double precision.  
             If  N  is  an integer, its designation is N%.  If N is a single-
        precision number, its designation is N!   If N is a double-precision
        number, its  designation  is  N#. Because BASIC assigns single preci-
        sion  to  all  numbers  unless  ordered  otherwise, a number without
        designation can be assumed (although not without some risk) to be of
        single precision. 
       ......................................................................
        
        FROM SORT.FIN, EXERCISE 45, PAGE 98:
        The  BASIC  bubble-sort routines are based upon two fundamental prin-
        ciples.  First, the computer is aware of  the  ASCII  order  of  the
        keyboard  characters even when the ASC function has not been invoked.
        This applies to letters as well as to numbers.   Not  only  does  it
        recognize  that  3  is greater than 2 and that  minus 6 is less than
        minus 1, it is equally aware that B is less than C and that a  lower
        case "a" is greater than an upper cse "Z".  Second, the SWAP command
        enables  the  computer  to exchange the assignment of variables.  If,
        for example, A$(1) is equal to X$ and A$(2) equal to Y$, the command
        SWAP  A$(1),A$(2)  will  immediately set A$(1) equal to Y$ and A$(2)
        equal to X$.
             Imagine the four letters P, Z, M and A in positions 1, 2, 3 and
        4. Starting with the two leftmost letters, do  nothing if the letter
        in  position  1  is less or equal to the letter in position 2; other-
        wise SWAP them.  Since P is less than Z, they are left alone and the
        order  remains  P, Z, M, A.   Now look at the letters in positions 2
        and 3. Since Z is not less than M, there is a  SWAP  and  the  order
        becomes  P, M, Z, A.  Next, the letters in positions 3 and 4:  Since
        Z is not less than M, it is SWAPped again, this time  to  its  final
        position.  The  order  is  now P, M, A, Z  and the first pass is com-
        plete.
             On the second pass, first P and M SWAP, then P and A. Z remains
        untouched and the order becomes M, A, P, Z with P and Z now in final
        position.  
             On the third pass, M is not less than A, there is one last SWAP,
        the order becomes  A, M, P, Z, and the sorting process  is  complete.
             On the fourth pass, A is less than M, M is less than P and P is
        less than Z.  The SWAP command is not invoked and it is this lack of
        activity that informs the computer that the sort has come to an end.
       ...................................................................... 
 
