The most popular computer language is Visual Basic for Windows (VB). More programs are written in VB than in any other computer language.

Using VB, you can easily create Windows programs that let the human use a mouse to click on icons, choose from menus, use dialog boxes, etc.

After inventing the first VB, Microsoft invented improved versions, called VB 2, VB 3, VB 4, VB 5, and VB 6. Then came a further improvement, called VB.Net 2002, then VB.Net 2003. Now Microsoft is trying to invent VB 2005 (whose codename is VB Whidbey).

You can get the current VB (which is VB.Net 2003) in three ways:

To use VB.Net 2002, VB.Net 2003, or VB 2005, you need Windows XP (or Windows 2000 or Windows Server 2003). Many programmers still use VB 6 because it runs on all modern versions of Windows (95, 98, Me, XP, NT, 2000, and 2003).

This chapter explains VB 6 (which is similar to other versions of VB).

Before you read this chapter and study VB, prepare yourself! Do 3 prerequisite activities:

VB uses these commands (which resemble QBASIC’s):

VB uses these functions (which resemble QBASIC’s):

In VB, you never write “a long program”. Instead, you begin by drawing objects on the screen (as if you were using a graphics program). Then for each object, you write a little program (called a subroutine) that tells the computer how to manipulate the object. VB handles these objects:

Each object has properties, which you can manipulate:

 

 

 

 

Let’s have fun programming!

Copy VB to the hard disk

Here’s how to copy Visual Studio (version 6, Enterprise Edition) to the hard disk. (Other versions of Visual Studio and VB are similar.)

Start VB

To start using VB, click “Start” then “Programs”. (Then click “Microsoft Visual Studio 6.0”, if you see that choice.)

Click “Microsoft Visual Basic 6.0”.

Create simple programs

Press ENTER. (That has the same effect as double-clicking “Standard EXE”).

That creates an object to manipulate: it’s a window called Form1. You see it on the screen.

On the screen’s right side, you should see a line saying:

(If you don’t see that line, make it appear by pressing the F4 key.)

Click “AutoRedraw” then press the T key, so that line becomes:

That tells the computer to automatically redraw Form1 each time its contents change. (If you forget to set AutoRedraw to True, the examples in this chapter won’t work!)

Double-click in the middle of the Form1 window. The double-clicking tells the computer you want to write a subroutine about that object.

The computer starts writing the subroutine for you. The computer writes:

The top line, which is “Private Sub Form_Load()”, is the subroutine’s header. The bottom line, which is “End Sub”, is the subroutine’s footer; it marks the end of the subroutine. Between those lines, insert lines that tell the computer what to do to the object (which is the Form1 window). The lines you insert are called the subroutine’s body.

Simplest example Let’s make the Form1 window show the answer to this math problem: 4 + 2. To do that, type this line —

so the subroutine becomes:

To run your program, press the F5 key. Then you see the Form1 window again. In that window, the computer has printed the answer:

When you’ve finished admiring that answer, stop the program by clicking the Form1 window’s X button. Then you see the subroutine again:

Edited example Let’s edit that subroutine, so instead of printing the answer to 4 + 2, it will print the answer to 79 + 2.

To do that, change the 4 to 79. Here’s how: click the 4’s left edge, then press the DELETE key (to delete the 4), then type 79, so the subroutine looks like this:

Run that program by pressing the F5 key. Then the Form1 window shows the new answer:

When you finish admiring that, click Form1’s X button.

Longer example Let’s make the computer print the answer to 7 - 3 (which is 4) and the answer to -26.3 + 1 (which is -25.3).

To do that, change the subroutine to this:

To make those changes, use your mouse and keyboard (as if you’re doing word processing). If you want to delete a whole line (yank it), do this: click in the line’s middle; then while holding down the Ctrl key, tap the Y key. If you want to insert an extra line, choose one of these methods:

If you make a mistake, undo it by clicking the Undo button (which is near the screen’s top, under the word “Query”.)

When typing the minus sign, make sure you hold down the SHIFT key.

Run that program by pressing the F5 key. Then the Form1 window shows the new answers:

Your own examples Go ahead! Try changing the subroutine, to do different math problems instead!

Multiply To multiply, use an asterisk. So to multiply 2 by 6, type this:

The computer will print:

Divide To divide, use a slash. So to divide 8 by 4, type this:

The computer will print:

Congratulations You’ve written VB subroutines and created VB programs, so you’ve become a VB programmer! You can put on your résumé, “VB programmer!”

Type faster

Here are tricks that let you type faster.

You don’t need to capitalize computer words such as “Print”. The computer will capitalize them automatically when you press ENTER at the end of the line.

You must put a blank space after the word “Print” to separate “Print” from the number after it. But you don’t need to put spaces around symbols such as “+”. The computer will insert those spaces automatically when you press ENTER at the end of the line.

Instead of typing the word “Print”, you can type a question mark. When you press the ENTER key at the end of the line, the computer will automatically turn the question mark into “Print” and put a space after it. So instead of typing —

you can type:

Huge and tiny numbers

When dealing with huge and tiny number, be careful!

Avoid commas Do not put commas in big numbers. To write four million, do not write 4,000,000; instead, write 4000000.

The symbol # If you type a whole number that’s huge (bigger than 2147483647) or a type “a decimal point followed by just 0 or nothing” (as in 53.0 or 53.), the computer will automatically write the symbol # afterwards (when you press ENTER or run the program). That’s the computer’s way of reminding itself to treat your bizarre number carefully!

Use decimals for big answers The computer sometimes has difficulty handling answers bigger than 32 thousand. To avoid difficulty,
put a decimal point in any problem whose answer might be bigger than 32 thousand.

For example, suppose you want the computer to multiply 250 by 200. Since the answer to that problem is 50 thousand, which is bigger than 32 thousand, you should put a decimal point in that problem, like this —

or like this:

Suppose you forget to insert a decimal point, and you say just this:

the computer will complain by saying:

Whenever the computer says “Run-time error”, you have 2 popular choices:

Then the computer will print the correct answer:

E notation If the computer’s answer is huge (at least a quadrillion, which is 1000000000000000) or tiny (less than .1), the computer might print an E in the answer. The E means “move the decimal point”.

For example, suppose the computer says the answer to a problem is:

The E means, “move the decimal point”. The plus sign means, “towards the right”. Altogether, the E+15 means, “move the decimal point towards the right, 15 places.” So look at 1.586743, and move the decimal point towards the right, 15 places; you get 1586743000000000.

So when the computer says the answer is 1.586743E+15, the computer really means the answer is 1586743000000000, approximately. The exact answer might be 1586743000000000.2 or 1586743000000000.79 or some similar number, but the computer prints just an approximation.

Suppose your computer says the answer to a problem is:

After the E, the minus sign means, “towards the left”. So look at 9.23, and move the decimal point towards the left, 6 places. You get:

.00000923

So when the computer says the answer is 9.23E-06, the computer really means the answer is:

.00000923

You’ll see E notation rarely: the computer uses it just if an answer is huge (at least a quadrillion) or tiny (tinier than .1). But when the computer does use E notation, remember to move the decimal point!

The highest number The highest number the computer can handle well is about 1E308, which is 1 followed by 308 zeros. If you try to go much higher, the computer will gripe (by saying “Overflow”).

The tiniest decimal The tiniest decimal the computer can handle accurately is 1E-309 (which is a decimal point followed by 309 digits, 308 of which are zeros). If you try to go tinier, the computer will either say 0 or give you a rough approximation.

Order of operations

What does “2 plus 3 times 4” mean? The answer depends on who you ask.

To a clerk, it means “start with 2 plus 3, then multiply by 4”; that makes 5 times 4, which is 20. But to a scientist, “2 plus 3 times 4” means something different: it means “2 plus three fours”, which is 2 + 4 + 4 + 4, which is 14.

Since computers were invented by scientists, computers think like scientists. If you type —

the computer will think you mean “2 plus three fours”, so it will do 2 + 4 + 4 + 4 and print this answer:

The computer will not print the clerk’s answer, which is 20. So if you’re a clerk, tough luck!

Scientists and computers follow this rule: do multiplication and division before addition and subtraction. So if you type —

the computer begins by hunting for multiplication and division. When it finds the multiplication sign between the 3 and the 4, it multiplies 3 by 4 and gets 12, like this:

So the problem becomes 2 + 12, which is 14, which the computer prints.

For another example, suppose you type:

The computer begins by doing all the multiplications and divisions. So it does 2 * 3 (which is 6) and does 72 / 9 * 5 (which is 8 * 5, which is 40), like this:

So the problem becomes 10 - 6 + 40, which is 44, which is the answer the computer prints.

Parentheses You can use parentheses the same way as in algebra. For example, if you type —

the computer will compute 5 - 2 and print:

You can put parentheses inside parentheses. If you type —

the computer will compute 10 - (5 - 2), which is 10 - 3, and will print:

Multi-statement line

In your subroutine, a line can include many statements separated by colons, like this:

That line means the same thing as:

When you run the program, the computer will print:

Strings

Let’s make the computer fall in love. Let’s make it say, “I love you”.

Create this subroutine:

The computer types the top and bottom lines for you automatically, so type just the Print line. Here’s how:

When you run the program (by pressing F5), the computer will obey your command; it will print this message onto the Form1 window:

You can change the computer’s personality. For example, if you edit the Print command to make it become —

the computer will reply:

Notice that to make the computer print a message, you must put the message between quotation marks. The quotation marks make the computer copy the message without worrying about what the message means. For example, if you misspell “I love you”, and type —

the computer will still copy the message (without worrying about what it means); the computer will print:

Type faster Instead of typing —

you can type just this:

At the end of that line, when you press the ENTER key (or F5), the computer will automatically do three things:

Jargon The word “joy” consists of 3 characters: j and o and y. Programmers say that the word “joy” is a string of 3 characters.

Strings versus numbers The computer can handle two types of expressions: strings and numbers. Put strings (such as “joy” and “I love you”) in quotation marks. Numbers (such as
4 + 2) do not go in quotation marks.

Accidents Suppose you accidentally put the number 2 + 2 in quotation marks, like this:

The quotation marks make the computer think “2 + 2” is a string instead of a number. Since the computer thinks “2 + 2” is a string, it copies the string without analyzing what it means; the computer will print:

It will not print 4.

Suppose you want the computer to print the word “love” but you accidentally forget to put the string “love” in quotation marks, and type this instead:

Since you forgot the quotation marks, the computer is confused. Whenever the computer is confused, it either gripes at you or prints nothing or prints a zero. In this particular example, when you run the program the computer will print nothing: the Form1 window will stay blank. So if you incorrectly tell the computer to proclaim its love, it will give you a blank look.

Longer subroutines You can program the computer say it’s madly in love with you!

Let’s make the computer say:

To make the computer say all that, just run this subroutine:

The computer typed the top and bottom lines; just type the Print lines then press F5. Try it!

To have even more fun, run this program:

It makes the computer print “I long”, then print the answer to 2+2 (which is 4), then print “U”. So altogether, the computer prints:

Yes, the computer says it longs for you!

Tricky printing

Printing can be tricky! Here are the tricks.

Indent Suppose you want the computer to print this letter onto Form1:

This subroutine prints it:

Each Print line contains two quotation marks. To make the computer indent a line, put blank spaces AFTER the first quotation mark.

Blank lines Life consists of some joy, some sorrow, and some numb emptiness. To express those feelings, run this subroutine:

Altogether, the computer will print:

Semicolons Run this subroutine:

The first Print line (saying to print “fat”) ends with a semicolon. The semicolon makes the computer print the next item on the same line; so the computer will print “her” on the same line, like this:

This line shows what happens to an evil king on a boat:

It makes the computer print “sin” and then print “king” on the same line, like this:

Spaces after numbers Try typing this command:

Whenever the computer prints a NUMBER, it prints a blank space afterwards; so the computer will print a blank space after -3, like this:

Spaces before positive numbers This command tells what to put in your coffee:

The computer prints 7 and “do” and “nuts”. Since 7 is a number, the computer prints a blank space after the 7. The computer prints another blank space BEFORE every number that’s positive; so the computer prints another blank space before the 7, like this:

Hey, if you’re feeling cool, maybe this command expresses your feelings:

The computer prints “the temperature is”, then 4 + 25 (which is 29), then “degrees”. Since 29 is a positive number, the computer prints a blank space before and after the 29:

Fix the negative numbers Use this command if you’re even colder:

The computer prints “the temperature is”, then 4 - 25 (which is -21), then “degrees”. Since -21 is a number, the computer prints a space after it; but since -21 is not positive, the computer does not print a space before it. The computer prints:

Yuk! That looks ugly! It would look prettier if there were a space before the -21. To insert a space, put the space inside quotation marks:

Then the computer will print:

Multiple calculations By using semicolons, you can make the computer do many calculations at once.

For example, this command makes the computer do 6+2, 6-2, 6*2, and 6/2, all at once:

That makes the computer print the four answers:

The computer prints spaces between the answers, because the computer prints a space after every number (and an additional space before every number that’s positive).

Print a quotation mark The symbol for inches is ". Let’s make the computer print this sentence:

This Print command does not work:

When the computer sees the quotation mark after 2, it mistakenly thinks that quotation mark is paired with the quotation mark before “The”, then gets totally confused.

Here’s the correct way to write that line:

The symbol "" means: print a quotation mark. That Print line makes the computer print:

Here’s the rule: to print the quotation mark ("), you must put the symbol "" in your Print statement.

Let’s make the computer print this sentence:

To print the quotation mark before “Hamlet”, you must type "". To print the quotation mark after “Hamlet”, you must type "" Here’s the solution:

Print on paper If you say Printer.Print instead of just Print, the computer will print on paper instead of on your screen.

For example, if you want the computer to compute 2 + 2 and print the answer on paper, create this subroutine:

When you run that program (by pressing the F5 key), the computer will compute 2 + 2 and prepare to print the answer (which is 4) onto paper. The actual printing will occur when you finish running the program (by clicking its X button).

The printing will succeed just if you already put paper in the printer and turned the printer’s power on.

If you say Print 2 + 2, the computer prints the answer (4) onto the screen. If you say Printer.Print 2 + 2, the computer prints 4 onto paper instead. If you want to print the answer onto the screen and also onto paper, say Print and also Printer.Print, like this:

That technique is called dual printing because it makes the computer print in two places: on the screen and on paper.

If you tell the computer to print onto paper, the computer prints to the RAM first, in a part of the RAM called the Printer object. The computer doesn’t copy from the Printer object to the printer until you finish running your program (by clicking its X button) or give a Printer.EndDoc command (in your subroutine).

Here’s another way to accomplish dual printing:

The first two lines print this message onto Form1, which is on the screen:

The PrintForm line copies Form1 onto paper; so the printer will print “Your eyes are haunting” and “Your smile is gentle”, all in a gray box (since Form1 is a gray box). The printing occurs immediately. It works just if you remembered to say “AutoRedraw T” (as I warned you on page 463) and didn’t give any Printer.Print commands.

Final steps

When you finish playing with your program, here’s what to do.

Make sure you see the subroutine you typed. (If you see Form1’s window instead, close that window by clicking its X button.)

Save If you like the program you created and want to save it on disk, click the Save Project button. (It looks like a floppy disk. It’s near the screen’s top, below the word “Format”.)

If you haven’t done so already, invent a name for your program (such as “Funmaker”): type the name, press ENTER, type the name again, and press ENTER again. (During that process, if the computer complains that the name “already exists”, press ENTER then try a different name instead.)

That process makes the computer create two files (Funmaker.frm and Funmaker.vbp) and put them in your hard disk’s VB98 folder (which is in the Microsoft Visual Studio folder, which is in the Program Files folder).

If the computer asks “Add this project to SourceSafe?”, click “No”.

Afterwards, if you make further changes to the program, click the Save Project button again to save them.

New If you’re tired of working on a program and want to start inventing a different program instead, click “File” then “New Project”.

(If you didn’t save the previous program, the computer will ask “Save changes?” If you want to save the previous program, click “Yes” and answer any questions the computer asks about the program’s name; otherwise, click “No”.)

Eventually, the computer will say “New Project”.

Press ENTER. (That has the same effect as double-clicking Standard EXE.) Click “AutoRedraw”, then press the T key.

Exit When you finish using VB, click the X button that’s in the screen’s top right corner.

Open When you start using VB, you typically press ENTER (which has the same effect as double-clicking “Standard EXE”). Instead of pressing ENTER, try clicking “Existing”. You see a list of programs you created. Double-click the program you want to return to.

Some parts of your program will be missing from your screen. To make sure you see them all, do this:

Make .exe Try this experiment. Create a program and save it. On the File menu, you see a choice saying “Make”; for example, if you named your program “Funmaker”, you see a choice saying “Make Funmaker.exe”. Choose that, then press ENTER. Then click the Save Project button again. That makes the computer put a file called Funmaker.exe into your VB98 folder.

Congratulations! You’ve made an .exe file that can be run without going into Visual Basic!

Here’s how to run that file:

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

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

The next 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 subroutine, x is a numeric variable; it stands for the number 47. The value of x is 47.

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

A variable is a box

When you run that subroutine, 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.

More examples

Here’s another subroutine body:

The top 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.

Another example:

The top 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 top 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 top 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 subroutine, here’s what happens inside the computer’s RAM. The top 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.

Decimal points

On page 464, I said to “put a decimal point in any problem whose answer might be bigger than 32 thousand.” Here’s good news: when using a variable, the computer inserts any needed decimal point automatically, so you don’t have to worry about it!

For example, suppose you say:

When the computer encounters that Print line, it will change x from 200 to 200.0, to handle results bigger than 32000. It will multiply 250 by 200.0 and print the correct answer:

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 third 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 subroutines:

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

In the right-hand subroutine, the third line changes c to 1, so both b and c are 1. The bottom line prints 2.

While you run those subroutines, here’s what happens inside the computer’s RAM. For both subroutines, the top two lines do this:

box b                 1

box c                 7

In the left program, the third 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 third 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 subroutine:

But that subroutine’s silly, since it contains the number 1297.43 four times. This subroutine’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 subroutine 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:

The top line says x stands for the string “I love you”. The bottom line prints:

In that subroutine, x is a variable. Since it stands for a string, it’s called a string variable.

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

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

Spaces between strings

Examine this subroutine:

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, use 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 top line says p stands for “Peas porridge ”. The later lines make the computer print:

This subroutine prints a fancier rhyme:

The top three lines define h, m, and c. The later lines make the computer print:

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 as long as you wish: up to 255 characters! The name’s first character must be a letter; the remaining characters can be letters or digits. The computer ignores capitalization: it assumes that CityPopulationIn2001 is the same as citypopulationin2001.

The name must not be a word having a special meaning to the computer. For example, the name cannot be “Print”.

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

Here’s how to make a box appear suddenly on your screen.

Message box

Into any subroutine, you can insert this line:

When the computer runs the program and encounters that line, the computer suddenly creates a message box (a window containing a short message), which covers Form1 and contains this message: “Warning: your hair looks messy today”. The computer automatically makes the window be wide enough to include the whole message and be centered on the screen. When that window suddenly appears, the computer also rings a bell to get the human’s attention.

The window includes an OK button. When the human finishes reading the message, the human must click that OK button (or press ENTER) to make the window go away.

After the window goes away, Form1 reappears and the computer continues running the rest of the program (including any lines below the MsgBox line). Form1 remains on the screen until the human clicks Form1’s X button to end the program.

To make the message box fancier, say vbExclamation, like this:

That makes the message box window include an exclamation icon (an exclamation point in a yellow triangle).

You can choose from 4 icons:

Input box

For a wild experience, type this subroutine:

Run the program (by pressing F5). Here’s what happens…

The InputBox line makes the computer suddenly creates an input box, which is a window letting the human type info into the computer. That window covers Form1 and is slightly above the screen’s center. It contains this prompt: “What is your name?” It also contains a white box (into which the human can type a response) and an OK button.

The computer waits for the human to type a response. When the human finishes typing a response, the human must click the OK button (or press ENTER) to make the window go away.

Then Form1 reappears and the computer makes x be whatever the human typed. For example, if the human typed —

x will be Maria. Then the Print line will make the computer print:

College admissions This subroutine makes the computer print a letter admitting you to the college of your choice:

Run the program (by pressing F5). An input box suddenly appears, asking “What college would you like to enter?” Type your answer (then click OK or press ENTER).

For example, if you type —

the college will be Harvard and so the computer will print:

If you type this instead —

the computer will print:

All the printing is onto Form1. If you want to print onto paper instead, change each “Print” to “Printer.Print”.

Numeric input To input a string, you’ve learned to say InputBox. To input a number, say InputBox but also say Val, to emphasize that you want the computer to produce a numeric value.

For example, this subroutine asks for your two favorite numbers and prints their sum:

When you run the program (by pressing F5), the computer asks “What is the first number?”, waits for you to type it, and calls it x. Then the computer asks “What is the second number?”, waits for you to type it, and calls it y. Then the computer prints the sum of the numbers. For example, if the first number was 7 and the second number was 2, the computer will print the sum:

In that program, if you accidentally omit each Val, the computer will think x and y are strings instead of numbers, so the computer will add the string “7” to the string “2” and print this longer string:

Predict your future This subroutine makes the computer predict your future:

When you run the program, the computer asks, “In what year were you born?” If you answer —

y will be the numeric value 1962, and the computer will correctly print:

Prices 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.) These lines find the price of multiple tickets:

Conversion These lines convert feet to inches:

When you run the program, the computer asks “How many feet?” If you answer —

the computer will print:

Trying to convert to the metric system? These lines convert inches to centimeters:

Nice day today, isn’t it? These lines convert the temperature from Celsius to Fahrenheit:

When you run the program, the computer asks “How many degrees Celsius?” If you answer —

the computer will print:

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.

 

 

 

 

 

 

 

 

 

 

 

 

A subroutine is a list of statements that you want the computer to perform. Here’s how to control which statements the computer performs, and when, and in what order.

If

This subroutine makes the computer discuss the human’s age:

When that program is run (by pressing F5), the computer asks “How old are you?” and waits for the human’s reply. For example, if the human says —

the age will be 15. Then the computer will print:

Let’s make that subroutine fancier, so if the human is under 18 the computer will also say “You are still a minor”. To do that, just add a line saying —

so the subroutine looks like this:

For example, if the human runs the program and says —

the computer will print:

If instead the human says —

the computer will print just:

In that program, the most important line is:

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 the 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 If 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, 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:

Here’s how to indent the Print lines in that block:

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:

“ElseIf” is one word. Type “ElseIf”, not “Else If”. If you accidentally type “Else If”, the computer will gripe.

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 age 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 age is more than 5 and less than 10, print you get hamburgers for lunch”:

Here’s how to say, “If score 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”:

Yes/no message box

Let’s make the computer ask, “Do you love me?” If the human says “Yes”, let’s make the computer say “I love you too!” If the human says “No”, let’s make the computer say “I don’t love you either!”

This subroutine accomplishes that goal:

But that subroutine has a flaw: what if the human types neither “yes” nor “no”? Instead of typing “yes”, what if the human types “YES” or “Yes” or “yeah” or “yep” or “yessiree” or just “y” or “certainly” “I love you tremendously” or “not sure”? In those situations, since the human didn’t type simply “yes”, the computer will say “I don’t love you either!”, which is inappropriate.

The problem with that subroutine is it gives the human too many choices: it lets the human type anything in the input box.

To make sure the computer reacts appropriately to the human, give the human fewer choices. Restrict the human to choosing just Yes or No. Here’s how: show the human a Yes button and a No button, then force the human to click one of them. This subroutine accomplishes that:

The MsgBox line makes the computer create a message box saying “Do you love me?” A normal message box contains an OK button, but vbYesNo makes this be a yes/no message box instead (which contains Yes and No buttons instead of an OK button).

If the human clicks the Yes button, the subroutine makes the computer print “I love you too!” If the human does otherwise (by clicking the No button), the computer prints “I don’t love you either!”

Select

Let’s turn your computer into a therapist!

To do that, make the computer ask the patient “How are you?” and let the patient type whatever words the patient wishes. Just begin the subroutine like this:

That makes the computer ask “How are you?” and makes the patient’s response be called the feeling.

Make the computer continue the conversation 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 the feeling 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 subroutine Here’s a complete subroutine:

The InputBox line 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 subroutine’s bottom Print 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.

Fancy cases You can create fancy cases:

Exit Sub

To make the computer skip the bottom part of your subroutine, say Exit Sub, like this:

When you run that program (by pressing F5), the computer will print “I love the company president” and then exit from the subroutine, without printing “as much as stale bread”. The computer will print just:

Suppose you write a subroutine that prints a long message, and you want to run the program several times (so several of your friends get the message). If one of your friends would be offended by the end of your message, send that friend an abridged message! Here’s how: put Exit Sub above the part of the message that you want the computer to omit.

End

Here’s a simple subroutine:

When human runs the program, the computer creates a message box saying “Warning: your hair looks messy today”. Then the computer waits for the human to click the message box’s OK button.

When the human clicks the OK button, the message box disappears. Then the computer is supposed to do any remaining lines in the subroutine. But there are no lines remaining to be done. So the computer just waits for the human to close the program by clicking its X button.

What if the human is too stupid to know to click the X button? Instead of clicking the X button, what if the human just keeps waiting to see whether the computer will do something? The situation is stupid: the computer waits for the human to click the X button, while the human waits for the computer to say what to do next.

To end such confusion, say End near your subroutine’s bottom, like this:

That End line makes the computer stop running the program and automatically click the X button.

Long programs While running a long program, the computer should occasionally ask whether the human wants to continue. To make the computer ask that, insert this line:

That line creates a yes/no message box asking “Do you want to continue?” If the human clicks the No button, the program will end (and the computer will automatically click the program’s X button).

You can change Form1’s properties.

Caption

The top of Form1’s window normally says “Form1”, but you can make it say something else instead. For example, you can make it say “Results” or “Payroll results” or “Mary’s window” or “Fun stuff” or “Hey, I’m a funny window full of fun stuff!” You can make the top of the window say whatever you wish! That’s called the window’s caption.

Let’s make the caption become “Fun stuff”. You can do that in two ways.…

Equation method One way to make the caption become “Fun stuff” is to insert this equation in Form1’s subroutine:

Then the caption will change to “Fun stuff” when you run the program.

Property-list method Here’s a more sophisticated way to change the caption to “Fun stuff”.

At the screen’s right side, you should see a window called “Properties — Form1”. (If you accidentally erased that window, make it reappear by pressing the F4 key.)

In that window, you can see this property list:

(The screen shows the list’s beginning. To see the whole list, use the list’s scroll arrows.)

That list says the caption is normally “Form1”.

To change the caption, click the word “Caption” in that list, then type what you want the caption to be, so the property list’s Caption line becomes this:

Try that now! It makes the top of Form1 immediately say “Fun stuff”. To see the top of Form1 easily, run the program (by pressing F5) or close the subroutine’s window (by clicking its X button).

Colors

Normally, the inside of the Form1 window shows black characters on a gray background. Get wilder!

Property-list method Here’s how to make the background color be more exciting than gray:

Here’s how to make the characters have a color more exciting than black:

Equation method This subroutine makes the background color be yellow, then print (in red letters) “My love for you is as hot as fire”, then print (underneath in blue letters) “but I feel blue”:

In the equations, you can use 8 simple colors: vbYellow, vbRed, vbBlue, vbGreen, vbBlack, vbWhite, vbCyan (which is a greenish blue), and vbMagenta (which is a purplish red).

To invent a fancier color, tell the computer how much Red, Green, and Blue light to mix together; that’s called an RGB mix. In the mix, the Red, Green, and Blue can each be up to 255. For example, you can create orange by shining a red light at full intensity (255) and a green light at lower intensity (127), and keeping the blue light off (0), so orange is RGB(255, 127, 0). This line create orange characters:

Here are some popular colors and their RGB codes:

Fonts

Normally, the inside of the Form1 window shows characters whose font is plain (MS Sans Serif) and small: just 8 points high.

(A point is ¹/₇₂ of an inch, on paper or on a 14-inch monitor’s screen. If your monitor is slightly bigger than 14-inch, everything on the monitor’s screen looks slightly magnified.)

Try wilder fonts! Here’s how.…

Property-list method In the property list, click Font then Font’s down-arrow.

You see an alphabetical list of fonts. (To see the whole list, use its scroll arrows.) Click the font you want.

Warning: if you pick a font that other computers don’t have, your program might not run well on other computers. Here are the safest fonts to choose:

You see a list of font styles (Regular, Italic, Bold, and Bold Italic). Click the font style you want.

You see a list of recommended sizes. For MS Sans Serif, the recommended sizes are 8, 10, 12, 14, 18, and 24; for the best fonts (Arial, Courier New, and Times New Roman), the recommended sizes are 8, 9, 10, 11, 12, 14, 16, 18, 20, 22, 24, 26, 28, 36, 48, and 72. Click one of those sizes.

If you wish, choose Strikeout or Underline (by clicking their boxes to put check marks there).

When you finish, press ENTER.

Equation method This subroutine prints (in normal letters) “My love for you is” then prints (underneath dramatically) “huge!”

If you want strikeout, you must say:

Notice you must say Strikethrough (not Strikeout) and must put a period before it. (That’s because the folks who invented Visual Basic 6 were accidentally inconsistent. They screwed up!)

Maximize

The Form1 window is normally medium-sized. To maximize it, you can use 3 methods.

Manual method While the program is running (because you pressed F5), you can manually click the Form1 window’s maximize button. That maximizes the window but just temporarily: when you finish running the program (by clicking the Form1 window’s X button), the computer forgets about maximization. The next time you run the program, it will not be maximized, unless you click the maximize button again.

Equation method Insert this equation in Form1’s subroutine:

To make the equation work fast, put it at the subroutine’s beginning (just below the Private Sub line).

Since the code number for “maximized” is 2, you can write the equation more briefly, like this:

Property-list method In the property list, click WindowState. Then either type 2 or do this: click WindowState’s down-arrow then “2 — Maximized”.

That makes the property list’s WindowState line become this:

(You temporarily see just part of “2 — Maximized”; you’ll see the rest when you click elsewhere on the screen.)

Refuse to maximize

Instead of maximizing the Form1 window, you can do just the opposite: you can prevent the user from maximizing. Here’s how.…

In the property list, click MaxButton. Then type an F (or click MaxButton’s down-arrow then “False”). That makes the property list’s MaxButton line become:

That make Form1’s maximize button be grayed out while the program runs; the maximize button will become gray instead of black. That grayed-out button will ignore all attempts to be clicked, so the window will refuse to maximize.

Adjust form size

Here’s how to adjust Form1’s size.…

Property-list method In the property list, click Width. Then type a number indicating how wide you want Form1, measured in twips. (A twip is a twentieth of a point.)

The normal width is 4800 twips. If you want Form1 to be wider, type a number bigger than 4800 (such as 9000). If you want Form1 to be smaller, type a number smaller than 4800 (such as 2000).

The biggest permissible width is 15360, which makes Form1 stretch all the way across the screen. The smallest permissible width is 1680, which makes Form1 be just slightly over an inch wide.

In the property list, click Height then type how many twips tall you want Form1.

The normal height is 3600 twips. The biggest permissible height is 11520, which makes Form1 be as tall as the screen; but you should stay below 11000, to avoid bumping into the taskbar (which stretches across the screen’s bottom, from the Start button to the clock). The smallest permissible height is 405, which makes Form1 be just tall enough to hold its caption without any other text.

Drag method While the program is running, you can change Form1’s size by dragging its bottom right corner. That changes the size just temporarily: when you finish running the program (by clicking Form1’s X button), the computer forgets how you dragged Form1’s corner, and Form1 reverts to its previous size.

Here’s how to change Form1’s size so the computer remembers the new size:

Form position

Here’s how to adjust Form1’s position.…

Property-list method In the property list, click StartUpPosition then StartUpPosition’s down-arrow. You see a list of choices.

The computer assumes you want “3 — Windows Default”, which lets the computer use its own best judgment about where to put Form1 on the screen; the computer tends to put Form1 very close to the screen’s top left corner. If you wish, choose “2 — CenterScreen” instead, which will make Form1 be centered on the screen. Or if you wish, choose “0 — Manual” instead and then do this:

Afterwards, whenever you run the program (by pressing F5), Form1 will be positioned as you requested.

Drag method While the program is running, you can move Form1 by dragging its title bar (the blue horizontal bar that’s at Form1’s top and typically says “Form1”). That moves Form1 just temporarily; when you finish running the program (by clicking Form1’s X button), the computer forgets how you dragged Form1, and Form1 reverts to its previous position.

Here’s how to drag Form1 so the computer remembers how you dragged:

You’ve learned how to create and manipulate an object called “Form1”. You can create other kinds of objects also! Here’s how.…

Command button

Try this experiment. Exit from VB (by clicking its X button). Then go back into VB by doing this:

You see the Form1 window (which is blank). At the screen’s left edge, you should see this Toolbox:

                                Pointer                      Picture Box

                                   Label                      Text Box

                                  Frame                      Command Button

                          Check Box                      Option Button

                        Combo Box                      List Box

        Horizontal Scroll Bar                      Vertical Scroll Bar

                                   Timer                      Drive List Box

             Directory List Box                      File List Box

                                  Shape                      Line

                                  Image                      Data

                                     OLE

(If you accidentally erased it, make it reappear by clicking “View” then “Toolbox”.)

Each object in that Toolbox is called a tool. Double-click the Command Button tool. That makes a command button appear in the middle of Form1. The button is a rectangle and says “Command1” on it.

(If you wish, you can drag that button to a different place in Form1. You can also change the button’s size by dragging its 9 square handles. But for your first experiment, you just leave the command button where the computer put it.)

The command button says “Command1” on it. Just for fun, let’s make it say “Please click me” instead. To do that, click Caption (in the property list) and type “Please click me”, so the property list’s Caption line becomes:

That makes the command button’s caption become “Please click me”.

Notice that the property list concerns the command button and its caption (instead of Form1’s caption), because the command button is highlighted.

Let’s write a program so if a human clicks the command button (which says “Please click me”), Form1 will say “Thanks for the click”. To do that, double-click the command button. The double-clicking tells the computer you want to write a subroutine about that object (the command button).

The computer starts writing the subroutine for you. The computer writes:

Insert this line in the middle of the subroutine —

so the subroutine looks like this:

That subroutine tells the computer that when the Command1 button is clicked, the computer should print “Thanks for the click” onto Form1. (The computer knows it should print that onto Form1 rather than onto the command button, because the Print command applies just to forms, not to buttons.)

Then run the program (by pressing F5). You’ll see Form1 with a button on it that says “Please click me”. If you click the button, the subroutine makes Form1 say “Thanks for the click”. If you click the button again, the subroutine makes Form1 say “Thanks for the click” again, so Form1 says “Thanks for the click” twice, like this:

Click the button as often as you wish; each time, Form1 says “Thanks for the click” again. If you click the button many times, Form1 will eventually get filled up and won’t be able to show any more thanks. If that happens, make Form1 bigger temporarily, by clicking its maximize button, so you can see more thanks.

When you get tired of clicking, end the program by clicking Form1’s X button.

Two buttons Let’s write a program that has two command buttons! Let’s make the first button be called “Red” and the second button be called “Blue”. If the human clicks the “Red” button, let’s make Form1 turn red; if the human clicks the “Blue” button, let’s make Form1 turn blue.

To do all that, start a new program as follows:

You see the Form1 window (which is blank).

In the Toolbox, double-click the Command Button tool. A command button appears in Form1 and is called Command1. In the property list, click Caption then type “Click here for red”, so the property list’s Caption line becomes:

That makes the command button’s caption become “Click here for red”.

In the Toolbox, double-click the Command Button tool again. That makes another command button appear in Form1 and be called Command2. Unfortunately, the Command2 button covers up the Command1 button, so you can’t see the Command1 button. Drag the Command2 button out of the way (toward the right), so you can see both buttons side-by-side.

The Command2 button should be highlighted. (If it’s not highlighted, click it to make it highlighted.) In its property list, change its Caption from “Command2” to “Click here for blue”.

Now your screen shows Form1 with two buttons on it. The first button says “Click here for red”. The second button says “Click here for blue”.

Double-click the “Click here for red” button, and write this subroutine for it:

That subroutine says: clicking that button will make Form1’s background color be red.

Move that subroutine out of the way (by clicking its X button), so you can see Form1.

Double-click the “Click here for blue” button, and write this subroutine for it:

While you’re writing that subroutine, you’ll see the other subroutine above it.

Then run the program by pressing F5. Here’s what happens.…

You see Form1 with two buttons on it. The first button says “Click here for red”; if you click it, Form1 turns red. The other button says “Click here for blue”; if you click it, Form1 turns blue.

Try clicking one button, then the other. Click as often as you like. When you get tired of clicking, end the program (by clicking Form1’s X button).

Where to put command buttons A good habit is to put command buttons side-by-side, in Form1’s bottom right corner. That way, the buttons won’t interfere with the Print command or any other objects on Form1.

Exit button To stop running a typical program, you have to click its X button. Some humans don’t know to do that. To help them, create a command button called “Exit”, so that clicking it will make the computer exit from the program.

To do that, create an ordinary command button; but make the button’s caption say “Exit” (or anything else you prefer, such as “Quit” or “End” or “Abort” or “Click here to end the program”), and make the button’s subroutine say End, like this:

Put that Exit button in Form1’s bottom right corner.

Option button

You learned how to use the Command Button tool. The Option Button tool is similar. Here are the differences.…

A command button is a gray rectangle, with a caption inside the rectangle. An option button is a tiny white circle, with a caption to the right of the circle.

Although you can put command buttons and option buttons wherever you wish, it’s customary to arrange command buttons horizontally (so the second command button is to the right of the first) but arrange option buttons vertically (so the second option button is below the first). The option buttons (and their captions) form a vertical list of choices. Command buttons are best if you have just 1, 2, or 3 choices; option buttons are best if you have 4, 5, or 6 choices.

When the human starts running your program, the first option button (which is Option1) has a black dot inside the white circle, and the computer automatically does Option1’s subroutine (even if the human hasn’t clicked the Option1 button yet).

Afterwards, if the human clicks a different option button, the black dot moves to that option button and the computer does that button’s subroutine. At any given moment, just one of the option buttons contains the black dot.

If you’re annoyed that Option1 starts with a black dot inside it (and automatically gets its subroutine run), make Option1’s caption say “Nothing” or “Plain” or “Regular” and have no subroutine.

OK button When the human clicks an option button, the computer can react to the click immediately, but that might startle and upset the human. If you want to be gentler, delay the computer’s reaction until the human also clicks an OK button, which confirms the human’s desires.

To do that, make the option buttons have no subroutines, so nothing will happen when those buttons are clicked. In Form1’s bottom right corner, create a command button whose caption says “OK” and whose subroutine looks like this:

That subroutine says: when the OK button is clicked, notice which option button was clicked and react appropriately.

Here’s how to start typing that subroutine. Type the word “If”, then a space, then the word “Option”, then 1, then a period. After you’ve typed the period, the computer will show you a list of what can come after the period. From that list, choose “Value” by using one of these methods.…

Then type the rest of the subroutine.

Put the OK button in Form1’s bottom right corner.

Check box

A check box is a small white square, with a caption to the right of the square. At first, the white square has nothing inside it: the square is empty. While the program is running, clicking the square makes a check mark (_a) appear in the square. If you click it again, the check mark goes away.

To create a check box, double-click the Check Box tool. A check box appears in the middle of Form1. Drag the check box wherever you wish. The first check box’s caption is temporarily “Check1”; to change that caption, click Caption (in the property list) and type whatever caption you wish.

If you want the computer to react immediately to whether the check box is checked, give the check box this subroutine:

For example, this subroutine makes the computer print “I am dressed” if the check box is just became checked, but print “I am naked” if the check box just became empty:

When that program runs, the check box starts by being empty. Clicking the check box makes you see _a and makes the computer print “I am dressed”. The next time you click the check box, the _a disappears from the box, so the box becomes empty and the computer prints “I am naked”. Clicking the check box again makes the _a reappear and makes the computer print “I am dressed”.

Form1 can contain many check boxes. The human can check several at the same time, so that several of the boxes contain check marks simultaneously. That’s how check boxes differ from option buttons: the human can check several check boxes but must choose just one option button.

Like option buttons, check boxes are usually arranged vertically (so the second check box is below the first).

OK button If Form1 contains several check boxes, you should typically delay the computer’s reaction until the human has decided which boxes to check, has checked all the ones desired, and has clicked an OK button to confirm that the correct boxes are checked.

To do that, make the boxes have no subroutines. Instead, create an OK button in Form1’s bottom right corner (by creating a command button there and making its caption be “OK”), then make the OK button’s subroutine look like this:

That subroutine says: when the OK button is clicked, notice which check boxes are checked and react appropriately.

For example, let’s make the computer print “I love you” in whatever style the human chooses: “bold” or “italic” or “bold italic” or “regular” (neither bold nor italic). To do that, create a check box for “bold”, a check box for “italic”, and an OK button that looks at which boxes are checked and prints “I love you” in the desired style. Here’s how to do all that:

Label

A label is a sneaky command button. Here’s the best way to create one:

Here’s how a label differs from a command button.…

A command button is a rectangle that’s small, and you can clearly see its four sides. A label is a rectangle that you typically make bigger, and its four sides are invisible while the program is running.

A command button’s caption is short, centered in the button’s middle. A label’s caption is typically longer: if you make the label big, you can make the caption be quite long, containing many words. In a typical label, the caption is a whole paragraph.

If your paragraph doesn’t fit in your label, enlarge the label by dragging the label’s handles. Another way to make your paragraph fit in your label is to do this before typing the paragraph:

Printing to a label The Print command makes the computer start printing at Form1’s top left corner. If you want to print elsewhere on Form1, create Label1 where you want to print, then tell the computer to “print to Label1”. To “print to Label1”, tell the computer to “print to Label1’s caption”.

For example, suppose you want to print the answer to 4 + 2.

This Form1 subroutine prints the answer (which is 6) at Form1’s top left corner:

This Form1 subroutine prints the answer at Label1’s caption instead:

When writing that subroutine, make sure you say Label1.Caption, not just Caption. (If you accidentally say just Caption, that Form1 subroutine will print at Form1’s caption instead of Label1’s caption.)

That subroutine, if typed correctly, makes Label1’s caption say “6” instead of “Label1”, so you see 6 at Label1’s top left corner.

List box

A list box is a big white box that contains a list of choices, such as these color choices —

or these style choices —

or these country choices —

The list can be short (2 or 3 choices) or long (hundreds of choices). If the list is too long to fit in the box, the computer will automatically add scroll arrows so humans can scroll through the list.

To create a list box, double-click the List Box tool. A list box (big white box) appears in the middle of Form1. Drag the list box wherever you wish.

The first list box is called List1. Inside that list box, you temporarily see the word “List1”, but you should put your own list of choices there instead. Here’s how:

SingleSelect You can give List1 this kind of subroutine:

If you want the action to be delayed until the human clicks an OK button, do this:

MultiSelect If you want to let the human select several items from the list (instead of just one item), do this:

Label Next to your list box, you should put a message, explaining the list box’s purpose to the human.

To put the message there, you could use Print statements, but it’s hard to get Print statements to print in exactly the right spot (next to the list box). Here’s an easier way to put your message in the right spot: create a label (sneaky command button) whose caption is your message. Drag the label until it’s next to your list box. Give the label no subroutine, so clicking the label makes no difference.

Text box

You already learned that Form1’s subroutine can contain this line:

When you run the program, that line makes the computer create an input box. The input box is a pop-up window containing a message (“What is your name?”), a wide white box (in which the human types a response), and an OK button (which the human clicks when finished typing).

That technique works adequately but gives you no control: you have no control over the size or position of the window, the message, the white response box, or the OK button.

To be more professional, get control by creating a text box instead. Here’s how.

Double-click the Text Box tool. That creates a text box (a white box in which the human can type a response). Drag it wherever you wish. Adjust its size by dragging its handles.

The box’s interior temporarily says “Text1”. Make the box’s interior be blank instead, by doing this: in the property list, click Text then press the SPACE bar then the BACKSPACE key.

Above the box (or left of the box), create a label (sneaky command button) containing a message (such as “What is your name?”)

Below the box (or right of the box), create an OK button (a command button whose caption is “OK”). Make the OK button’s subroutine include this line —

and anything else you want the computer to do, such as:

Form1 can contain several text boxes. For example, you can include:

That makes Form1 be truly a form to fill in! Create just one OK button to handle all those text boxes, so the human clicks the OK button after filling in the entire form.

Password character If you want the human to type a password into a text box, do this: in the text box’s property list, click PasswordChar then type an asterisk (the symbol *). That makes the box show asterisks instead of the characters the human is typing. That prevents enemies from discovering the password by peeking over the human’s shoulder.

MultiLine Normally the text box is restricted to holding just one line of text. To let the text box handle several lines of text well, do this:

Combo box

A combo box is a fancy text box that includes a list of suggested responses.

To create a combo box, double-click the Combo Box tool. That creates a combo box. Like a text box, it’s a white box in which the human can type a response; but the combo box’s right edge shows a down-arrow, which the human can click to see a list of suggested responses.

Drag the combo box wherever you wish.

The box’s interior temporarily says “Combo1”. Make the box’s interior be blank instead, by doing this: in the property list, click Text then press the SPACE bar then the BACKSPACE key.

In the property list, click List then List’s down-arrow. Type your list of suggested responses; at the end of each suggested response, press Ctrl with ENTER, except that end the end of the final suggested response press just ENTER.

Make the combo box wide enough to hold the longest response (by dragging the combo box’s right handle).

Above (or left of) the combo box, create a label (sneaky command button) containing a prompt (an instruction to the human about what to put into the box).

Below (or right of) the combo box, create an OK button (a command button whose caption is “OK”). Make the OK button’s subroutine include this line —

and anything else you want the computer to do, such as:

3 kinds of combo boxes In Combo1’s property list, click Style then Style’s down-arrow. You see 3 styles:

Click whichever style you wish. If you don’t choose otherwise, the computer assumes you want “0 — Dropdown Combo”. That works as I described: the human can type anything into the box, and the suggestion list appear just if the human clicks the box’s down-arrow.

If you choose “1 — Simple Combo” instead, the human can still type anything into the box, and the suggestion list always appears (without requiring a down-arrow click) if you make the combo icon tall enough to hold the list.

If you choose “2 — Dropdown List” instead, the human cannot type into the box; the human is required to choose from the suggestion list, which appears when the human clicks the down-arrow. If the human tries typing a character (such as a letter of the alphabet or a digit) instead of clicking the down-arrow, the computer peeks in the suggestion list and chooses the first item beginning with that character.

Line

You can become an artistic programmer! For example, here’s how to draw a line on Form1.

Click the Line tool (just once). On Form1, drag from where you want the line’s beginning to where you want the line’s end. You can make the line be horizontal, vertical, or diagonal. The line is black.

Change the color Here’s how to make the line be more interesting than black. In the property list, click BorderColor then BorderColor’s down-arrow then Palette. You see 48 colors; click your favorite.

Shape

Here’s how to draw a rectangle on Form1.

Click the Shape tool (just once). On Form1, drag from where you want the rectangle’s top left corner to where you want the rectangle’s bottom right corner. The rectangle appears.

The rectangle itself consists of 4 black lines. The rectangle’s inside is gray (unless you changed Form1’s background color).

Change the colors Here’s how to make the rectangle’s 4 lines be more interesting than black:

Here’s how to make the rectangle’s inside be more interesting than gray:

Change the shape Here’s how to turn the rectangle into a different shape.

In the property list, click Shape then Shape’s down-arrow. You see this list of shapes:

From that list, click whichever shape you want.

Frame

A frame is a sophisticated rectangle. To create one, click the Frame tool (just once). On Form1, drag from where you want the frame’s top left corner to where you want the frame’s bottom right corner. The frame appears.

Here’s how the frame differs from a normal rectangle.…

In a normal rectangle, the 4 lines are black. In a frame, the 4 lines are created with a special effect that makes the lines look chiseled into your screen.

A normal rectangle has no caption. A frame does have a caption, which appears near the frame’s top left corner. For your first frame, which is called Frame1, the caption starts by saying “Frame1”. Here’s how to change the caption: in the property list, click Caption then type whatever words you want in the caption.

A frame protects its contents from outside influences. Here are two examples:

Horizontal scroll bar

The traditional way to let the human input a number is to create an InputBox or Text box. Here’s an alternative that’s more fun.…

Double-click the Horizontal Scroll Bar tool. A horizontal scroll bar appears in the middle of Form1. You can drag it wherever you wish and adjust its size (by dragging its handles). To see it better, I recommend that you widen it (by dragging its handles), so it’s always as wide as Form1.

The horizontal scroll bar consists of a left-arrow (which is on the left), a right-arrow (which is on the right), and a little square between them. The little square is called a slider. When you run the program (by pressing F5), the slider will blink, to encourage the human to slide it (by dragging it). The human can slide it to the right and back again to the left.

Go ahead: try it now! Create a horizontal scroll bar, run the program, and have fun sliding the slider!

Subroutine The horizontal scroll bar is called HScroll1. For your first experiment, give it this subroutine:

The computer has already typed the top and bottom lines, so type just the middle line. That subroutine says: whenever the human moves the slider (changes its position by dragging), print the slider’s value. (The value is 0 if the slider is at the far left, 32767 if the slider at the far right.)

Try it! Run the program, slide the slider, and see the computer print a number showing where you slid to.

Extreme positions If you don’t want the slider’s far-right position to be called “32767”, click Max (in HScroll1’s property list) and type a smaller number instead (such as 100). Try that now: make it 100!

If you don’t want the slider’s far-left position to be called “0”, click Min (in HScroll1’s property list) and type a different number instead (such as -100).

The Max and Min numbers must no bigger than 32767, no more negative than -32768, and have no decimal points.

Starting position The human can move the slider. Before the human moves the slider, the slider starts at position 0 (which is at the far left, unless you changed Min).

If you want the slider to start at a different position, click Value then type the number of where you want the slider to start (such as 50).

Arrows The slider is surrounded by a left-arrow and a right-arrow. The human can nudge the slider slightly to the left by clicking the left arrow, and slightly to the right by clicking the right-arrow. Clicking those arrows nudges the slider just slightly (1 position).

If you want those arrows to produce bigger nudges, click SmallChange (in the property list) and type a number bigger than 1. For example, type 10.

White rectangles The slider is also surrounded by white rectangles. The human can nudge the slider to the left by clicking the left white rectangle, and to the right by clicking the right white rectangle. Clicking those rectangles nudges the slider just slightly (1 position).

If you want those rectangles to produce bigger nudges, click LargeChange (in the property list) and type a number bigger than 1. It’s customary to make that number be bigger than SmallChange; for example, make Large Change be 50.

Variables Instead of saying Print HScroll1.Value, you can say:

That makes x become whatever number the slider’s position is. Afterwards, you can say Print x or, better yet, if you’ve created a Label, say:

Vertical scroll bar

The Vertical Scroll Bar tool resembles the Horizontal Scroll Bar tool but produces a scroll bar that’s vertical. Here are the details.…

Double click the Vertical Scroll Bar tool. A vertical scroll bar appears in the middle of Form1. It consists of an up-arrow (which is at the top), a down-arrow (which is at the bottom), and a slider (little square) between them. When you run the program, the human can slide the blinking slider down and back up again.

Subroutine The vertical scroll bar is called VScroll1. For your first experiment, give it this subroutine:

That subroutine says: whenever the human moves the slider (changes its position by dragging), print the slider’s value. (The value is 0 if the slider is at the top, 32767 if the slider is at the bottom.)

Extreme positions If you don’t want the slider’s top position to be called “0”, click Min (in VScroll1’s property list) and type a different number instead (such as 100). If you don’t want the slider’s bottom position to be called “32767”, click Max (in VScroll1’s property list) and type a different number instead (such as 0).

Arrows, white rectangles, and variables A vertical scroll bar handles these features in a fashion similar to a horizontal scroll bar.

Timer

Let’s make the computer print “I love you” repeatedly, so Form1 begins like this:

To make the computer repeat easily, use the Timer tool. Double-click it. A timer icon (which looks like a stopwatch) appears on Form1. (If that timer icon covers another icon, drag the timer icon out of the way.)

Subroutine Double-click the timer icon, then write a subroutine saying what activity to repeat, like this:

The computer has already typed the top and bottom lines, so type just the middle line.

Frequency interval Tell the computer how frequently to repeat that activity. To do that, click Interval (in Timer1’s property list) then type how many milliseconds the computer should wait before doing or repeating the activity. (A millisecond is a thousandth of a second.)

For example, if you want the computer to wait 1 second before printing the next “I love you”, type 1000 (since 1 second is 1000 milliseconds). If you want the computer to wait 2 seconds before printing the next “I love you”, type 2000. If you want the computer to wait just half a second before printing the next “I love you”, type 500.

You can type any number from 1 to 65535. If you type 1, the interval is 1 millisecond. If you type 65535, the interval is 65535 milliseconds, which is 65.535 seconds, which is slightly more than a minute.

Technical note:

For your first experiment, type 1000, so the computer waits 1 second before printing the next “I love you”.

Run the program (by pressing F5). The computer will wait 1 second, then print “I love you”, then wait 1 more second, then print another “I love you” underneath, then wait 1 more second, then print another “I love you” underneath, etc.

If you want the computer to wait a shorter interval (so each “I love you” comes faster), change the interval to less than 1000.

Run When you run the program (by pressing F5), the computer waits (for 1000 milliseconds or however long you said), then does the timer’s subroutine (which prints “I love you”), then pauses again, then prints again, the pauses again, then prints again, etc.

While the program is running, the timer icon does not appear on Form1: the timer icon is invisible. The timer icon is visible just while you’re designing the program, not while you’re running it.

Disable Let’s make the computer say —

then pause for 3 seconds, then give the joke’s punch line:

Here’s how.…

Start a new program. Make Form1’s subroutine say:

Create a timer icon. Give it an Interval of 3000, and make its subroutine say:

When you run that program, the computer will say “I love you”, then pause for 3 seconds, then say “except for your hair”. After another 3-second pause, it will say “except for your hair” again. It will keep saying “except for your hair” again and again, separated by 3-second pauses.

If you want the computer to say “except for your hair” just once, change the timer icon’s subroutine to this:

That makes the computer print “except for your hair” (after a 3-second interval) then disable the timer (so the timer gets turned off and doesn’t print any more).

Add Form

Besides Form1, you can create extra forms, called Form2, Form3, Form4, etc. To create an extra form, click the Add Form button (which is near the screen’s top, under the words “Edit” and “View”), then double-click the Form icon. To make that form act normally, click AutoRedraw then press the T key (which stands for True).

For example, let’s make a command button (on Form1) so that when you click that button, Form2 suddenly appears and says “I love you”. Here’s how.…

When you run the program (by pressing F5), you see Form1, which contains a command button captioned “Click me for a surprise”. If you click that button, the computer displays Form2, which covers Form1 and says “I love you”.

To stop running the program, close the Form2 window (by clicking its X button) then close the Form1 window (by clicking its X button).

 

 

 

 

 

 

 

You can create a menu.

Menu bar

At the top of Form1, let’s create this menu bar:

Let’s program the computer so clicking “Love” makes the computer print “I love you”, and clicking “Hate” makes the computer print “I hate you because you’re a human”.

Here’s how to accomplish all that.…

Create the menu bar Click the Menu Editor tool (which is near the screen’s top, under the word “Project”). Type the menu’s first word (“Love”), press the TAB key, type “mnu” and that word again (“mnuLove”), and press ENTER. Do the same for the second word: type “Hate” then press TAB then type “mnuHate”. If you did that correctly, you see this list of menu items:

Click OK.

At the top of Form1, you see the menu bar you created:

Congratulations! You created a menu!

Create menu subroutines Click “Love”, then write this subroutine telling the computer what to do if “Love” is clicked:

(The computer already typed the top and bottom lines for you, so type just the middle line.) When you finish typing that line, click the subroutine window’s X button.

Click “Hate”, then write this subroutine about clicking “Hate”:

Then click the subroutine window’s X button.

Run the program Go ahead: run the program (by pressing the F5 key). You see the menu bar you created:

Clicking “Love” makes the computer print “I love you”; clicking “Hate” makes the computer print “I hate you because you’re a human”.

Pull-down menu

Let’s expand the menu by adding “Color”, so the menu becomes this:

Let’s program the computer so clicking “Color” makes this pull-down menu appear under Color:

Let’s program so clicking one of those colors makes Form1’s background be that color.

Here’s how to accomplish all that.…

Create a new menu item If your program is still running, stop it (by clicking its X button). Close any subroutine window (by clicking its X button).

You see Form1.

Click the Menu Editor tool again. You see this list of menu items:

Add “Color” to that list. Here’s how: click under “Hate”, then click in the Caption box, then type “Color”. Press the TAB key, then type “mnuColor”, then press ENTER. If you did that correctly, you see this list of menu items:

Create a pull-down menu To create Color’s pull-down menu (saying “Yellow”, “Green”, and “Red”), make that list become:

Here’s how. Click “Æ” (which makes the computer create an indented list). Click in the Caption box, type “Yellow”, press TAB, type “mnuYellow”, then press ENTER. Do the same for “Red”: type “Red”, press TAB, then type “mnuRed”. If you did that correctly, you see:

Click OK.

Create menu subroutines At the top of Form1, you see the menu bar you created:

Click “Color”. You see Color’s pull-down menu:

Click “Yellow”, then write this subroutine about Yellow:

Then click the subroutine window’s X button.

Click “Color” then “Red”, then write this subroutine about Red:

Then click the subroutine window’s X button.

Run the program Go ahead: run the program (by pressing the F5 key). You see the menu bar you created:

Clicking “Color” makes the computer show Color’s pull-down menu; clicking the “Yellow” or “Red” makes Form1’s background turn that color.

Submenu

Let’s expand Color’s pull-down menu by adding “Gray”, so the menu becomes this:

Let’s program the computer so clicking “Gray” makes this submenu appear to the right of Gray:

Let’s program so clicking one of those shades of gray (“Light Gray” or “Dark Gray”) makes Form1’s background be that color.

Here’s how to accomplish all that.…

Create a new menu item If your program is still running, stop it (by clicking its X button). Close any subroutine window (by clicking its X button).

You see Form1.

Click the Menu Editor tool again. You see this list of menu items:

Add “Gray” to that list. Here’s how: click under “Red”, then click “Æ”, then click in the Caption box, then type “Gray”. Press the TAB key, then type “mnuGray”, then press ENTER. If you did that correctly, you see this list of menu items:

Create a submenu To create Gray’s submenu (saying “Light Gray” and “Dark Gray”), make that list become:

Here’s how. Click “Æ” (which makes the computer indent farther). Click in the Caption box, type “Light Gray”, press TAB, type “mnuLightGray” (without any space before “Gray”), then press ENTER. Do the same for “Dark Gray”: type “Dark Gray”, press TAB, then type “mnuDarkGray” (without any spaces). If you did that correctly, you see:

Click OK.

Create menu subroutines At the top of Form1, you see the menu bar you created:

Click “Color”. You see Color’s pull-down menu:

Next to “Gray”, the symbol “₈” means Gray has a submenu. Click “Gray”; you see this submenu:

Click “Light Gray”, then write this subroutine about it:

Then click the subroutine window’s X button.

Click “Color” then “Gray” then “Dark Gray”, then write this subroutine about it:

Then click the subroutine window’s X button.

Run the program Go ahead: run the program (by pressing the F5 key). You see the menu bar you created:

Clicking “Color” makes the computer show Color’s pull-down menu; clicking “Gray” makes the computer show Gray’s submenu; then clicking “Light Gray” or “Dark Gray” makes Form1’s background turn that color.

Rearranging menu items

After you’ve created a menu, here’s how to rearrange its items.…

Click the Menu Editor tool again. You see a list of menu items, like this:

To change one of those items, click it (so it’s highlighted in a blue band), then do one of these actions (using the buttons above the item):

You can create a 6-level menu:

Underlined letters

To be sophisticated, make the computer underline the first letter of each menu item, so when you run the program the menu toolbar looks like this —

and Color’s pull-down menu looks like this —

and Gray’s pull-down menu looks like this:

Here’s how to do all that: in the list of menu items, make each item begin with an ampersand (the symbol “&”), like this:

Do that by adding an ampersand into the Caption box (but not the Name box). For example, the first item’s Caption box should say &Love (but that item’s Name box should say just mnuLove, without an ampersand).

After you’ve done all that (so the letters are underlined), you can do this trick while the program runs:

Instead of tapping the Alt key, you can tap the F10 key, which does the same thing.

That whole method works just if, in each menu, all items begin with different letters. If two items in a menu begin with the same letter, rename one of the items or else underline a different letter. (To underline a different letter, put the ampersand before that letter. For example, to underline the v in “Love”, to produce “Love”, say “Lo&ve”.)

Keyboard shortcuts

In that program, choosing “Dark Gray” is tedious: you must click “Color” then “Gray” then “Dark Gray” (or tap Alt then C then G then D). Here’s how to create a keyboard shortcut, so that pressing Ctrl with D will choose “Dark Gray”.

Click the Menu Editor tool, so you see the list of menu items:

Click “&Dark Gray” then the Shortcut box’s down-arrow then “Ctrl+D”. That makes Ctrl+D be the shortcut for “Dark Gray”. While the program is running, you can choose “Dark Gray” by doing this (instead of choosing “Color” then “Gray” then “Dark Gray”): while holding down the Ctrl key, just tap the D key.

To teach humans that you made Ctrl+D be the shortcut for “Dark Gray”, the computer automatically writes “Ctrl+D” next to “Dark Gray” in the menu, so the Gray menu looks like this:

Using that same method, you can make Ctrl+L be the shortcut for “Light Gray”: in the list of menu items, click “&Light Gray” then the Shortcut box’s down-arrow then “Ctrl+L”. Then the Gray menu look like this:

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Here are VB’s nifty features. Enjoy!

Plotting

On Form1, the top left corner is called position (0, 0). If you start at the top left corner and go 1000 twips to the right and then 2000 twips down, you get to
position (1000, 2000).

In a subroutine, you can say:

That draws a diagonal line from position (0, 0) to position (1000, 2000). The line is black and thin. Try it!

Here’s a list of plotting commands you can give:

Besides vbRed, you can use other simple colors (vbYellow, vbBlue, vbGreen, vbBlack, vbWhite, vbCyan (which is a greenish blue), vbMagenta (which is a purplish red), or an RGB mix such as RGB(255, 127, 0), as explained on page 476, column 2.

Clear screen

In a subroutine, you can say:

That stands for “Clear screen”. It makes the computer erase everything that was written on Form1 by Print, Line, PSet, or Circle. (It does not erase Form1’s buttons or other objects.)

For example, suppose you create a command button whose subroutine says:

Clicking that command button will make Form1 say just “love” and erase all of Form1’s previous writings.

Tab

In a subroutine, you can say:

That makes the computer indent to the 6^th print position then print “hot”, like this:

Here’s a fancier example:

That makes the computer indent to the 6^th print position, then print “hot”, then skip to the 13^th print position, then print “buns”, like this:

How wide is a print position? That depends on what font you’re using. If you’re using Courier New, where each character has the same width, a print position is the width of one character. If you’re using MS Serif or Times New Roman or Ariel, the letter “W” is wider than “i”; a print position is defined to be “the width of the average character”, which in most fonts is the width of “J”.

Tab without a number If you say Tab without a number, the computer will do Tab(15) or Tab(15 + 14) or Tab(15 + 14 + 14) or Tab(15 + 14 + 14 + 14) or something similar.

For example, saying —

is the same as saying:

It prints:

Saying —

is the same as saying:

It prints:

Saying —

makes the computer skip to print position 15, then print “I love to eat hot”, then skip to print position 15 + 14 + 14 (since print position 15 + 14 has already been passed), then print “buns”, like this:

Comma Instead of saying Tab without a number, you can type just a comma (and omit the semicolons next to it). So instead of saying —

you can say:

These lines print a list of words and their opposites:

Each of those lines contains a comma, which makes the computer skip to the 15^th print position, so the computer prints this table:

Format a number

This program makes an ugly number look prettier:

The FormatNumber(27931.6) means “format the number 27931.6 so it looks like money”; it’s the string “27,931.60”. Notice that the computer inserts a comma (because the number is at least 1000) and puts 2 digits after the decimal point. The computer prints:

The computer prints just that. It does not put a blank space before or after the number.

Here’s another example:

The computer will round 8.739, to put just 2 digits after the decimal point and produce the string “8.74”. The computer will print:

Here’s how to make the computer print a million dollars:

The computer will print:

Problem: if you add $1.49 and $1.01, what’s the total? The answer is supposed to be $2.50. If you say —

The computer will print 2.5, which doesn’t look like money. If you say —

the computer will print:

How many digits? After the decimal point, how many digits do you want? The computer assumes you want 2 digits, unless you say otherwise.

For example, if you say —

the computer will put 5 digits after the decimal point and print:

If you say —

the computer will put no digits after the decimal point. It will print just:

Percent Instead of saying FormatNumber, you can say FormatPercent, which converts the number to a percent. To do so, FormatPercent multiplies the number by 100, then does FormatNumber tricks on it (to make the number look pretty and have 2 digits after the decimal point), then writes a percent sign.

For example, suppose you say:

The computer starts with .75 and converts it to a percent. To do that the computer multiplies .75 by 100 (to get 75), then makes the number look pretty (75.00), then writes a percent sign; so the computer prints:

If you say —

the computer will print:

If you say —

the computer will print no digits after the decimal point; it will print just:

Other countries I’ve been describing how FormatNumber and FormatPercent work in the United States. In other countries, it works differently, to adjust to how those countries handle money and other numbers.

To find out what country and language your computer is assuming, click Start then Settings then Control Panel, then double-click Regional Settings, then click Number for further details.

If you’re sharing the computer with colleagues, do not change those Regional Settings unless you get their permission!

Here’s how to make the computer repeat.

Do…Loop

The computer can be religious. Just make Form1’s subroutine say this:

When you run the program, the computer shows a message box saying “I worship your feet” and waits for the human to click OK. Then the computer shows a message box saying “But please wash them” (and waits for the human to click OK again).

To make the computer do the lines many times, say “Do” above the lines and say “Loop” below them, so the subroutine looks like this:

Notice the lines being repeated (the MsgBox lines) should be between the words Do and Loop and indented. (To indent a line, press the TAB key at the line’s beginning. To unindent a line, click the line’s beginning then press the BACKSPACE key.)

Run the program (by pressing the F5 key). The computer says “I worship your feet” (and waits for the human to click OK), then says “But please wash them” (and waits for OK), then goes back and says “I worship your feet” again (and waits for OK), then says “But please wash them” again (and waits for OK), then goes back and says the same stuff again, and again, and again, and again, forever.

Since the computer’s thinking keeps circling back to the same lines, the computer is said to be in a loop. In that subroutine, the Do means “do what’s underneath and indented”; the Loop means “loop back and do it again”. The lines that say Do and Loop — and the lines between them — form a loop, which is called a Do loop.

The computer does that loop repeatedly, forever — or until you abort the program by doing this: while holding down the Ctrl key, tap the PAUSE/BREAK key, which is the last key in the top row. That makes the computer stop running your program; it will break out of your program; it will
abort your program. Then click the End button (which is a blue square near the screen’s top, just under the words “Tools” and “Add-Ins”).

In that program, since the computer tries to go round and round the loop forever, the loop is called infinite. The only way to stop an infinite loop is to abort it.

Warning: the PAUSE/BREAK key does not work with .exe files. If a program contains an infinite loop, do not turn it into an .exe file. If you make the mistake of turning this program into an .exe file (by choosing “Make .exe” from the File menu), you’ll have created a nasty program that refuses to stop and even refuses to let the typical computer “Shut Down”: it won’t stop until you turn the computer’s power off.

GoTo

Instead of typing —

you can type:

The top line (named joe) makes the computer say “I worship your feet”. The next line makes the computer say “But please wash them”. The bottom line makes the computer Go back To the line named joe, so the computer forms a loop. The computer will loop forever — or until you press Ctrl with PAUSE/BREAK.

You can give a line a short name (such as joe) or a long name (such as BeginningOfMyFavoriteLoop). Put the name at the beginning of the line. After the name, put a colon (the symbol “:”).

The line’s name (such as joe or BeginningOfMyFavorite Loop) is called the line’s label.

Skip ahead Did you ever dream about having a picnic in the woods? These lines express that dream:

They make the computer print:

Let’s turn that dream into a nightmare where we all become giant termites. To do that, insert the shaded items:

The computer begins by printing “Let’s munch”. Then the computer does GoTo conclusion, which makes the computer Go skip down To the conclusion line, which prints “the trees!”. So the program makes the computer print just this:

Is GoTo too powerful? Saying GoTo gives you great power: if you make the computer GoTo an earlier line, you’ll create a loop; if you make the computer GoTo a later line, the computer will skip over several lines of your program.

Since saying GoTo is so powerful, programmers are afraid to say it. Programmers know that the slightest error in saying GoTo will make a program act very bizarre! Programmers feel more comfortable using milder words instead (such as Do…Loop), which are safer and rarely get botched up. since saying GoTo is scary, many computer teachers prohibit students from using it, and many companies fire programmers who say GoTo instead of Do…Loop.

But saying GoTo is fine when you’ve learned how to control the power! Though I’ll usually say Do…Loop instead of GoTo, I’ll say GoTo in certain situations where saying Do…Loop would be awkward.

Exiting a Do loop

Let’s create a guessing game, where the human tries to guess the computer’s favorite color, which is pink. To do that, say GoTo or Exit Do or Loop Until. Here’s how.…

GoTo Just makeForm1’s subroutine say this:

The top line (which is called AskTheHuman) asks the human to guess the computer’s favorite color.

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

But if the guess is not pink, the computer will instead say “No, that’s not my favorite color” and then Go back To AskTheHuman again to guess the computer’s favorite color.

Exit Do Here’s how to write that subroutine without saying GoTo:

The Do loop makes the computer do this repeatedly: ask “What’s my favorite color?” and then say “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:

The 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:

For…Next

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

To do that, put these lines into Form1’s subroutine:

The top line (For x = 1 To 12) says that x will be every number from 1 to 12; so x will be 1, then 2, then 3, etc. The line underneath is indented (by pressing the TAB key) and says what to do about each x: it says to Print each x.

Whenever you write a subroutine 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 12.

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 4:

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. For example, 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 10, like this:

To do that, type this line —

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

Print the squares as a table Let’s make the computer print the squares more beautifully, to form this table:

Here’s how:

The top line prints the word “Number” at the top of the first column, and the word “Square” at the top of the second. (Those words are called the column headings.) The For line says i goes from 3 to 10; to begin, i is 3. The indented line makes the computer print:

The bottom line makes the computer do the same thing for the next i, and for the next i, and for the next; so the computer prints the whole table.

Count how many copies This program prints “love” a dozen times:

Here’s a poem:

This program prints 4 copies of that poem, onto 4 sheets of paper:

The Printer.EndDoc makes the printer eject the paper.

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

When you run that program, the computer asks:

If you answer 5 (and click the OK button), the n becomes 5 (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.

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.

The computer can do fancy calculations.

Exponents

In Form1’s subroutine, try giving this command:

To type the symbol ^, do this: while holding down the SHIFT key, tap this key:

^ 6

That symbol (^) is called a caret.

In that line, the “4 ^ 3” makes the computer use the number 4, three times. The computer will multiply together those three 4’s, like this: 4 times 4 times 4. Since
“4 times 4 times 4” is 64, the computer will print 64.

In the expression “4 ^ 3”, the 4 is called the base; the 3 is called the exponent.

Here’s another example:

The “10 ^ 6” makes the computer use the number 10, six times. The computer will multiply together those six 10’s (like this:
10 times 10 times 10 times 10 times 10 times 10) and print the answer, 1000000.

Here’s another example:

The “3 ^ 2” makes the computer use the number 3, two times. The computer will multiply together those two 3’s (like this:
3 times 3) and print the answer, 9.

Order of operations The symbols +, -, *, /, and ^ are all called operations.

To solve a problem, the computer uses the three-step process taught in algebra and the “new math”. For example, suppose you say:

The computer will not begin by subtracting 3 from 70; instead, it will use the three-step process:

In each step, it looks from left to right. For example, in step 2, it sees / and gets rid of it before it sees *.

Speed Though exponents are fun, the computer handles them slowly. For example, the computer handles 3 ^ 2 slower than 3 * 3. So for fast calculations, say 3 * 3 instead of 3 ^ 2.

Square roots What positive number, when multiplied by itself, gives 9? The answer is 3, because 3 times itself is 9.

3 squared is 9. 3 is called the square root of 9.

To make the computer deduce the square root of 9, type this:

The computer will print 3.

When you tell the computer to Print Sqr(9), make sure you put the parentheses around the 9.

The symbol Sqr is called a function. The number in parentheses (9) is called the function’s input (or argument or parameter). The answer, which is 3, is called the function’s output (or value).

Sqr(9) gives the same answer as 9 ^ .5. The computer handles Sqr(9) faster than 9 ^ .5.

Cube roots What number, when multiplied by itself and then multiplied by itself again, gives 64? The answer is 4, because 4 times 4 times 4 is 64. The answer (4) is called the cube root of 64.

Here’s how to make the computer find the cube root of 64:

The computer will print 4.

Stripping

 Sometimes the computer prints too much info: you wish the computer would print less, to save yourself the agony of reading excess info irrelevant to your needs. Whenever the computer prints too much info about a numerical answer, use Abs, Fix, Int, Round, or Sgn.

Abs, Fix, Int, Round, and Sgn are all called stripping functions or strippers or diet functions or diet pills, because they strip away the number’s excess fat and reveal just the fundamentals that interest you.

 

 

 

 

 

 

 

 

 

 

 

 

 

Here’s how to make your program consume less RAM and run faster: before you use a variable (such as x), tell the computer what type of data the x will stand for, by giving one of these 11 commands:

For example, suppose you want x to be 52. Before saying
“x = 52”, tell the computer what type of data the x will be. Since x will be a number between 0 and 255, say “Dim x As Byte”, so your subroutine looks like this:

According to the chart’s top line, saying “Dim x As Byte” lets x consume just 1 byte of RAM. The computer can store 52 (or any whole number up to 255) in just 1 byte of RAM, because the computer stores the number by using a special trick called binary representation.

If you neglect to say “Dim x As Byte”, the computer doesn’t know what type of data the x will stand for, so the computer makes x be a Variant variable, which can hold anything but consumes more RAM: at least 16 bytes. Saying “Dim x As Byte” lets the program consume less RAM and run faster, since the computer can handle shorter data faster.

Details

Here are more details about those 11 commands.…

Byte A Byte is a number from 0 to 255, without a decimal point. Here’s an example:

The first line says x is a Byte. The next line says x is 52. The bottom line makes the computer print:

A Byte cannot have a decimal point. For example, if you try to say —

the computer will round 52.9 to 53, so x will be 53, and the computer will print:

A Byte cannot be bigger than 255. If you say “Dim x As Byte” and then try to say “x = 256”, the computer will gripe by saying this when you run the program:

The computer will give that same gripe if you try to say “x = -1”, since a Byte cannot be a negative number.

Integer An Integer is a number from 0 to 32767, with maybe a negative sign in front, but without a decimal point. For example, these numbers can all be Integer:

Technical note: although 32768 is slightly too big to be an Integer, -32768 is a special number that can be an Integer, though it’s rarely used.

If you say “Dim x As Integer” and then try to say “x = 52.9”, the computer will round 52.9 to 53, so x will be 53.

Long A Long is a number from 0 to 2147483647, with maybe a negative sign in front, but without a decimal point. For example, these numbers can all be Longs:

Technical note: although 2147483648 is slightly too big to be a Long, -2147483648 is a special number that can be a Long, though it’s rarely used.

If you say “Dim x As Long” and then try to say “x = 52.9”, the computer will round 52.9 to 53, so x will be 53.

Currency A Currency is a number from 0 to 922337203685477.5807, with at most 4 digits after the decimal point, and maybe with a negative sign. For example, these numbers can all be Currency:

Technical note: although 922337203685477.5808 is slightly too big to be a Currency, -922337203685477.5808 is a special number that can be a Currency, though it’s rarely used.

If you say “Dim x As Currency” and then try to say “x = 8.14529”, the computer will make x be 8.1453.

You can use Currency to handle dollars-and-cents variables (such as Price or HourlyWage or Profit), other variables that needs a decimal point followed by 1, 2, 3, or 4 digits, and other variable that needs to handle numbers in the trillions.

Single A Single is a number from 0 to 3E38 (which is a “3 followed by 38 zeros”, which is 300000000000000000000000000000000000000), with maybe a negative sign and a decimal point. After the decimal point, you can have as many digits as you wish. For example, these numbers can all be Single:

The computer manages to store a Single rather briefly (just 4 bytes) by “cheating”: the computer stores the number just approximately, to an accuracy of about 7 significant digits.

For example, if you say —

the computer will print 7 digits:

If you say —

the computer will round to 7 digits and print:

When handling Single variables, the computer can give inaccurate results. The inaccuracy is especially noticeable if you do a subtraction where the two numbers nearly equal each other. For example, if you say —

the computer will make x be approximately 8000.1, so y will be approximately .1. The Print line will print:

Notice that the last few digits are wrong! That’s the drawback of Single: you can’t trust the last few digits of the answer! Single is accurate enough for most scientists, engineers, and statisticians, since they realize all measurements of the real world are just approximations; but Single is not good enough for accountants, who fret over every penny. Single’s errors drive accountants bananas. For accounting problems that involve decimals, use Currency instead of Single, since Currency is always accurate, though slower.

Technical notes:

Double A Double is similar to a Single but can include more digits, since the computer uses 8 bytes for it instead of 4 bytes. It’s more accurate than a Single but still can make tiny errors (unlike Currency, which is always correct but limited to 4 digits after the decimal point). Here are the details about Double.…

A Double is a number from 0 to 1E308, with maybe a negative sign and a decimal point. After the decimal point, you can have as many digits as you wish. The computer stores the number just approximately, to an accuracy of about 15 significant digits.

For example, if you say —

the computer will print 15 digits:

If you say —

the computer will make x be approximately 8000.1, so y will be approximately .1. The Print line will print:

Notice that the last few digits are wrong. In this example about subtracting 8000 from 8000.1, the answer produced by Double is slightly wrong but closer to the truth than the answer produced by Single. If you insist on a completely correct answer, say Currency instead.

Technical notes:

Boolean A Boolean is either the word True or the word False. Here’s an example:

The computer will print:

Here’s another example:

The computer will print:

Technical notes:

Date A Date is a date with time. For example, these lines make x be December 31, 2005, at 30 seconds after 11:59 PM:

Notice you must put the symbol # before and after the date-with-time. The computer will print:

For the year, you can pick 2005 or 1999 or 1776 or 1492 or even earlier. You can pick any year from 100 (which was shortly after Christ) to 9999 (which is many centuries from now). If you type a 2-digit year, the computer will put “20” before your typing, to make a 4-digit year (unless your 2-digit year is at least 30, in which case the computer will put “19” before your typing instead).

You can omit any part of the date-and-time that doesn’t interest you. For example, if you don’t care about the seconds, leave them out. If you don’t care about the time-of-day, leave it out and type just the date; if you don’t care about the date, leave it out and type just the time of day.

The computer makes assumptions:

To avoid pissing off people who don’t like those assumptions, the Print command avoids printing 12:00:00 AM and avoids printing 12/30/1899. For example, if you leave out the time of day and type this —

x will be #12/31/2005 12:00:00 AM# but the Print command will print just:

If you say —

the computer will make x be the current date-with-time. For example, if the computer encounters that line while running the program on December 31, 2005 (at 30.16 seconds after 11:59 PM), x will become #12/31/2005 11:59:30 PM#. Instead of saying x = Now, you can say other things:

Object An Object is Form1 or Command1 or any other VB object.

For example, suppose you created a button called Command1. If you put this line in Form1’s subroutine, Command1’s caption will become “Click here for a joke”:

These lines do the same thing:

Notice that to make x equal an Object, you must say Set.

String A String is a collection of characters, such as “joy” or “I love you” or “aieee luf ya” or “76 trombones” or “GO AWAY!!!” or “xypw exr///746”. Here’s an example:

The computer will print:

Since the string “joy” contains 3 characters, x consumes 3 bytes of RAM — plus 10 bytes to remember how long the string is. So altogether, x consumes 13 bytes of RAM.

Instead of saying “Dim x As String”, you can be more helpful by saying:

That says x will always be a string of 3 characters, so the computer doesn’t need to wonder how many characters x will have and doesn’t need to devote 10 bytes to that question. The x will consume 3 bytes of RAM, not 13.

If you say “Dim x As String * 3” and then try to say x = “father”, the computer will shorten “father” to 3 characters, so x will be “fat”. If you say “Dim x As String * 3” and then try to say x = “he”, the computer will lengthen “he” to 3 characters, so x will be h then e then a blank space.

If you say “Dim x As String * 3”, x will be a string of 3 characters and consume 3 bytes of RAM. If you say “Dim x As String * 4”,x will be a string of 4 characters and consume 4 bytes of RAM. The biggest string length you can specify is “Dim x As String 65526”.

If you say just “Dim x As String”, without putting a number after “String”, the computer will keep track of how long x is and consume as many bytes as needed for x — plus 10 extra bytes for remembering x’s length. For example, if x is “joy”, x will consume 3 bytes, plus 10 bytes for remembering x’s length, so x will consume 13 bytes of RAM altogether. If you say just “Dim x As String”, without putting a number after “String”, x can be a string up to 2 billion characters long.

If you say “Dim x As String” and try to say “x = 9 + 3.5”, the computer will try to make x be 12.5 but must turn x into a string, so x will become the string “12.5” (without any blank spaces).

Variant If you say —

you’re being purposely vague: you’re saying that x could be anything (a Byte or Integer or Long or Currency or Single or Double or Boolean or Date or Object or String). For example, if you say “Dim x As Variant”, you can say x = 5000 and later change x by saying x = “joy”.

Saying “Dim x As Variant” is the same as saying just “Dim x” or saying nothing at all about x! That forces the computer to figure out, by itself, without human help, what kind of data x is. Such thinking will consume RAM:

Multiple variables

If you want x to be a Byte, y to be a String, and price to be a Currency, say this —

or say this:

If you want x and y to both be Integers, say:

or say this:

Do not say just “Dim x, y As Integer”, which means “Dim x As Variant, y As Integer”.

Suffix

The normal way to make x be a String is to say:

An alternative way to make x be a String is to put a dollar sign after the x, so that you always write x$ instead of x. The dollar sign is called a suffix (or type-declaration character).

Here are the suffixes you can use:

Constants

Your subroutine can mention variables (such as x and y), commands (such as Print and If), operators (such as + and -), and constants (such as 3.7 and “I love you”).

You’ve learned that a variable (such as x) can have 11 types: Byte, Integer, Long, Currency, Single, Double, Boolean, Date, Object, String, or Variant. Each constant can have a type also. Here’s how the computer tells a constant’s type:

A constant cannot be a Variant, since is constant has a specific value but a Variant is vague.

VarType

Each type of constant has a code number:

If you say Print VarType, the computer will examine a constant and tell you its code number. For example, if you say —

the computer will examine 4.95@, realize it’s a Currency, and print Currency’s code number, which is:

Here are more examples:

VarType of a variable If you say Print VarType(x), the computer will notice what type of variable x is and print its code number. For example, if you say —

the computer will print Currency’s code number, which is 6.

There is no code number for Variant. If x is a Variant, the computer will try to print the code number of x’s value. For example, if x is a Variant and you say —

the computer will print Currency’s code number, which is 6.

If x is a Variant but doesn’t have a value yet, Print VarType(x) will print 0.

TypeName

If you say TypeName instead of VarType, the computer will say the type’s name instead of its code number.

For example, if you say —

the computer will say:

Instead of saying “Object”, the computer will try to be more specific. For example, if you created a command button called Command1 and say —

the computer will say:

If x is a Variant but doesn’t have a value yet, Print TypeName(x) will print:

Operations

When you do math operations (add, subtract, multiply, divide, or exponents), here’s what kind of answer you get.

Exponents When you do exponents (using the symbol “^”), the answer is a Double.

Division When you divide one number by another (using the symbol “/”), here’s what happens:

Add, subtract multiply When you add, subtract, or multiply numbers (using the symbol + or - or *), here’s what happens:

But if such an answer would produce an Overflow error (because the answer is too high a number to fit in that type), the computer switches the answer to a higher type: it switches Byte to Integer, switches Integer to Long, and switches Long (or Single) to Double. Another exception: if one number is a Single and the other number is a Long, the answer is a Double.

Adding strings You can add two Strings together: “hot” + “dog” is “hotdog”. That can be called “shoving the strings together”, but programmers call it “concatenating the strings”.

To avoid confusion and also make your program run faster, Microsoft recommends concatenating by using the symbol & instead of +, so you write:

For example, you can say —

or say:

Date arithmetic You can start with a Date and then add or subtract a number of days. For example, adding 1 means “the next day”, so that #12/29/2005# + 1 is #12/30/2005#.

Adding .25 means “a quarter of a day” (which is 6 hours), so that #12/29/2005 3PM# + .25 is #12/29/2005 9PM#. Another way to add 6 hours is to add #6:00#. Similarly, you can add 10 minutes by adding #0:10#.

(When you’ve typed such stuff and press the ENTER key afterwards, the computer will annoy you by changing #6:00# to #6:00:00 AM# and changing #0:10# to #12:10:00 AM#, but don’t worry: the computer will still print correct answers.)

General declarations

Normally, each subroutine has its own variables. For example, if Form1’s subroutine uses a variable called x, and Command1’s subroutine uses a variable that’s also called x, Form1’s x has nothing to do with Command1’s x. Form1’s x is stored in a different part of RAM from Command1’s x. If Form1 says x = 5, Command1’s x remains unaffected by that statement.

To prove that, try this experiment:

If you want Form1’s x to be the same as Command1’s x and use the same RAM, say “Dim x” in your program’s general declarations. Here’s how.…

Get Form1’s subroutine onto the screen. Above that subroutine, you see a box saying “Form”. Click that box’s down-arrow, then click “(General)”. Then type “Dim x” (or something more specific, such as “Dim x As Integer”).

By saying “Dim x” in your program’s general declarations (instead of in a subroutine), you’re saying that x has general scope (the x applies to all subroutines instead of just a single subroutine).

Def If you want all variables to be Integer, say —

Put that line into your program’s general declarations. Here’s how.…

Get Form1’s subroutine onto the screen. Above that subroutine, you see a box saying “Form”. Click that box’s down-arrow, then click “(General)”, then type:

Here are similar statements you can give:

If you want most variables to be Integer but want price to be a Currency, say “DefInt A-Z” in your program’s general declarations but say “Dim price As Currency” underneath (in the general declarations or in whichever subroutine uses price).

Conversion functions

In the middle of a calculation, you can convert to a different type of data by using these conversion functions:

For example, CInt(3.9) is “3.9 converted to the nearest Integer”, which is 4. If you say —

the computer will print:

If you say —

the computer will print:

Arrays

To make x be a list of 3 items, say:

That says x is a list of 3 items. The 3 items are called x(1), x(2), and x(3).

For example, try making Form1’s subroutine say this:

The top line says x is a list of 3 items. The lines below say x’s first item is the number 7.9, x’s second item is the string “I love you”, and x’s third item is the first item(7.9) minus 5.9, so it’s 2. The Print line line makes the computer print x’s second item (which is “I love you”) then x’s third item (which is 2), so the computer will print:

Instead of saying x(1) = 7.9, math books say:

The lowered 1 is called a subscript.

In that example, the x is called an array. Definition: an array is a variable that has subscripts.

To make x be a list of 10 items, say:

To make x be a list of 1000 items, say:

To make x be a list of a million items, say:

To make x to be a list of 10 items and make each item be a String, say:

To make x be a list of a million Integers, say:

Since each Integer consumes 2 bytes, that list of a million Integers consumes 2 million bytes, which is 2 megabytes. That’s much less RAM than saying just Dim x(1000000), which would create a list of a million Variants, at 16 bytes per Variant, 16 megabytes total.

Love and hate Let’s make x be this list of 7 strings: “love”, “hate”, “kiss”, “kill”, “peace”, “war”, “why”.

To do that, begin Form1’s subroutine by saying:

That says x’s first item is “love”, x’s second item is “hate”, etc.

To make the computer to print all those items, say:

That means: print all the items in x. The computer will print:

Let’s lengthen the subroutine, so the computer prints all this:

That consists of two verses. The second verse resembles the first verse, except that each line of the second verse begins with “why”.

To make the computer print all that, just add the shaded lines to the subroutine:

The shaded Print line leaves a blank line between the first verse and the second verse. The shaded For…Next loop, which prints the second verse, resembles the For…Next loop that printed the first verse but prints “why” before each x(i).

Let’s add a third verse, which prints the words in reverse order:

Before printing that third verse, print a blank line:

Then print the verse itself. To print the verse, you must print x(7), then print x(6), then print x(5), etc. To do that you could say:

But this way is shorter:

Tables Let’s make x be this table of Strings:

To do that, begin by saying:

That says x will be a table having 2 rows and 3 columns of Strings.

Then tell the computer what Strings are in x. Type these lines:

That says the String in x’s first row and first column is “dog”, the String in x’s first row and second column is “cat”, etc.

If you’d like the computer to print all those Strings, type this:

That means: print all the items in x. The computer will print:

Most programmers follow this tradition: the row’s number is called i, and the column’s number is called j. That example obeys that tradition. The “For i = 1 To 2” means “for both rows”; the “For j = 1 To 3” means “for all 3 columns”.

Notice i comes before j in the alphabet; i comes before j in x(i, j); and “For i” comes before “For j”. If you follow the i-before-j tradition, you’ll make fewer errors.

At the end of the first Print line, the comma makes the computer print each column at its own tab stop. The other Print line makes the computer press the ENTER key at the end of each row. The x is called a table or 2-dimensional array or doubly subscripted array.

Usually, the computer is predictable: it does exactly what you say. But sometimes, you want the computer to be unpredictable.

For example, if you’re going to play a game of cards with the computer and tell the computer to deal, you want the cards dealt to be unpredictable. If the cards were predictable — if you could figure out exactly which cards you and the computer would be dealt — the game would be boring.

In many other games too, you want the computer to be unpredictable, to “surprise” you. Without an element of surprise, the game would be boring.

Being unpredictable increases the pleasure you derive from games — and from art. To make the computer act artistic, and create a new original masterpiece that’s a “work of art”, you need a way to make the computer get a “flash of inspiration”. Flashes of inspiration aren’t predictable: they’re surprises.

Here’s how to make the computer act unpredictably.…

Rnd is a RaNDom decimal (bigger than 0 and less than 1) whose data type is Single. For example, it might be .6273649 or .9241587 or .2632801. Every time your program mentions Rnd, the computer concocts another decimal:

The computer prints:

The first time your program mentions Rnd, the computer chooses its favorite decimal, which is .7055475. Each succeeding time your program mentions Rnd, the computer uses the previous decimal to concoct a new one. It uses .7055475 to concoct .533424, which it uses to concoct .5795186. The process by which the computer concocts each new decimal from the previous one is weird enough so we humans cannot detect any pattern.

How to print many decimals

These lines print 16 decimals:

Some of those decimals are numbers that end in “E-02”, which means “move the decimal point to the left, 2 places”.

These lines print 50 decimals:

The top line maximizes the window. To see all 50 decimals, your screen’s resolution must be at least 1024-by-768.

Here’s how to print 50 rows of decimals, 2 decimals per row, 100 decimals total:

Here’s how to print 50 rows of decimals, 10 decimals per row, 500 decimals total:

Percentages

When you print a list of decimals, about half the decimals will be less than .5, and about half will be more than .5.

Most of the decimals will be less than .9. In fact, about 90% will be.

About 36% of the decimals will be less than .36; 59% will be less than .59; 99% will be less than .99; 2% will be less than .02; a quarter of them will be less than .25; etc.

You might see some decimal twice, though most of the decimals will be different from each other.

Randomize

If you run one of those programs again, you’ll get exactly the same list of decimals again, in the same order.

If you’d rather see a different list of decimals, say Randomize at the subroutine’s top:

When the computer sees Randomize, the computer looks at the clock and manipulates the time’s digits to produce the first value of Rnd.

So the first value of Rnd will be a number that depends on the time of day, instead of the usual .7055475. Since the first value of Rnd will be different than usual, so will the second, and so will the rest of the list.

Every time you run the program, the clock will be different, so the first value of Rnd will be different, so the whole list will be different — unless you run the program at exactly the same time the next day, when the clock is the same. But since the clock is accurate to a tiny fraction of a second, the chance of hitting the same time is extremely unlikely.

Coin flipping

Here’s how to make the computer flip a coin:

The Randomize line makes the value of Rnd depend on the click. The If line says there’s a 50% chance that the computer will print “heads”; if the computer does not print “heads”, it will print “tails”.

Until you run the program, you won’t know which way the coin will flip; the choice is random. Each time you run the program, the computer will flip the coin again; each time, the outcome is unpredictable. Try running it several times!

Love or hate?

Who loves ya, baby? These lines try to answer that question:

The Randomize line makes the value of Rnd depend on the clock. The InputBox line makes the computer wait for the human to type a name. Suppose he types Suzy. Then x is “Suzy”. The If line says there’s a 67% chance that the computer will print “Suzy loves you, too”, but there’s a 33% chance the computer will instead print “Suzy hates your guts”.

Try running the program several times. Each time, input a different person’s name. Find out which people love you and which people hate your guts — according to the computer!

Random integers

If you want a random integer from 1 to 100, ask for 1 + Int(Rnd * 100). Here’s why:

Guessing game These lines play a guessing game:

The second line makes the computer say “I’m thinking of a number from 1 to 10.” The next line makes the computer think of a random number from 1 to 10. The InputBox line asks the human to guess the number.

If the guess is less than the computer’s number, the first If line makes the computer say “Your guess is too low” and then GoTo AskHuman, which lets the human guess again. If the guess is greater than the computer’s number, the second If line makes the computer say “Your guess is too high” and then GoTo AskHuman.

When the human guesses correctly, the computer arrives at the bottom line, which prints:

Dice These lines make the computer roll a pair of dice:

The second line makes the computer say:

Each of the dice has 6 sides. The next line, a = 1 + Int(Rnd * 6), rolls one of the dice, by picking a number from 1 to 6. The line saying “b = 1 + Int(Rnd * 6)” rolls the other. The bottom line prints the total.

Here’s a sample run:

Here’s another run:

Daily horoscope These lines predict what will happen to you today:

Those lines make x be a list of 5 fortunes. Since 1 + Int(Rnd * 5) is a random integer from 1 to 5, the x(1 + Int(Rnd * 5)) is a randomly chosen fortune. The computer will print —

or —

or some in-between comment.

For inspiration, run that program when you get up in the morning. Then notice whether your day turns out the way the computer predicts!

Here’s a simple Form1 subroutine:

It makes the computer print this message onto your screen:

Instead of printing that message onto your screen, let’s make the computer print the message onto your disk. Here’s how.…

Open For Output

This Form1 subroutine prints the message onto your hard disk, instead of onto your screen:

Those Print lines make the computer print the message onto your hard disk instead of onto your screen. Each line says Print #1, which means: print onto the hard disk.

The Open line is an introductory line that tells the computer where on the hard disk to print the message. The Open line says: find a blank place on the hard disk, call it joan.txt, and make joan.txt be file #1. So Print #1 will mean: print onto file #1, which is joan.txt.

(Instead of joan.txt, you can invent any other filename that ends in .txt.)

Any program that says Open should also say Close, so the bottom line says Close. The Close line makes the computer put some “finishing touches” on joan.txt, so that joan.txt becomes a perfect, finished file.

When you run that program, the computer will automatically put onto the hard disk a file called joan.txt that contains this message:

After running that program, try this experiment:

Open For Input

To see the message that’s in joan.txt, run this subroutine, which inputs from joan.txt and prints onto your screen:

The Open line prepares the computer to input from joan.txt.

The next line inputs x from joan.txt, so x is “eat”. The next line prints “eat” onto your screen’s Form1.

The next pair of lines input y from joan.txt (so y is 4) and print 4 onto Form1. The next pair of lines input z from joan.txt (so z is “eggs”) and print “eggs” onto Form1. So altogether, on your screen’s Form1 you’ll see:

The Close line tells the computer that you’re done using joan.txt for a while (until you say Open again).

Open For Append

After you’ve put joan.txt onto the disk (so that joan.txt consists of “eat” and 4 and “eggs”), try running this subroutine:

In the Open line, the word Append tells the computer to keep adding onto joan.txt. So when the computer comes to the Print line, it adds “good morning!” onto joan.txt, and joan.txt becomes this:

Erasing

For your next experiment, try running this program:

Since the Open line does not say Append, the computer will not keep adding onto joan.txt. Instead, the computer erases everything that’s been in joan.txt. So when the computer finishes processing the Open line, joan.txt has become blank.

The Print line puts “pickles are pleasant” into joan.txt. So at the end of the program, joan.txt includes “pickles are pleasant” (but not “eat”, 4, “eggs”, and “good morning!”, which have all been erased).

Output, Input, Append

In the Open line, you can say Output or Input or Append. Here’s how they differ:

Here’s what happens if you say Open “joan.txt” and the file joan.txt exists already:

Here’s what happens if you say Open “joan.txt” when joan.txt doesn’t exist yet:

The following subroutine plays a trick: if joan.txt doesn’t exist yet, the subroutine creates joan.txt; if joan.txt exists already, the subroutine leaves joan.txt alone.

Loops

This subroutine lets you put the names of all your friends onto the hard disk:

Here’s how it works:

This subroutine makes the computer look at the friends.txt file and copy all its names to your screen:

Here’s how it works:

As that subroutine illustrates, to read from a file you create a Do loop. Above the loop, say Open for Input; below the loop, say Close; in the loop, say Input #1; next to the Do, say Until EOF(1).

LOF

In the middle of your subroutine, if you say Print LOF(1), the computer will tell you the Length Of the File: it will tell you how many bytes are in the file.

Multiple files

If you want the computer to handle two files simultaneously, use two Open statements.

How to Close

The Close statement closes all files. To be more specific, you can say Close 1 (which closes just the first file) or Close 2 (which closes just the second).

Whenever you’re done using a file, Close it immediately. When you say Close, the computer puts finishing touches on the file that protect the file against damage.

Suppose that halfway through your program, you finish using file 2 but want to continue using file 1. Say Close 2 there, and delay saying Close 1 until later.

Long text

Let’s program the computer to give the human a big white box, let the human type an essay into the box, and then copy the essay to the hard disk.

Create a text box (by double-clicking the Text Box tool). Enlarge it (by dragging its handles), until it’s nearly as large as Form1 (but leave a blank inch to the right of it, for an OK button). Make it be blank (by pressing the SPACE bar then the BACKSPACE key). Make it be MultiLine (by clicking MultLine then pressing T). Give it scroll bars (by clicking ScrollBars then the ScrollBars down-arrow then “2 - Vertical”).

Below the text box, put an OK button. Here’s how:

Make the OK button’s subroutine say this:

Then run the program (by pressing F5). Click in the big white box. Type your essay there. (At the end of each paragraph, press ENTER twice.) When you’ve finished typing your essay, click the OK button. That makes the computer do the OK button’s subroutine (which copies your text to a file called “essay.txt” then ends the program).

To prove that the program worked, do this:

In your VB program, the OK button copies from the text box to essay.txt. Let’s add a Retrieve button that copies in the opposite direction, from essay.txt to the text box. To do that, create another command button, put it to the right of the OK button, make its caption be Retrieve, and make its subroutine say this:

The Open line makes the computer find “essay.txt”. The Do Until EOF(1) line makes the computer repeat the loop until the computer reaches the end of the file essay.txt. The Line Input command makes the computer input a whole line from essay.txt (even if the line contains commas), and makes that line be called x. The next line makes the text box’s text become whatever was in the text box before, plus the line x, plus a carriage return and line feed (to mark the end of the line).