This book is more than the usual computer disk and text combination. The book that you now hold contains a working copy of Microsoft's Visual Basic 4, a complete Windows programming development system. Along with the Visual Basic 4 Working Model, you get a fantastic (if I may say so myself) introduction text for programming in the Visual Basic environment. In addition to Visual Basic and this text, you also get every program listed in this book on the enclosed CD-ROM, so you can spend less time typing and more time learning.
If you have programmed in other languages, hold on to your hats—Visual Basic is unlike other programming languages. The primary difference is that Visual Basic is fun to work with. The word fun simply does not apply to many other programming languages. With Visual Basic, you create most of your programs by clicking and moving your mouse. Instead of writing programs, you build programs. Visual Basic is one of the few programming tools with which you can efficiently design your program while you create it.
This unit describes what programming is all about. You will learn a little about the history of programming, especially the movement of BASIC through computer history. (Visual Basic finds its roots in the more traditional BASIC language.) Get ready to learn how Visual Basic streamlines your programming life.
Note: This unit spends a lot of time describing the background and importance of programming and the early programming languages. This background serves two purposes. First, by learning about the history of programming, you will have a better idea where today's programming tools are headed. Second, you will appreciate more fully the incredible power, ease, and versatility that Visual Basic offers over other programming languages. Visual Basic's capabilities were beyond anyone's imagination just a few years ago.
Concept: If you want your computer to do exactly what you want it to do, you must write a program.
A computer does nothing on its own. In fact, a computer is a dumb machine with no intelligence whatsoever. Despite what you might read in science fiction stories, a computer does nothing more than blindly follow instructions supplied by a programmer. Computers cannot think.
Definition—A program is a set of instructions that tells the computer exactly what to do.
When someone buys a computer today, the computer sits on the desk doing nothing until he or she loads a program into the computer's internal memory and starts running the program. Just as a VCR does not record shows on its own without being programmed to do so, a computer requires detailed instructions to do something. The computer finds those detailed instructions in programs that you and others write.
Suppose that you own rental properties and want to use your computer to track your tenant records. Your computer will not help you out in any way until you load and run a rental property program. Where do you find such a program? There are two ways to obtain programs for computers. You can
Buy one and hope that the program does exactly what you want it to do.
Write your own program.
It's much easier and faster to buy a program that you need instead of taking the time to write a program. Thousands of programs are on the market today. In fact, there are so many programs out there that you might not see the need for writing your own programs.
If you can find a program that does exactly what you want, you are ahead of the game. If you find a program that meets your exact requirements, you should buy that program because purchasing a program is often less expensive and much quicker than writing the same program yourself or hiring programmers to write it for you.
Think about this for a moment, though: If there are so many programs sold today that do virtually everything, why are programming languages such as Visual Basic continuing to break previous sales records each year? The answer is simple: People buy a computer so that the computer will do jobs that they need to have done. Firms cannot adapt their business to computer programs. They must find programs, or write their own programs, so that the computer processes information according to the business procedures already in place. The only way to ensure that a program exactly fits the needs of a firm is for the firm to develop its own programs.
Business people are not the only ones who need custom-designed programs. No two people manage their finances exactly the same way; no two scientists need computers for exactly the same kinds of computations; and no two graphic artists need the same kinds of computer drawing tools. Although people buy spreadsheets and word processors for their general-purpose computing needs, many people require specialized programs for specific jobs.
The art of programming computers is rewarding not only from a requirements standpoint, but also on a more personal level. Programming computers is fun! Just as a sculptor looks on a finished work of clay, programmers are often proud of the programs that they write. By the time you finish this book, you will have written programs that were not available before you wrote them. When you want your computer to do something specific and you cannot find a program that does the job exactly the way you want, you will be able to design and write the program yourself.
Some Programs are Changeable: There is a third method for getting exactly the program that you need if you want to computerize your company's accounting records. Accounting software firms often sell not only accounting programs but also the source code for those programs. This source code is a human-readable listing of the program's instructions. By having access to the source code, you can take what the software company wrote and modify the behavior of the program to suit your own requirements.
By starting with a functional program instead of starting from scratch, you save programming time and money. Sadly, most non-accounting software firms do not supply source code with their software. Most programs sold today have been compiled. After compiling, the source code is translated into a locked-in executable program. The bottom line is that you cannot easily change the behavior of compiled programs. For most programs, therefore, you have the choice of buying them or writing them yourself from scratch.
Definition—Code is another name for program.
There are many ways to write programs for computers. In the next section, you'll learn how the process of entering programs progressed from switches on the front of the computer to clicking and pointing with the mouse today. The majority of programs now in use are supplied in the form of code listings, which often comprise pages of line after line of computer instructions. Visual Basic helps take the drudgery out of coding—that is, writing—programs. Visual Basic enables you to move elements and place graphical images on the screen with the mouse instead of requiring that you give written and detailed screen instructions as required by languages that came before Visual Basic.
Tip: For a complete description of the programming process, a comprehensive overview of programming languages, and a guided tour through the business of programming, check out Absolute Beginner's Guide to Programming (Sams Publishing, 1993).
Tip: No single program pleases everyone. When a company sells a program, it must be general enough to please most purchasers. Some people need programs to behave in a specific manner in order to fulfill a specific need. They must resort to writing their own programs. Luckily, Visual Basic takes a lot of the pain out of writing programs.
Concept: Computers cannot understand just any language. You must learn a language that your computer knows before you can write programs for your computer.
Definition—An application is yet another name for program.
Many people use computers all day long for word processing, database storage, and spreadsheet analysis, without realizing what is going on behind the scenes. You must always keep in mind that computers cannot think. Your computer does not know how to be a word processor. If you want your computer to do word processing, you must supply detailed instructions in the form of a program. Only by following the detailed instructions of a word processor program that you load can your computer perform word processing.
It would be nice if writing a program were as easy as telling the computer what you want done. Many people can handle ambiguous instructions, but computers are not smart enough to understand vague requirements. Computers can only follow orders given to them, and you must supply those orders in the form of a program. Therefore, you must supply the programs that you write. Writing programs, especially complex programs, takes time and several procedural steps. Visual Basic speeds the process of creating programs, but even with Visual Basic some programs take time to write and perfect.
Definition—A bug is a program error.
Figure 1.1 shows you the typical steps that most programmers go through when writing programs. First, you have an idea for a program. Once you have an idea for a program, or once someone comes to you with an idea or a need for a program, spend some time thinking through the major components and parts of the program. Decide the overall goals of the program. Will the program produce reports? Will the program calculate values? Think about some of the major components of your program from a high-level perspective. Next, you use a program-development system, such as Visual Basic, to write the program. Errors, or bugs, often appear in programs because of the details needed for even the simplest of programs. Therefore, you must test the program thoroughly and fix the errors. Fixing errors is called debugging. Once all the errors are out of the program, you have a finished application.
Figure 1.1. Writing a program involves several steps.
The second step, writing the source code, is the most tedious part of programming. Remember that the source code is the actual programming instructions that the computer is to follow. You will spend most of your programming time working on the source code so that you end up with a program whose instructions direct the computer in the way that you want.
There are many ways to write the source code for programs. Although today's computers are more powerful than earlier machines in terms of memory capacity and speed, today's computers are no smarter than the very first computer was. In the late 1940s, programmers had to write programs for those early computers just as today's programmers must do. The difference lies in the way today's programmers write programs. Today's programming tools—Visual Basic is a shining example—are far more powerful. They enable you to develop programs more powerful than before and with less effort on your part.
The very early computers were not programmed through keyboards and mice. As a matter of fact, the first few computers did not even have keyboards! The first computers had to be programmed by routing wires from component to component. Instead of programmers, electrical engineers programmed the early computers.
Those hard-wired programming methods were simply too tedious to be productive. If a different calculation was needed, somebody would have to rewire the computer. Programmers had to have electrical and engineering experience just to make a computer do something. There had to be a way to speed up the process.
Those early computers had memory similar to the way in which today's computers have memory. The difference is that the early memory was minuscule—even the largest computers had only a few hundred memory locations for data storage. Despite the short supply of memory, one of the computer experts of the time developed the idea of using the memory to hold both data and the code that instructed the computer on a task. Until that point, the "code" consisted of the hard-wired circuitry.
Tip: By putting the computer's instructions inside the memory along with data, the computer programs were easier to change because the programmer could s change the memory contents. Engineers were no longer required to rewire computers every time programs needed changing.
The computer scientists put a panel of switches on those early computers. Figure 1.2 shows a simple representation of those switches. The programmers would flip the switches into a series of unique On and Off states, press the Enter button, and repeat the process until a series of instructions that looked like the following "program" appeared in the program memory:
On Off On On Off Off Off On Off On On Off On On Off Off Off Off Off On On Off On Off On On On On Off Off Off On Off Off On Off Off On On Off On On Off On On Off Off On Off Off On Off On On On Off
Definition—The original On-and-Off programming was called machine language.
Figure 1.2. The switch panel eliminated the hard wiring.
Although this On-and-Off program is virtually indecipherable, each combination of On and Off switches represents a single instruction. By combining several instructions that operated on data located elsewhere in the machine's memory, a complicated thirty-instruction program might not do anything more than multiply two numbers! Despite the difficulties involved, such a lightning-fast calculation would have been unheard of before those computers. The military immediately began using computers for trajectories and other calculations.
Tip: By seeing the short history of programming, you will really appreciate what Visual Basic can do when you start using Visual Basic for your programs.
The world of computers began moving forward with the switch panel. More memory was added, and the programs got more powerful. Sometime in the late 1940s, somebody got the bright idea of replacing the switch panel with a typewriter-like keyboard. Instead of assigning On and Off combinations to mean Add and Store, programmers could actually type the words Add and Store on the keyboard. The computer would analyze the instruction, look up the On and Off combinations needed, and set the memory switches internally.
Machine Language is Dead!—Long Live Machine Language!
Luckily, you do not have to write programs in the On-and-Off machine language anymore. The computer languages today are much closer to spoken speech than On and Off switches can ever hope to be. Even so, today's most powerful computers, programmed with advanced programming tools such as Visual Basic, still recognize only machine language.
People do not like machine language because it is too difficult to use. Computers do not like anything else. The job of all programming languages is to take the source code that you type in a programming language and to convert it to machine language so that the computer can execute those instructions.
Once programmers got hold of keyboards, there was no stopping them. The languages grew from the primitive On-and-Off system to higher-level languages that read more like spoken text. Listing 1.1 shows an example of a short FORTRAN program from the early days of these high-level languages. Although this FORTRAN program will be cryptic to you, the more textual approach to programming, as opposed to On and Off switches, opened doors for more people to become programmers. The software industry blossomed in the 1950s, and programs went from simple calculating tools to complete business and scientific applications.
Note: FORTRAN stands for FORmula TRANslator. It is used primarily in mathematical and scientific programming. Although FORTRAN was one of the earliest high-level programming languages, many computer installations still use FORTRAN programs today. Much of the Visual Basic language was founded in principles of the early FORTRAN language.
Listing 1.1. An early FORTRAN program.
WRITE (6, 10)
10 FORMAT('** Payroll Calculations **')
WRITE (6, 11)
11 FORMAT('** Enter the employee's ID, hours, and pay rate')
TAXRAT = 0.25
101 READ(5, 102, END=900) IDEMP, HRSWRK, RATE
102 FORMAT(I5, 1X, I3, F5.2)
IF (HRSWRK .GT. 40) GOTO 300
*******COMPUTE REGULAR PAY
GRSPAY = HRSWRK * RATE
GOTO 500
300 OVRHRS = HRSWRK - 40
*******COMPUTE OVERTIME PAY
OTGRS = OVRHRS * RATE * 1.5
GRSPAY = 40.0 * RATE + OTGRS
500 TAXES = GRSPAY * TAXRAT
PAYNET = GRSPAY - TAXES
WRITE (6,503) IDEMP, PAYNET
503 FORMAT('EMP: ', I3, 2X, 'NET PAY: ', F6.2)
GOTO 101
*******END-OF-JOB PROCESSING
900 END
If you are unfamiliar with FORTRAN programs or with programming in any other language, you probably will not understand much of what you see in Listing 1.1. You might, however, be able to tell from some of the words, that the code performs payroll calculations of some kind. It is true that FORTRAN does not produce extremely readable code, but the commands such as IF, GOTO, and WRITE, improved programmer productivity greatly over what programmers had to do before such languages came along.
With high-level languages such as FORTRAN, the 1950s and 1960s saw an incredible distribution of new software. Programming became more accessible to more people because of the easier-to-use programming languages. The increased number of programs brought a tremendous increase in the number of computers sold. Companies, laboratories, and universities purchased computers. There was no turning back the computer era once so many people had access to so much computing power. As computer companies sold more computers, competition produced less expensive and more powerful machines. And you thought that the 1990s were exciting!
Definition—Syntax refers to the spelling and grammar of languages.
Even though programming languages were easier to learn, people still needed easier programming methods. Some Dartmouth College professors decided to write an easier programming language based on FORTRAN but with fewer details than FORTRAN required. Those professors developed BASIC, the language that enabled students to write programs because of its easier format and less restrictive syntax than FORTRAN's.
Note: BASIC is an acronym for Beginner's All-purpose Symbolic Instruction Code. The acronym's meaning is almost as long as—and much more difficult to remember than—the BASIC language itself.
Listing 1.2 shows the BASIC equivalent of the FORTRAN program that you saw in Listing 1.1. To programming newcomers, this BASIC listing might not be significantly easier to understand than the FORTRAN code. Nevertheless, the BASIC language is a little cleaner and slightly less cryptic than its FORTRAN predecessor. Although programming still took effort, BASIC took some of the rough edges off programming, and it brought more people to the programming craft.
Listing 1.2. A BASIC program.
10 PRINT "** Payroll Calculations **" 20 PRINT "** Enter the employee's ID, hours, and pay rate" 30 TAXRAT = .25 40 INPUT IDEMP$, HRSWRK, RATE 50 IF (IDEMP$ = "END") THEN GOTO 160 60 IF (HRSWRK > 40) GOTO 70 70 REM *******COMPUTE REGULAR PAY 80 GRSPAY = HRSWRK * RATE 90 GOTO 120 100 OVRHRS = HRSWRK - 40 110 REM *******COMPUTE OVERTIME PAY 120 OTGRS = OVRHRS * RATE * 1.5 130 GRSPAY = 40 * RATE + OTGRS 140 TAXES = GRSPAY * TAXRAT 150 PAYNET = GRSPAY - TAXES 160 PRINT "EMP: "; IDEMP$; "NET PAY: "; PAYNET 170 GOTO 20 180 END
Well into the 1980s, the rate at which the number of programmers grew remained high. Despite all new programmers, the programming tools themselves really did not advance much. Many people developed new programming languages. Despite their "new and improved" claims, most of the languages retained the textual procedural quality that FORTRAN and BASIC offered.
Large-scale programming tool improvements did not occur until a hardware breakthrough occurred: NASA's space efforts developed the microchip, and microcomputers were born. Now, instead of new and potential programmers, desktop computers opened the door for millions of would-be programmers. These programmers demanded easier programming tools.
Definition—QBasic is a recent BASIC language clone.
Efforts were made to improve the friendliness of programming languages like BASIC. New versions of BASIC, such as QBasic, enabled programmers to write more powerful programs with less effort. Programmers could also write programs that had a less rigid style than earlier programs. Listing 1.3 shows a QBasic version of the payroll calculation shown in the previous two listings. As you can see, the language is getting less strict and more free-form.
Listing 1.3. A QBasic program.
TaxRate = .25 PRINT "** Payroll Calculations **" PRINT "** Enter the employee's ID, hours, and pay rate" INPUT IdOfEmp$, HrsWorked, Rate DO UNTIL (IdOfEmp$ = "END") IF (HrsWorked <= 40) THEN ' *******Compute regular pay GrossPay = HrsWorked * Rate ELSE ' *******Compute overtime pay OverTimeHours = HrsWorked - 40 OverTimeGross = OverTimeHours * Rate * 1.5 GrossPay = 40 * Rate + OverTimeGross END IF Taxes = GrossPay * TaxRate PayNet = GrossPay - Taxes PRINT "Emp: "; IdOfEmp$; "Net Pay: "; PayNet INPUT IdOfEmp$, HrsWorked, Rate LOOP END
Definition—Computers generate output on screens and printers.
Just as a recipe has a result, the cooked meal, instructions in a program produce an important result. The result of the programming effort is the finished program that makes the computer perform a directed task, such as payroll processing. After entering a program or loading a program from the disk, you must tell the computer to run, or execute, the program. The computer then follows the program's instructions and produces the output.
If you entered the code in Listing 1.3 into the QBasic programming language, the following output might result:
** Payroll Calculations ** ** Enter the employee's ID, hours, and pay rate ? KL823, 40, 9.25 Emp: KL823 Net Pay: 277.5 ? PO341, 35, 10 Emp: PO341 Net Pay: 262.5 ? LP543, 40, 10 Emp: LP543 Net Pay: 300 ? END, 0, 0
Note: The previous QBasic code requires that the user tell the program that there are no more employees to process by typing END as an employee ID and zero amounts for the hours and pay rate.
Tip: This output would be different if the user entered different data, because the program would calculate different payroll results.
Definition—Input is the data that the user enters.
As you can see from the execution of this program, the program takes the user's input and calculates net pay amounts. Input can come from sources other than the user. Programs might get input from a disk file, a modem connected to the telephone, or from other programs running along with yours. Users do not always see the output, either. Programs often perform calculations and data manipulation and send the output of that processing to disk files or to other computers over modem lines.
Figure 1.3 illustrates the program flow from writing the program to generating output, such as the payroll output you see here.
Figure 1.3. The program's instructions produce the output.
Note: The output you get after typing with a word processor would be the text on paper or on the screen. The output from other programs might be as diverse as payroll reports, calculations, or graphics. The program's instructions determine what the program produces.
Bugs are as frustrating in computer programs as they are in computer programmer's houses. Rarely will a program that you write work the first time you run it. There are two kinds of errors: Syntax errors—sounds like "sin tax"—and logic errors. Because you do not know the Visual Basic programming language yet, this simple phrase demonstrates the two kinds of errors that can appear in your code:
There are two errrors in this sentence.
What are the two errors? I'll wait...
The first error, a syntax error, is easy to spot. errrors is misspelled. As you now know, misspellings always trigger syntax errors. The sentence's logic error takes more time to find. The logic error is that the sentence is logically untrue; there is only one error, the syntax error errrors, not two.
When you begin to write programs, this example sentence may come back to haunt you a bit. Syntax errors are easy to catch because Visual Basic catches all of them for you. In other words, if you type Tezt when Visual Basic expects you to type Text, Visual Basic immediately displays an error message box in the center of your screen. Visual Basic is extremely stubborn when it comes to syntax errors because it refuses to execute your program until you remove all the syntax errors in the code.
When you make a logic error, however, Visual Basic cannot help you out. For example, if you were writing a payroll calculation routine and accidentally subtracted $50 from everybody's paycheck, Visual Basic has no way of knowing that you should not subtract that amount. If you tell Visual Basic to subtract the amount—using correct syntax, of course—Visual Basic subtracts the amount. Only until your employees beat your door down will you know that a logic error took place.
Tip: Thoroughly test your programs before you distribute them or use them for important work. Run the program using all combinations of input to find and correct as many logic errors as possible.
Definition—GUI stands for Graphical User Interface.
A challenging programming problem arose when advanced GUI visual environments, such as Microsoft Windows, appeared in the 1980s. GUI environments require more advanced and difficult programming efforts than text-based computing environments. Although users and programmers wanted easier tools, GUI environments demanded more complex programming tools.
Definition—An event can be a Windows mouse click, a key press, a menu selection, or an internal Windows activity.
It is relatively easy to produce the text-based output shown earlier. It is much more difficult to produce Windows-like screens such as the one shown in Figure 1.4. The user does not have to enter the ID, hours worked, and amounts in any preset order. Neither does the user have to press the three command buttons at the right of the screen in any order. In Windows programs, a specific event determines the next course of action. A Windows program is called an event-driven program as opposed to a text-based procedural program. In Windows, the user determines what happens next by triggering an event to which the Visual Basic program responds.
Figure 1.4. Users randomly control event-driven programs.
Review: Computer programming has progressed a long way from the wiring panels of the early days. Once keyboards were added, what programmers could do grew by leaps and bounds. Actually, it was not until the development of Visual Basic that another great leap in programming tools arrived. The power of programs that you can create with Visual Basic, given the simplicity of Visual Basic's environment, produces as much computer programming advantage today as the keyboard provided over the switch panel. As Yogi Berra once said, "It ain't bragging if it's true!"
Concept: As Windows programming tools are developed, their complexity seems to increase. The Microsoft Windows environment requires much more complicated programming efforts than DOS-based non-Windows programs require. Visual Basic bucks the trend by providing a simple approach to writing Windows programs while retaining all the beginning and advanced programming language instructions found in QBasic.
Definition—Text-based programs are often called procedural programs.
Procedural languages such as FORTRAN and QBasic simply don't work well for GUI environments. The problem—actually, the primary advantage for users—of GUIs is the event-driven processing explained in the previous section. The user does not always do the same thing in the same order. That is, a user might want to select from a pull-down menu, click a mouse button, type text, or compute a mathematical answer, and might do those tasks in virtually any order. Text-based procedural programming languages essentially required that the program dictate the order of the user's actions. Windows requires a different approach. The traditional programming languages cannot handle the GUI approach well at all.
It is possible to write event-driven programs in procedural languages. The majority of Windows programs in use today were written in the C language, a procedural language more similar in style to FORTRAN than to Visual Basic, although C and FORTRAN differ greatly in their approach and syntax. Nevertheless, C programmers face great challenges when using C for Windows programs because languages such as C are procedural, whereas Windows is event-driven.
Several powerful programming solutions have been devised that aid Windows programmers. A relatively new programming concept called object-oriented programming (or OOP for short) better lends itself to Windows-like event-driven programming than languages such as FORTRAN, BASIC, or C. Even OOP, however, puts a strain on its programmers that today's busy and backlogged programming departments do not have the resources to handle.
The big problem is that as computers get easier for users by supplying graphical environments such as Windows, the programs that the users use become harder to develop. Therefore, as the demand for these GUI programs increases, so does the backlog of programs that need to be written.
Microsoft introduced a new programming language, Visual Basic, a few years ago. The advantages of Visual Basic became immediately apparent. They are
The great thing about Visual Basic is that the program looks almost exactly like the output screen that results. In other words, to design and write the simple program that produced Figure 1.3, you would place text, buttons, and lines onto the screen, using the visual tools supplied with Visual Basic, until your "program" looked like what you wanted your finished Windows program to look like. Such placement of visual elements would take pages and pages of typed instructions using a traditional procedural programming language.
Note: After the success of Visual Basic for Windows, Microsoft developed Visual Basic for DOS. Visual Basic for DOS found extremely limited success, however, and is now extinct.
Beginning with Visual Basic 4.0, Microsoft changed the Visual Basic language somewhat to conform to an emerging language standard called Visual Basic for Applications, or VBA for short. Many Microsoft applications, such as Excel and Project, includes VBA. Although VBA was not completely compatible with pre-4.0 Visual Basic versions, VBA was virtually compatible with Visual Basic and Visual Basic formed the genesis for VBA's specifics.
This book's course comes with a special version of Visual Basic called the Visual Basic Working Model. Although the Visual Basic Working Model does contain a few limitations described in the next unit, the Visual Basic Working Model is virtually identical with Visual Basic 4.0. Therefore, when you use Visual Basic Working Model to write programs, those programs will be able to interact with other Microsoft applications that use the VBA language, such as Microsoft Excel. When developing Visual Basic 4.0, Microsoft understood the need for complete compatibility between its Visual Basic versions.
Before you can learn to program with Visual Basic, you must get a feel for the tool itself. The second half of this lesson, Unit 2, introduces you to Visual Basic. You will learn how to install the Visual Basic disk that comes with this book, start Visual Basic, and manipulate the screens of Visual Basic. Once you master the mechanics of Visual Basic, the second lesson dives right into programming by walking you through your first fully functional Visual Basic application from design to execution.
Visual Basic is Event-Driven and Procedural: Don't think that the days of program listings are gone forever. As a matter of fact, one of the most important components of Visual Basic is its procedural BASIC-like programming language underneath the visual environment. When you begin to extend your Visual Basic programming by developing more powerful programs, you will need to combine the visual elements of the language with the QBasic-like routines.
Note: There are several versions of the Windows environment. Perhaps you use Windows 3.1, Windows for Workgroups 3.11, Windows 95, or Windows NT. The Visual Basic system that comes with this book, the Visual Basic 4 Working Model, works inside the Windows 95 and Windows NT environments. (These environments are known as 32-bit environments due to their internal architecture.) If you use Windows 3.1 or Windows for Workgroups, you'll want to use the Visual Basic Primer Edition that comes packaged with Visual Basic in 12 Easy Lessons or in the Visual Basic Starter Kit.
Warning: This unit ends here without describing the details of Visual Basic because Visual Basic's details are the rest of this book's job. Now that you have a fundamental grasp of programming and the Windows programming challenges, you are ready to begin a rewarding tutorial of Visual Basic. In twelve easy lessons, you will be a Visual Basic master!
Review: In many ways, writing programs the old-fashioned way—that is, writing page after page of text instructions that the computer will eventually follow—is somewhat like a long and arduous recipe. The cook starts at the first instruction in the recipe and must be careful not to skip steps. Such listings are vital, and although the recipe might throw in a picture or two, the cook must follow the recipe sequentially if the finished meal is to taste good.
Writing programs with Visual Basic is much more akin to using a VCR than following a step-by-step recipe. In all fairness, though, even the most complicated of VCRs are easier to program than complex Visual Basic applications. Visual Basic, though, is still one of the easiest and fastest tools you can find to develop Windows applications.
Note: Most of the parts in this book end with a Review as well as a Stop & Type section, which enables you to reinforce the section's topics with a hands-on programming exercise. The primary purpose of this first unit has been to teach you the basics of programming from a historical perspective. Therefore, there are no hands-on topics for this unit.
Note: Because this unit was descriptive, it contains no What's the Output?, Find the Bug, or Write Code That... sections.
