QuickBasic
Jason Mallory
CSC 415: Programming Languages
Dr. Lyle
November 16, 2011
Development
QuickBasic was the precursor to Visual Basic and its development was based on
GW-Basic ("QuickBasic." ). First released in 1985, it was sold only on 5.25” floppy disk,
despite 3.5” drives replacing the older hardware. Version 2, released in ’86, introduced
the IDE that would persist until the final release, QuickBasic 4.5, that hit the market in
1988 (Perry, Z).
QBasic, a subset of QuickBasic, was distributed with versions of DOS 5.0 and
later, which replaced GW-Basic that had been shipped previously. QuickBasic
expanded upon GW-Basic by adding newer features like user defined data types,
control structures, better graphics support and an integrated compiler. ("QuickBasic.")
QuickBasic, despite being nearly 3 decades old and that it has not been
supported for almost as long, still sees use today. Within the hobbyist programming
communities, it is still being used to create simple games, software for small personal
businesses and as of late, it has been used to allow machines as old as the 8088 to be
networked ("QuickBasic.").
Data Types
QuickBasic data types included strings, integers, long integers, single precision,
double precision, and user defined data types. Variables could be declared in one of
two ways. You could use either DIM name AS type or you could append the variable
name with a symbol to declare its type when it was initialized. The symbols used were $
for strings, % for integers, & for long integers, ! for single precision, and # for double
precision. Given that QuickBasic did not have a character data type, strings were a data
type of its own rather than being an array of characters like many other languages.
Arrays have to be declared using the dim method and appending the variable name with
the dimensions of the array like DIM name(x, y, z, etc.) AS type.
From what can be inferred from the application help file, it would appear that
numeric variables were always signed 32 bit values. Reserved words could not be used
for variable names and QuickBasic was not case sensitive.
Variables in QuickBasic were locally scoped whereas some other BASIC
languages used only global scoping. One bonus to the methods used to declare
variables was when it came to procedures. While the appended symbol method was
convenient for easily seeing the variables type, the DIM name AS type method allowed
you to change the type by simply changing the type keyword. Through the SHARED
keyword, variables could be used out of scope, increasing the ease of code reusability
(Noggle, 80).
Arithmetic, Relational, and Logical Operators
QuickBasic possessed the standard stable of arithmetic operators such as
exponentiation (^), negation (-), multiplication and division (*, /), integer division (\),
modulo arithmetic (MOD), and addition and subtraction (+, -), with an operator
precedence of the order given.
Relation operators included equal to (=), greater then (>), less than (<), not equal
to (<>), less than or equal to (<=), and greater than or equal to (>=).
In regards to logical operators, QuickBasic supported operators for not (NOT),
and (AND), or (OR), exclusive or (XOR), equivalent or if and only if
(EQV), material implication or X implies Y (IMP).
Program Structure
Microsoft made the move to a more structured format from the start with
QuickBasic and with newer versions, continued to improve upon this. QuickBasic still
supported line numbers and program jumps, although these led to spaghetti code that
was difficult to follow and maintain. (QuickBasic) Control structures like
IF…THEN…ELSE, SELECT CASE…CASE1…CASE2…CASE ELSE…END SELECT,
DO WHILE…LOOP, DO UNTIL…LOOP, and for loops in the form of FOR…NEXT were
supported in QuickBasic. These included both block and single line verses. The
inclusion of these, as well as functions and procedures, allowed for the creation of more
professional code.
Subprograms
QuickBasic supported procedures, but they were stored and written separately
from the main program file. Through the use of the SUB keyword, the editor would take
you to a new window as soon as the procedure was declared ("QBASIC Programming
for Kids."). The syntax for declaring a procedure was as follows:
SUB name [ parameterList]
[statements]
[EXIT SUB]
[statements]
EXIT SUB
Through the use of subprograms and user defined data types, something that
resembled object oriented programming could be accomplished.
Exception/Error Handling
QuickBasic supported error handling through the ON ERROR GOTO label
statement. This statement tells the program what label to go to in the event of an error.
ERR, a variable that holds a code related to the error, is then used in a SELECT CASE
statement to designate how each error is handled. RESUME NEXT is used after the
select case to allow the program to continue.
Readability, Writability, and Reliability
QuickBasic, being part of the BASIC family, was meant to be a user friendly
language. It was marketed by Microsoft as “the introductory level for their BASIC
Professional Development System.” ("QuickBasic.") QuickBasic code is fairly easy to
follow and read when compared to other languages. Other languages use many
abbreviations, but QuickBasic’s code looked almost like a set of instructions given in
English. For an example of a complete QuickBasic program, see the appendix: A
QuickBasic Example Program.
The English like syntax, while making it more readable, has an impact on its
writability via the sheer number of keystrokes needed to complete a task. This is
balanced by the fact that writing QuickBasic code feels like naturally explaining a task.
Regarding reliability, QuickBasic had some differences between the interpreter
and the compiler. This meant that code that execute is the interpreter may not compile.
("QuickBASIC." ) Newer versions of QuickBasic were backwards compatible with
previous versions.
Overview
Overall QuickBasic was a language that performed it task. It was a language that
was easy to learn. It provided the means to create professional code. During it’s lifetime
it was a language that supported the features of it’s day. QuickBasic was a solid
language that is used to solve problem, even to this day.
Appendix: A QuickBasic Example Program.
The following is an example program from the 99 Bottles of Beer website. This site is a
collection of source code in many different languages that will generate the lyrics to the song
“99 Bottles of Beer.” This specific version can be found at: http://www.99-bottles-ofbeer.net/language-quickbasic-1673.html
Language QuickBASIC
(boolean algebra, "four phrase" logic)
Date:
01/19/08
Author:
Al Boulley
URL:
n/a
Comments:
1
Info:
n/a
Score:
(3.12 in 24 votes)
'set fridge capacity, beverage type, and container type
X = 99
B$ = "beer"
C$ = "bottle"
'build number strings so "0" can be sung correctly in second to last verse
DIM N$(X)
FOR L = 1 TO X
N$(L) = LTRIM$(STR$(L))
NEXT
N$(0) = "no more"
'fully stock the fridge, and then start singing!
F=X
DO
'each verse has four "phrases"
FOR P = 1 TO 4
SELECT CASE P:
'three phrases are very similar - first, second, and fourth
CASE 1, 2, 4:
'use some boolean algebra to handle the "what-ifs":
PRINT N$(F); " "; C$; LEFT$("s", -(F <> 1)); " of "; B$;
'-(F=1) evaluates to 1 when F=1.... [-(-1)]
'
0 when F<>1... [-(0) ]
'(don't want to pluralize a lone container)
PRINT LEFT$(" on the wall", -12 * (P <> 2));
'-12*(P<>2) evaluates to 0 when P=2.... [-12*(0) ]
'
12 when P<>2... [-12*(-1)]
'(don't want to sing those words in the second phrase)
PRINT MID$(", ." + CHR$(13), 3 + 2 * (P = 1), 2);
'3+2*(P=1) evaluates to 1 when P=1.... [3+2*(-1)]
'
3 when P<>1... [3+2*(0) ]
'(brief pause after first phrase, long pause after other two)
'[using length of zero with Left$ results in empty string]
'third phrase of the song never changes
CASE 3:
PRINT "Take one down and pass it around, ";
F=F-1
END SELECT
NEXT
'take an extra breath between verses
PRINT
'F evaluates to FALSE when F=0 [exactly zero is always FALSE]
'
TRUE when F<>0 [every nonzero is always TRUE]
'(continue singing verses until fridge is empty)
LOOP WHILE F
'sing final verse the easy way
PRINT "No more "; C$; "s of "; B$; " on the wall, no more "; C$; " of "; B$; "."
PRINT "Go to the store and buy some more, "; N$(X); " "; C$; "s of "; B$; " on the wall."
'boolean algebra is your friend :)
Bibliography
Joseph, Noggle H. QuickBasic Programming for Scientists and Engineers. CRC, 1992. Web.
Perry, Z. "Programming: QBASIC History Timeline." Associated Content from Yahoo! Associatedcontent.com. Web. 22 Nov. 2011.
<http://www.associatedcontent.com/article/423353/programming_qbasic_history_timelin
e.html?cat=15>.
"QBASIC Programming for Kids." Ted Felix's Home Page. Web. 22 Nov. 2011.
<http://tedfelix.com/qbasic/>.
"QuickBASIC." Wikipedia, the Free Encyclopedia. Web. 22 Nov. 2011.
<http://en.wikipedia.org/wiki/QuickBASIC>.