The Best of Creative Computing Volume 1 (published 1976)

Page 300 << PREVIOUS >> NEXT Jump to page:
Go to contents Go to thumbnails

Reviews of 34 Books on BASIC (comparing books, no standardization, the programs, flowcharts, indexes, and tutorials)

graphic of page

The books are given an overall A-B-C-D rating. Ten are
excellent, and rate an A. Ten more are very good, for a B.

Another ten are average, C. Two are poor, getting a D. Two
get split ratings: one gets an A for the first half of the book,
a C for the second half; the other book rates a B+ for
classroom use, but only a c- for the solitary reader.

Some authors chop their texts into very brief chapters,
perhaps feeling that the reader's attention span may be very
short for such material; Skelton (19), for example, has 12
chapters in l58 pages, with a 2½ -page chapter on READ
and DATA alone. Other cram quite a number of statements
into each chapter, usually in related groups. Sass (21) has
only nine chapters in 310 pages, and Barnett (23) has eight
chapters in 366 pages.

Only eight of the books introduce string constants and
variables at the same time as numeric constants and
variables, rather than later in the text, or not at all.

Several of the authors are more terminal-oriented than
others, and discuss the Teletype within the first half-dozen
pages: Albrecht et al (32), Dymax (28), Pavlovich & Tahan
(18), Pegels (31), Spencer (6) and Sass (21).

In ten of the books, INPUT is introduced before
DATA, perhaps to emphasize the interactive nature of

Several authors, or perhaps it was their publishers, have
padded their books with a great deal of white space, blank
pages, and meaningless appendixes. Several other authors,
notably the anonymous ones of the 53-page NCTM booklet
(4), have managed to cram more into each page than have
the writers of many of the much longer books.


No Standardization
Comparing any two or three of these books with each
other shows that there is no standardization in even the
simplest features of BASIC. Most authors are divided
between, for example, IF-THEN and IF/THEN; a couple
use IF...THEN. Some authors write Basic, others BASIC.

Waite & Mather (l) use the phrases "loop variable" and
"running variable", others call it the counter, index, control
variable, index of a loop, or control identifier. Over half the
books have no name for it at all, other than simply "I."

Only Gross & Brainerd (22) distinguish between brackets
and parentheses; Dwyer & Kaufman (33) also use both, but
don't say why.

Three books mention one statement each that no
others include: APPEND, PAUSE, and TYP.


The Programs
Most of the authors begin by presenting programs on a
slow-and-easy basis, starting with no more than 2 to 5 lines,
and building up from there. Kemeny & Kurtz (2) start with
a 5-liner on page l; NCTM (4) opens with a 2-liner.

Gruenberger (25) is one of the few mavericks in this
respect; he seems to believe in the sink-or-swim theory, and
starts off with an 11-line program on page 2. Even though
every line has a paragraph of explanation, the program is
too difficult for many readers.

Farina, in his earlier book (3), is one of the few authors
to keep all his programs short; the longest one contains 14
lines. The longest in NCTM (4) is 15 lines; in Peluso et al
(2) it is 13, except for two longer ones; Stern & Stern (34)
have only two over I5 lines; Gateley & Bitter (9), only two
over 13 lines long. Even the 63-page Dymax (28) has
programs 28 lines long.

A number of authors work their way up into some very
long and overly complex programs, most of them too
complicated for many beginners; these include Smith
(10 30), Gross & Brainerd (22), Sharpe & Jacob (17), Nolan
(5) and Hare (8).

Only a few authors go into the different levels of
programming languages. Sack & Meadows (27) and Murrill
& Smith (16) do a little, Hare (8) and Nolan (5) do more
(2½  pages each), and Gross & Brainerd (22) do quite well
by the subject, with 5½ pages.

Two authors discuss the history of time-sharing: Sass
(21) and Spencer (6) take two pages each.

Sage (7) is the only author to use the expression
"falling through" and to explain the principle thoroughly.

Most of the authors spread the teaching of the
elements of BASIC over most of the length of their books.

But there are some others who prefer to devote the major
portion of their book to applications. For instance, Sage (7)
has only 65 of 244 pages on the elements of BASIC; in
Gross & Brainerd (22), BASIC is covered in the first 68 of
the 304 pages; and Kemeny & Kurtz (2) spend only 43 of
their 150 pages on the essentials.

There are a few contradictions between one book and
another. For instance, Forsythe et al (12) have a section in
the first chapter on testing a program, with a number of
suggestions, including "When this experimental approach
fails to reveal the trouble .... Another technique called
tracking then becomes very helpful .... It is done by
inserting PRINT statements at selected points in a program
being tested." But Gruenberger (25) has a different
viewpoint: "Warning: as a debugging tool, tracing is to be
regarded as a last-ditch resort, and should never be used
casually. Using a tool as crude as tracing for debugging is
the mark of a poor programmer." That may well be true of
an experienced programmer, but a beginner needs all the
help he can get.

Only four texts show concern for the esthetics of
programming. Blakeslee (24) puts it one way, "SERMON:

Always remember the poor sucker who has to use the
output of a program you write; keep it neat, keep it simple.

That poor sucker could be you!" Gruenberger (25) notes
that allowing a program to end in OUT OF DATA ON
LINE XXX is "not the most graceful way to terminate a
program." Sharpe & Jacob (17) say that a printout without
headings is "hardly every elegant output." Waite & Mather
(l), practical as always, not only note that a program
ending in OUT OF DATA "does not yield an attractive
printout," but add that it "prevents taking any action after
the program discovers that it has run out of data."

Also in the realm of esthetics, although more on the
side of readibility, are the suggestions in five of the books
to use blank lines to "divide visually the major sections of a
program," as Waite & Mather (1) put it. Seven books indent
the statements inside a loop, between a FOR-NEXT pair.


Flowcharts, Indexes, and Tutorials
Not many authors are big on flowcharts; Kemeny &
Kurtz (2), for instance, have only three in the whole book.

Sage (7) and Smith (10) have flowcharts for every program
example, and Peluso et al (2) have for most of their
programs. Sass (21) has the most complex flowcharts, with
Smith (10) not far behind. Others who make frequent use
of flowcharts are Coan (11), Nolan (5), Lewis & Blakeley
(29) and, above all, Forsythe et al (12), to whom
flowcharting is everything.

Few authors seem to understand the art of indexmanship,
as most have only a few pages; Barnett (23), for
instance, has five pages of index. The one exception is Hare
(8), whose index is a full I8 pages long. Four books have no
index: Dymax (28), General Electric (15), NCTM (4) and
Smith (10).

A few indexes must have been computer-generated,
because they have some references to subjects that are
mentioned only very briefly in the text, and which nobody
would probably ever want to look up. The Gross &
Brainerd (22) index lists "coconut" and "animal, carnivorous,"  
while Kemeny & Kurtz (2) list "Oz, Land of."

Hare also has the longest glossary: 16 pages. Nolan (5)
has 11½ pages, Sass (21) has 8, and Spencer (6) has five
pages of glossary.

Seven of the books have authors who think enough of
their programs to have separate indexes of them, by title
and page number.

Most texts assume that the reader knows enough about
the various areas of mathematics to need no tutoring, but
several others devote sizable numbers of pages to teaching
math, including nine pages on matrices and ten on
trigonometry in Pavlovich and Tahan (18).


Page 300 << PREVIOUS >> NEXT Jump to page:
Go to contents Go to thumbnails