A letter can stand for a number. For example, x can stand for the number 47, as in this program:

The second line says x stands for the number 47. In other words, x is a name for the number 47.

The bottom line says to print x + 2. Since x is 47, the x + 2 is 49; so the computer will print 49. That’s the only number the computer will print; it will not print 47.

Jargon

A letter that stands for a number is called a numeric variable. In that program, x is a numeric variable; it stands for the number 47. The value of x is 47.

In that program, the statement
 “x = 47” is called an assignment statement, because it assigns 47 to x.

A variable is a box

When you run that program, here’s what happens inside the computer.

The computer’s random-access memory (RAM) consists of electronic boxes. When the computer encounters the line “x = 47”, the computer puts 47 into box x, like this:

       ┌─────────────┐

box x  │       47    │

       └─────────────┘

Then when the computer encounters the line “PRINT x + 2”, the computer prints what’s in box x, plus 2; so the computer prints 49.

Faster typing

Instead of typing —

you can type just this:

At the end of that line, when you press the ENTER key, the computer will automatically put spaces around the equal sign.

Since the computer automatically capitalizes computer words (such as CLS), automatically puts spaces around symbols (such as + and =), and lets you type a question mark instead of the word PRINT, you can type just this:

When you press ENTER at the end of each line, the computer will automatically convert your typing to this:

More examples

Here’s another example:

The second line says y is a numeric variable that stands for the number 38.

The bottom line says to print y - 2. Since y is 38, the y - 2 is 36; so the computer will print 36.

Example:

The second line says b is 8. The bottom line says to print b * 3, which is 8 * 3, which is 24; so the computer will print 24.

One variable can define another:

The second line says n is 6. The next line says d is n + 1, which is 6 + 1, which is 7; so d is 7. The bottom line says to print n * d, which is 6 * 7, which is 42; so the computer will print 42.

Changing a value

A value can change:

The second line says k’s value is 4. The next line changes k’s value to 9, so the bottom line prints 18.

When you run that program, here’s what happens inside the computer’s RAM. The second line (k = 4) makes the computer put 4 into box k:

       ┌─────────────┐

box k  │        4    │

       └─────────────┘

The next line (k = 9) puts 9 into box k. The 9 replaces the 4:

       ┌─────────────┐

box k  │        9    │

       └─────────────┘

That’s why the bottom line (PRINT k * 2) prints 18.

Hassles

When writing an equation (such as x = 47), here’s what you must put before the equal sign: the name of just one box (such as x). So before the equal sign, put one variable:

The variable on the left side of the equation is the only one that changes. For example, the statement d = n + 1 changes the value of d but not n. The statement b = c changes the value of b but not c:

The fourth line changes b, to make it equal c; so b becomes 7. Since both b and c are now 7, the bottom line prints 14.

“b = c” versus “c = b” Saying “b = c” has a different effect from “c = b”. That’s because “b = c” changes the value of b (but not c); saying “c = b” changes the value of c (but not b).

Compare these programs:

In the left program (which you saw before), the fourth line changes b to 7, so both b and c are 7. The bottom line prints 14.

In the right program, the fourth line changes c to 1, so both b and c are 1. The bottom line prints 2.

While you run those programs, here’s what happens inside the computer’s RAM. For both programs, the second and third lines do this:

       ┌─────────────┐

box b  │        1    │

       └─────────────┘

       ┌─────────────┐

box c  │        7    │

       └─────────────┘

In the left program, the fourth line makes the number in box b become 7 (so both boxes contain 7, and the bottom line prints 14). In the right program, the fourth line makes the number in box c become 1 (so both boxes contain 1, and the bottom line prints 2).

When to use variables

Here’s a practical example of when to use variables.

Suppose you’re selling something that costs $1297.43, and you want to do these calculations:

To do those four calculations, you could run this program:

But that program’s silly, since it contains the number 1297.43 four times. This program’s briefer, because it uses a variable:

So whenever you need to use a number several times, turn the number into a variable, which will make your program briefer.

String variables

A string is any collection of characters, such as “I love you”. Each string must be in quotation marks.

A letter can stand for a string — if you put a dollar sign after the letter, like this:

The second line says g$ stands for the string “down”. The bottom line prints:

In that program, g$ is a variable. Since it stands for a string, it’s called a string variable.

Every string variable must end with a dollar sign. The dollar sign is supposed to remind you of a fancy S, which stands for String. The second line is pronounced, “g String is down”.

If you’re paranoid, you’ll love this program:

The second line says t$ stands for the string “They’re laughing at you!” The later lines make the computer print:

Spaces between strings

Examine this program:

The bottom line says to print “sin” and then “king”, so the computer will print:

Let’s make the computer leave a space between “sin” and “king”, so the computer prints:

To make the computer leave that space, choose one of these methods.…

Method 1. Instead of saying —

make s$ include a space:

Method 2. Instead of saying —

make k$ include a space:

Method 3. Instead of saying —

say to print s$, then a space, then k$:

Since the computer will automatically insert the semicolons, you can type just this —

or even type just this —

or even type just this:

When you press the ENTER key at the end of that line, the computer will automatically convert it to:

Nursery rhymes

The computer can recite nursery rhymes:

The second line says p$ stands for “Peas porridge ”. The later lines make the computer print:

This program prints a fancier rhyme:

Lines 2-4 define h$, m$, and c$. The later lines make the computer print:

Undefined variables

If you don’t define a numeric variable, the computer assumes it’s zero:

Since r hasn’t been defined, the bottom line prints zero.

The computer doesn’t look ahead:

When the computer encounters the second line (PRINT j), it doesn’t look ahead to find out what j is. As of the second line, j is still undefined, so the computer prints zero.

If you don’t define a string variable, the computer assumes it’s blank:

Since f$ hasn’t been defined, the “PRINT f$” makes the computer print a line that says nothing; the line the computer prints is blank.

Long variable names

A numeric variable’s name can be a letter (such as x) or a longer combination of characters, such as:

For example, you can type:

The computer will print:

The variable’s name can be quite long: up to 40 characters!

The first character in the name must be a letter. The remaining characters can be letters, digits, or periods.

The name must not be a word that has a special meaning to the computer. For example, the name cannot be “print”.

If the variable stands for a string, the name can have up to 40 characters, followed by a dollar sign, making a total of 41 characters, like this:

Beginners are usually too lazy to type long variable names, so beginners use variable names that are short. But when you become a pro and write a long, fancy program containing hundreds of lines and hundreds of variables, you should use long variable names to help you remember each variable’s purpose.

In this book, I’ll use short variable names in short programs (so you can type those programs quickly), and long variable names in long programs (so you can keep track of which variable is which).

Programmers employed at Microsoft capitalize the first letter of each word and omit the periods. So instead of writing:

those programmers write:

That’s harder to read; but since Microsoft is headed by Bill Gates, who’s the richest person in America, he can do whatever he pleases!

 

Humans ask questions; so to turn the computer into a human, you must make it ask questions too. To make the computer ask a question, use the word INPUT.

This program makes the computer ask for your name:

When the computer sees that INPUT line, the computer asks “What is your name?” and then waits for you to answer the question. Your answer will be called n$. For example, if you answer Maria, then n$ is Maria. The bottom line makes the computer print:

When you run that program, here’s the whole conversation that occurs between the computer and you; I’ve underlined the part typed by you.…

Try that example. Be careful! When you type the INPUT line, make sure you type the two quotation marks and the semicolon. You don’t have to type a question mark: when the computer runs your program, it will automatically put a question mark at the end of the question.

Just for fun, run that program again and pretend you’re somebody else.…

When the computer asks for your name, if you say something weird, the computer will give you a weird reply.…

College admissions

This program prints a letter, admitting you to the college of your choice:

When the computer sees the INPUT line, the computer asks “What college would you like to enter?” and waits for you to answer. Your answer will be called c$. If you’d like to be admitted to Harvard, you’ll be pleased.…

You can choose any college you wish:

That program consists of three parts:

INPUT versus PRINT

The word INPUT is the opposite of the word PRINT.

The word PRINT makes the computer print information out. The word INPUT makes the computer take information in.

What the computer prints out is called the output. What the computer takes in is called your input.

Input and Output are collectively called I/O, so the INPUT and PRINT statements are called I/O statements.

Once upon a time

Let’s make the computer write a story, by filling in the blanks:

To write the story, the computer must ask for your name, your friend’s name, and a verb. To make the computer ask, your program must say INPUT:

Then make the computer print the story:

Here’s a sample run:

Here’s another run:

Try it: put in your own name, the name of your friend, and something you’d like to do to your friend.

Contest

The following program prints a certificate saying you won a contest. Since the program contains many variables, it uses long variable names to help you remember which variable is which:

Here’s a sample run:

Bills

If you’re a nasty bill collector, you’ll love this program:

Can you figure out what that program does?

Numeric input

This program makes the computer predict your future:

Here’s a sample run:

Suppose you’re selling tickets to a play. Each ticket costs $2.79. (You decided $2.79 would be a nifty price, because the cast has 279 people.) This program finds the price of multiple tickets:

This program tells you how much the “energy crisis” costs you, when you drive your car:

Here’s a sample run:

Conversion

This program converts feet to inches:

Here’s a sample run:

Trying to convert to the metric system? This program converts inches to centimeters:

Nice day today, isn’t it? This program converts the temperature from Celsius to Fahrenheit:

Here’s a sample run:

See, you can write the Guide yourself! Just hunt through any old math or science book, find any old formula (such as f = c * 1.8 + 32), and turn it into a program.

Here’s how to restrict the computer, so it performs certain lines only under certain conditions.…

IF

Let’s write a program so that if the human is less than 18 years old, the computer will say:

Here’s the program:

Line 2 makes the computer ask “How old are you” and wait for the human to type an age. Since the symbol for “less than” is “<”, the bottom line says: if the age is less than 18, then print “You are still a minor”.

Go ahead! Run that program! The computer begins the conversation by asking:

Try saying you’re 12 years old, by typing a 12, so the screen looks like this:

When you finish typing the 12 and press the ENTER key at the end of it, the computer will reply:

Try running that program again, but this time try saying you’re 50 years old instead of 12, so the screen looks like this:

When you finish typing the 50 and press the ENTER key at the end of it, the computer will not say “You are still a minor”. Instead, the computer will say nothing — since we didn’t teach the computer how to respond to adults yet!

In that program, the most important line says:

That line contains the words IF and THEN. Whenever you say IF, you must also say THEN. Do not put a comma before THEN. What comes between IF and THEN is called the condition; in that example, the condition is “age < 18”. If the condition is true (if age is really less than 18), the computer does the action, which comes after the word THEN and is:

ELSE

Let’s teach the computer how to respond to adults.

Here’s how to program the computer so that if the age is less than 18, the computer will say “You are still a minor”, but if the age is not less than 18 the computer will say “You are an adult” instead:

In programs, the word “ELSE” means “otherwise”. That program’s bottom line means: if the age is less than 18, then print “You are still a minor”; otherwise (if the age is not less than 18), print “You are an adult”. So the computer will print “You are still a minor” or else print “You are an adult”, depending on whether the age is less than 18.

Try running that program! If you say you’re 50 years old, so the screen looks like this —

the computer will reply by saying:

Multi-line IF

If the age is less than 18, here’s how to make the computer print “You are still a minor” and also print “Ah, the joys of youth”:

Here’s a more sophisticated way to say the same thing:

That sophisticated way (in which you type 4 short lines instead of a single long line) is called a multi-line IF (or a block IF).

In a multi-line IF:

In the middle of a multi-line IF, you can say ELSE:

That means: if the age is less than 18, then print “You are still a minor” and “Ah, the joys of youth”; otherwise (if age not under 18) print “You are an adult” and “We can have adult fun”.

ELSEIF

Let’s say this:

Here’s how:

One word In QBASIC, “ELSEIF” is one word. Type “ELSEIF”, not “ELSE IF”. If you accidentally type “ELSE IF”, the computer will gripe.

SELECT

Let’s turn your computer into a therapist!

To make the computer ask the patient, “How are you?”, begin the program like this:

Make the computer continue the conversation by responding as follows:

To accomplish all that, you can use a multi-line IF:

Instead of typing that multi-line IF, you can type this SELECT statement instead, which is briefer and simpler:

Like a multi-line IF, a SELECT statement consumes several lines. The top line of that SELECT statement tells the computer to analyze a$ and SELECT one of the CASEs from the list underneath. That list is indented and says:

The bottom line of every SELECT statement must say END SELECT.

Complete program Here’s a complete program:

Line 2 makes the computer ask the patient, “How are you?” The next several lines are the SELECT statement, which makes the computer analyze the patient’s answer and print “That’s good!” or “Too bad!” or else “I feel the same way!”

Regardless of what the patient and computer said, that program’s bottom line always makes the computer end the conversation by printing:

In that program, try changing the strings to make the computer print smarter remarks, become a better therapist, and charge even more money.

Error trap This program makes the computer discuss human sexuality:

The second line (which is numbered 10) makes the computer ask, “Are you male or female?”

The remaining lines are a SELECT statement that analyzes the human’s response. If the human claims to be “male”, the computer prints “So is Frankenstein!” If the human says “female” instead, the computer prints “So is Mary Poppins!” If the human says anything else (such as “not sure” or “super-male” or “macho” or “none of your business”), the computer does the CASE ELSE, which makes the computer say “Please say male or female!” and then go back to line 10, which makes the computer ask again, “Are you male or female?”

In that program, the CASE ELSE is called an error handler (or error-handling routine or error trap), since its only purpose is to handle human error (a human who says neither “male” nor “female”). Notice that the error handler begins by printing a gripe message (“Please say male or female!”) and then lets the human try again (GOTO 10).

In QBASIC, the GOTO statements are used rarely: they’re used mainly in error handlers, to let the human try again.

Let’s extend that program’s conversation. If the human says “female”, let’s make the computer say “So is Mary Poppins!”, then ask “Do you like her?”, then continue the conversation as follows:

To accomplish all that, insert the shaded lines into the program:

 

Weird programs The computer’s abilities are limited only by your own imagination — and your weirdness. Here are some weird programs from weird minds.…

Like a human, the computer wants to meet new friends. This program makes the computer show its true feelings:

When you run that program, the computer asks “Are you my friend?” If you say “yes”, the computer says “That’s swell.” If you say “no”, the computer says “Go jump in a lake.”

The most inventive programmers are kids. This program was written by a girl in the sixth grade:

When you run that program, the computer asks to watch your TV. If you say “yes”, the computer promises to come to your house at 5. If you refuse, the computer insults your feet.

Another sixth-grade girl wrote this program, to test your honesty:

When you run that program, lines 2-4 print nonsense. Then the computer asks whether you understand that stuff. If you’re honest and answer “no”, the computer will apologize. But if you pretend that you understand the nonsense and answer “yes”, the computer will print more nonsense, challenge you to translate it, wait for you to fake a translation, and then scold you for lying.

Fancy IF conditions

A Daddy wrote a program for his 5-year-old son, John. When John runs the program and types his name, the computer asks “What’s 2 and 2?” If John answers 4, the computer says “No, 2 and 2 is 22”. If he runs the program again and answers 22, the computer says “No, 2 and 2 is 4”. No matter how many times he runs the program and how he answers the question, the computer says he’s wrong. But when Daddy runs the program, the computer replies, “Yes, Daddy is always right”.

Here’s how Daddy programmed the computer:

Different relations You can make the IF clause very fancy:

In the IF statement, the symbols =, <, >, <=, >=, and <> are called relations.

When writing a relation, mathematicians and computerists habitually put the equal sign last:

When you press the ENTER key at the end of the line, the computer will automatically put your equal signs last: the computer will turn any “=<” into “<=”; it will turn any “=>” into “<=”.

To say “not equal to”, say “less than or greater than”, like this: <>.

OR The computer understands the word OR. For example, here’s how to say, “If x is either 7 or 8, print the word wonderful”:

That example is composed of two conditions: the first condition is “x = 7”; the second condition is “x = 8”. Those two conditions combine, to form “x = 7 OR x = 8”, which is called a compound condition.

If you use the word OR, put it between two conditions.

AND The computer understands the word AND. Here’s how to say, “If p is more than 5 and less than 10, print tuna fish”:

Here’s how to say, “If s is at least 60 and less than 65, print you almost failed”:

Here’s how to say, “If n is a number from 1 to 10, print that’s good”:

Can a computer be President?

To become President of the United States, you need 4 basic skills:

So altogether, to become President you need to be a good talker and listener and decision maker and also have the patience to put up with monotonous repetition.

Those are exactly the four qualities the computer has!

So by using the words PRINT, INPUT, IF, and GOTO, you can make the computer imitate any intellectual human activity. Those four magic words — PRINT, INPUT, IF, and GOTO — are the only concepts you need, to write whatever program you wish!

Yes, you can make the computer imitate the President of the United States, do your company’s payroll, compose a beautiful poem, play a perfect game of chess, contemplate the meaning of life, act as if it’s falling in love, or do whatever other intellectual or emotional task you wish, by using those four magic words. The only question is: how? The Secret Guide to Computers teaches you how, by showing you many examples of programs that do those remarkable things.

What programmers believe Yes, we programmers believe that all of life can be explained and programmed. We believe all of life can be reduced to just those four concepts: PRINT, INPUT, IF, and GOTO. Programming is the ultimate act of scientific reductionism: programmers reduce all of life scientifically to just four concepts.

The words that the computer understands are called keywords. The four essential keywords are PRINT, INPUT, IF, and GOTO.

The computer also understands extra keywords, such as CLS, LPRINT, WIDTH, SYSTEM, SLEEP, DO (and LOOP), END, SELECT (and CASE), and words used in IF statements (such as THEN, ELSE, ELSEIF, OR, AND). Those extra keywords aren’t necessary: if they hadn’t been invented, you could still write programs without them. But they make programming easier.

A BASIC programmer is a person who translates an ordinary English sentence (such as “act like the President” or “do the payroll”) into a series of BASIC statements, using keywords such as PRINT, INPUT, IF, GOTO, CLS, etc.

The mysteries of life Let’s dig deeper into the mysteries of PRINT, INPUT, IF, GOTO, and the extra keywords. The deeper we dig, the more you’ll wonder: are you just a computer, made of flesh instead of wires? Can everything that you do be explained in terms of PRINT, INPUT, IF, and GOTO?

By the time you finish The Secret Guide to Computers, you’ll know!

Exiting a DO loop

This program plays a guessing game, where the human tries to guess the computer’s favorite color, which is pink:

The INPUT line asks the human to guess the computer’s favorite color; the guess is called guess$.

If the guess is “pink”, the computer prints:

But if the guess is not “pink”, the computer will instead print “No, that’s not my favorite color” and then GO back TO line 10, which asks the human again to try guessing the computer’s favorite color.

END Here’s how to write that program without saying GOTO:

That new version of the program contains a DO loop. That loop makes the computer do this repeatedly: ask “What’s my favorite color?” and then PRINT “No, that’s not my favorite color.”

The only way to stop the loop is to guess “pink”, which makes the computer print “Congratulations!” and END.

EXIT DO Here’s another way to write that program without saying GOTO:

That program’s DO loop makes the computer do this repeatedly: ask “What’s my favorite color?” and then PRINT “No, that’s not my favorite color.”

The only way to stop the loop is to guess “pink”, which makes the computer EXIT from the DO loop; then the computer proceeds to the line underneath the DO loop. That line prints:

LOOP UNTIL Here’s another way to program the guessing game:

That program’s DO loop makes the computer do this repeatedly: say “You haven’t guessed my favorite color yet!” and then ask “What’s my favorite color?”

The LOOP line makes the computer repeat the indented lines again and again, UNTIL the guess is “pink”. When the guess is “pink”, the computer proceeds to the line underneath the LOOP and prints “Congratulations!”.

The LOOP UNTIL’s condition (guess$ = “pink”) is called the loop’s goal. The computer does the loop repeatedly, until the loop’s goal is achieved. Here’s how:

Saying —

is just a briefer way of saying this pair of lines:

Let’s make the computer print every number from 1 to 20, like this:

Here’s the program:

The second line (FOR x = 1 TO 20) says that x will be every number from 1 to 20; so x will be 1, then 2, then 3, etc. The line underneath, which is indented, says what to do about each x; it says to PRINT each x.

Whenever you write a program that contains the word FOR, you must say NEXT; so the bottom line says NEXT.

The indented line, which is between the FOR line and the NEXT line, is the line that the computer will do repeatedly; so the computer will repeatedly PRINT x. The first time the computer prints x, the x will be 1, so the computer will print:

The next time the computer prints x, the x will be 2, so the computer will print:

The computer will print every number from 1 up to 20.

When men meet women

Let’s make the computer print these lyrics:

To do that, type these lines —

and make x be every number from 2 up to 5:

 

At the top of the program, say CLS. At the end of the song, print the closing couplet:

That program makes the computer print the entire song.

Here’s an analysis:

Since the computer does the indented lines repeatedly, those lines form a loop. Here’s the general rule: the statements between FOR and NEXT form a loop. The computer goes round and round the loop, for x=2, x=3, x=4, and x=5. Altogether, it goes around the loop 4 times, which is a finite number. Therefore, the loop is finite.

If you don’t like the letter x, choose a different letter. For example, you can choose the letter i:

When using the word FOR, most programmers prefer the letter i; most programmers say “FOR i” instead of “FOR x”. Saying “FOR i” is an “old tradition”. Following that tradition, the rest of this book says “FOR i” (instead of “FOR x”), except in situations where some other letter feels more natural.

Print the squares

To find the square of a number, multiply the number by itself. The square of 3 is “3 times 3”, which is 9. The square of 4 is “4 times 4”, which is 16.

Let’s make the computer print the square of 3, 4, 5, etc., up to 20, like this:

To do that, type this line —

and make i be every number from 3 up to 20, like this:

Count how many copies

This program, which you saw before, prints “love” on every line of your screen:

That program prints “love” again and again, until you abort the program by pressing Ctrl with PAUSE/BREAK.

But what if you want to print “love” just 20 times? This program prints “love” just 20 times:

As you can see, FOR...NEXT resembles DO...LOOP but is smarter: while doing FOR...NEXT, the computer counts!

Poem This program, which you saw before, prints many copies of a poem:

It prints the copies onto paper. It prints each copy on a separate sheet of printer. It keeps printing until you abort the program — or the printer runs out of paper.

Here’s a smarter program, which counts the number of copies printed and stops when exactly 4 copies have been printed:

It’s the same as the DO...LOOP program, except that it counts (by saying “FOR i = 1 TO 4” instead of “DO”) and has a different bottom line (NEXT instead of LOOP).

Here’s an even smarter program, which asks how many copies you want:

When you run that program, the computer asks:

If you answer 5, then the n becomes 5 and so the computer prints 5 copies of the poem. If you answer 7 instead, the computer prints 7 copies. Print as many copies as you like!

That program illustrates this rule:

Count to midnight

This program makes the computer count to midnight:

The computer will print:

Semicolon Let’s put a semicolon at the end of the indented line:

The semicolon makes the computer print each item on the same line, like this:

If you want the computer to press the ENTER key before “midnight”, insert a PRINT line:

That extra PRINT line makes the computer press the ENTER key just before “midnight”, so the computer will print “midnight” on a separate line, like this:

Nested loops Let’s make the computer count to midnight 3 times, like this:

To do that, put the entire program between the words FOR and NEXT:

That version contains a loop inside a loop: the loop that says “FOR i” is inside the loop that says “FOR j”. The j loop is called the outer loop; the i loop is called the inner loop. The inner loop’s variable must differ from the outer loop’s. Since we called the inner loop’s variable “i”, the outer loop’s variable must not be called “i”; so I picked the letter j instead.

Programmers often think of the outer loop as a bird’s nest, and the inner loop as an egg inside the nest. So programmers say the inner loop is nested in the outer loop; the inner loop is a nested loop.

Abnormal exit

Earlier, we programmed a game where the human tries to guess the computer’s favorite color, pink. Here’s a fancier version of the game, in which the human gets just 5 guesses:

Line 2 warns the human that just 5 guesses are allowed. The FOR line makes the computer count from 1 to 5; to begin, i is 1. The INPUT line asks the human to guess the computer’s favorite color; the guess is called guess$.

If the guess is “pink”, the computer jumps down to the line numbered 10, prints “Congratulations!”, and tells how many guesses the human took. But if the guess is not “pink”, the computer will print “No, that’s not my favorite color” and go on to the NEXT guess.

If the human guesses 5 times without success, the computer proceeds to the line that prints “Sorry… You lose.”

For example, if the human’s third guess is “pink”, the computer prints:

If the human’s very first guess is “pink”, the computer prints:

Saying “1 guesses” is bad grammar but understandable.

That program contains a FOR...NEXT loop. The FOR line says the loop will normally be done five times. The line below the loop (which says to PRINT “Sorry”) is the loop’s normal exit. But if the human happens to input “pink”, the computer jumps out of the loop early, to line 10, which is the loop’s abnormal exit.

STEP

The FOR statement can be varied:

To count down, you must use the word STEP. To count from 17 down to 5, give this instruction:

This program prints a rocket countdown:

The computer will print:

This statement is tricky:

It says to start i at 5, and keep adding 3 until it gets past 16. So i will be 5, then 8, then 11, then 14. The i won’t be 17, since 17 is past 16. The first value of i is 5; the last value is 14.

In the statement FOR i = 5 TO 16 STEP 3, the first value or initial value of i is 5, the limit value is 16, and the step size or increment is 3. The i is called the counter or index or loop-control variable. Although the limit value is 16, the last value or terminal value is 14.

Programmers usually say “FOR i”, instead of “FOR x”, because the letter i reminds them of the word index.

Let’s make the computer print this message:

That message concerns this list of food: meat, potatoes, lettuce, tomatoes, honey, cheese, onions, peas. That list doesn’t change: the computer continues to love those foods throughout the entire program.

A list that doesn’t change is called DATA. So in the message about food, the DATA is meat, potatoes, lettuce, tomatoes, honey, cheese, onions, peas.

Whenever a problem involves DATA, put the DATA at the top of the program, just under the CLS, like this:

You must tell the computer to READ the DATA:

That READ line makes the computer read the first datum (“meat”) and call it a$. So a$ is “meat”.

Since a$ is “meat”, this shaded line makes the computer print “I love meat”:

Hooray! We made the computer handle the first datum correctly: we made the computer print “I love meat”.

To make the computer handle the rest of the data (potatoes, lettuce, etc.), tell the computer to READ and PRINT the rest of the data, by putting the READ and PRINT lines in a loop. Since we want the computer to READ and PRINT all 8 data items (meat, potatoes, lettuce, tomatoes, honey, cheese, onions, peas), put the READ and PRINT lines in a loop that gets done 8 times, by making the loop say “FOR i = 1 TO 8”:

Since that loop’s main purpose is to READ the data, it’s called a READ loop.

When writing that program, make sure the FOR line’s last number (8) is the number of data items. If the FOR line accidentally says 7 instead of 8, the computer won’t read or print the 8th data item. If the FOR line accidentally says 9 instead of 8, the computer will try to read a 9^th data item, realize that no 9^th data item exists, and gripe by saying:

Then press ENTER.

Let’s make the computer end by printing “Those are the foods I love”, like this:

To make the computer print that ending, put a PRINT line at the end of the program:

End mark

When writing that program, we had to count the DATA items and put that number (8) at the end of the FOR line.

Here’s a better way to write the program, so you don’t have to count the DATA items:

The third line (DATA end) is called the end mark, since it marks the end of the DATA. The READ line means:

When the computer exits from the DO loop, the computer prints “Those are the foods I love”. So altogether, the entire program makes the computer print:

The routine that says:

is called the end routine, because the computer does that routine when it reaches the end of the DATA.

Henry the Eighth Let’s make the computer print this nursery rhyme:

If you own a jump rope, have fun: try to recite that poem while skipping rope!

This program makes the computer recite the poem:

Since the data’s too long to fit on a single line, I’ve put part of the data in line 2 and the rest in line 3. Each line of data must begin with the word DATA. In each line, put commas between the items. Do not put a comma at the end of the line.

The program resembles the previous one. The new line (IF a$ = “to wed” THEN PRINT) makes the computer leave a blank line underneath “to wed”, to mark the bottom of the first verse.

Pairs of data

Let’s throw a party! To make the party yummy, let’s ask each guest to bring a kind of food that resembles the guest’s name. For example, let’s have Sal bring salad, Russ bring Russian dressing, Sue bring soup, Tom bring turkey, Winnie bring wine, Kay bring cake, and Al bring Alka-Seltzer.

Let’s send all those people invitations, in this form:

Here’s the program:

The DATA comes in pairs. For example, the first pair consists of “Sal” and “salad”; the next pair consists of “Russ” and “Russian dressing”. Since the DATA comes in pairs, you must make the end mark also be a pair (DATA end,end).

Since the DATA comes in pairs, the READ line says to READ a pair of data (person$ and food$). The first time that the computer encounters the READ line, person$ is “Sal”; food$ is “salad”. Then the LPRINT lines print this message onto paper:

The LPRINT CHR$(12) makes the computer eject the paper from the printer.

Then the computer comes to the word LOOP, which sends the computer back to the word DO, which sends the computer to the READ line again, which reads the next pair of DATA, so person$ becomes “Russ” and food$ becomes “Russian dressing”. The LPRINT lines print onto paper:

The computer prints similar letters to all the people.

After all people have been handled, the READ statement comes to the end mark (DATA end,end), so that person$ and food$ both become “end”. Since person$ is “end”, the IF statement makes the computer EXIT DO, so the computer prints this message onto the screen:

In that program, you need two ends to mark the data’s ending, because the READ statment says to read two strings (person$ and food$).

Debts Suppose these people owe you things:

Let’s remind those people of their debt, by writing them letters, in this form:

To start writing the program, begin by saying CLS and then feed the computer the DATA. The final program is the same as the previous program, except for the part I’ve shaded:

Triplets of data

Suppose you’re running a diet clinic and get these results:

This program makes the computer print a nice report:

Line 2 contains the DATA, which comes in triplets. The first triplet consists of Joe, 273, and 219. Each triplet includes a string (such as Joe) and two numbers (such as 273 and 219), so line 3’s end mark also includes a string and two numbers: it’s the word “end” and two zeros. (If you hate zeros, you can use other numbers instead; but most programmers prefer zeros.)

The READ line says to read a triplet: a string (person$) and two numbers (weight.before and weight.after). The first time the computer comes to the READ statement, the computer makes person$ be “Joe”, weight.before be 273, and weight.after be 219. The PRINT lines print this:

RESTORE

Examine this program:

The first READ makes the computer read the first datum (love), so the first PRINT makes the computer print:

The next READ would normally make the computer read the next datum (death); but the RESTORE 10 tells the READ to skip ahead to DATA line 10, so the READ line reads “chocolate” instead. The entire program prints:

So saying “RESTORE 10” makes the next READ skip ahead to DATA line 10. If you write a new program, saying “RESTORE 20” makes the next READ skip ahead to DATA line 20. Saying just “RESTORE” makes the next READ skip back to the beginning of the first DATA line.

Continents This program prints the names of the continents:

That program makes the computer print this message:

Let’s make the computer print that message twice, so the computer prints:

To do that, put the program in a loop saying “FOR i = 1 TO 2”, like this: