BASIC programming language
BASIC is a family of high-level programming languages. Originally devised as
a teaching tool, it became widespread on home microcomputers in the 1980s,
and remains popular to this day in a handful of heavily altered dialects.
BASIC's name, coined in classic computer science tradition to result in a
nice acronym, stands for Beginner's All-purpose Symbolic Instruction
Code,¹ tied to the name of an unpublished paper by the language's
co-inventor Thomas Kurtz (the name thus having no relation to C. K. Ogden's
series "Basic English"). Some critics have humorously called the language
Bill's Attempt to Seize Industry Control in response to Microsoft's policies
with respect to BASIC interpreters included with early IBM PC compatibles.
History
Background
Prior to the mid-1960s, computers were terribly expensive tools that were
used only for special-purpose task, running a single "job" at a time. During
the 1960s, however, computers started to drop in price to the point where
even small companies could afford them, and the speed increased to the point
where they often sat idle because there weren't enough jobs for them.
Programming languages of the era tended to be designed, like the machines
they ran on, for specific purposes such a scientific formula processing.
Since single-job machines were expensive, they also tended to consider
execution speed to be the most important feature of all. In general they
were hard to use, and tended to be somewhat "ugly".
It was at this time that the concept of time-sharing systems started to
become popular. In such a system the processing time of the main computer
was "sliced up" and each user was given a small amount in sequence. The
machines were fast enough that most users would be fooled into thinking that
they had a single fast machine to themselves. In theory timesharing reduced
the cost of computing tremendously, as a single machine could be shared
among, in theory at least, hundreds of users.
Birth and early years
The original BASIC language was invented in 1964 by John George Kemeny
(1926-93) and Thomas Eugene Kurtz (1928-) at Dartmouth College. In the
following years, as other dialects of BASIC appeared, Kemeny and Kurtz'
original BASIC dialect became known as Dartmouth BASIC.
BASIC was designed to allow students to write programs using time-sharing
computer terminals. BASIC intended to address the complexity issues of older
languages with a new language designed specifically for the new class of
users the time-sharing systems allowed – that is, a "simpler" user who
was not as interested in speed as in simply being able to use the machine.
The designers of the language also wanted it to remain in the public domain,
which helped it to spread.
The eight design principles of BASIC were:
1. Be easy for beginners to use
2. Be a general-purpose language
3. Allow advanced features to be added for experts (while keeping the
language simple for beginners)
4. Be interactive
5. Provide clear and friendly error messages
6. Respond fast for small programs
7. Not require an understanding of computer hardware
8. Shield the user from the operating system
The language was based partly on FORTRAN II and partly on Algol 60, with
additions to make it suitable for timesharing and matrix arithmetic, BASIC
was first implemented on the GE-265¹ mainframe which supported multiple
terminals. Contrary to popular belief, it was a compiled language at the
time of its introduction. Almost immediately after its release, computer
professionals started to deride BASIC as being too slow and too
simple.² Such elitism is a recurring theme in the computer industry.
BASIC nevertheless spread to a number of machines, and became fairly popular
on newer minicomputers like the DEC PDP series and the Data General Nova. In
these instances the language tended to be implemented as an interpreter
instead of a compiler, or alternately, both were supplied.
Explosive growth
However it was the introduction of the Altair 8800 microcomputer in 1975
that truly spread BASIC. Most programming languages were too large to fit in
the small memory most users could afford on these machines, and with the
slow paper tape (or later audio cassette tape) storage (disks of any kind
were not available at any price for some years) and the lack of suitable
text editors, a small language like BASIC was a good fit. One of the first
to appear for this machine was Tiny BASIC, a simple BASIC implementation
originally written by Dr. Li-Chen Wang, and then ported onto the Altair by
Dennis Allison at the request of Bob Albrecht (who later founded Dr Dobbs
Journal). The Tiny BASIC design and the full source code was published 1976
in DDJ.
In 1977 Microsoft (then only two people -- Gates and Allen) released Altair
BASIC. Versions then started appearing on other platforms under licence, and
millions of copies and variants were soon in use; it became one of the
standard languages on the Apple II. By 1979 Microsoft was in talks with
several microcomputer vendors, including IBM, to license a BASIC interpreter
for their computers. A version was included in the IBM PC's ROM chips and,
for PCs without disks, was booted automatically on power up.
As newer companies attempted to follow the success of Altair, IMSAI, North
Star, and Apple, and thus created the home computer revolution, BASIC became
a standard feature of all but a very few home computers; most came with a
BASIC interpreter in ROM (a feature pioneered by the Commodore PET in 1977).
Soon there were many millions of machines running BASIC around the world,
likely a far greater number than all of the users of all other languages put
together. Many programs, especially those on the Apple II and IBM PC,
depended on the presence of Microsoft's BASIC interpreter and would not run
without it; thus, Microsoft used the copyright license on the BASIC
interpreters to gain leverage in negotiations with the computer vendors.
Maturity
Newer and more powerful BASIC versions were created in this time period.
Microsoft sold several versions of BASIC for MSDOS / PCDOS including BASICA,
GW-BASIC (a BASICA-compatible version that didn't need IBM's ROM), and Quick
BASIC. Turbo Pascal-publisher Borland published Turbo BASIC 1.0 in 1985
(successor versions are still sold under the name of PowerBASIC by another
company). Various extensions of home computer BASICs appeared, typically
with graphics, sound, and DOS commands, as well as facilities for structured
programming. Other languages used the widely-understood BASIC syntax as the
basis for otherwise completely different systems, GRASS being one example.
However by the latter half of the 1980s newer computers were far more
complex and included features (such as graphical user interfaces) that made
BASIC less and less suitable for programming them. At the same time
computers were progressing from hobbyist interest to tools used primarily
for running applications written by others, and programming as a whole
became less important for the growing majority of users. BASIC started to
fade, although numerous versions remained available.
BASIC's fortunes reversed once again with the introduction of Visual Basic
from Microsoft. Although it is somewhat difficult to consider this language
to be BASIC (despite its using many familiar BASIC keywords) it has gone on
to become one of the most used languages on the Windows platform, and is
said to represent some 70 to 80% of all commercial development. Visual Basic
for Applications (VBA) was added to Microsoft Excel 5.0 in 1993 and to the
rest of the Microsoft Office product line in 1997. Windows 98 included a
VBScript interpreter. The most recent Visual Basic version is called VB.NET.
The OpenOffice suite includes a BASIC variant reportedly less powerful than
its MS counterpart.
The language
Syntax
Statements are terminated by line endings unless there is a line
continuation character. A very minimal BASIC syntax only needs the LET,
PRINT, IF and GOTO commands. An interpreter which executes programs with
this minimal syntax doesn't need a stack. Some early microcomputer
implementations were this simple. If one adds a stack, nested FOR-loops and
the GOSUB command can be added. A BASIC interpreter with these features
requires the code to have line numbers.
Line numbers were a very distinctive aspect of classic home computer BASICs.
Alas, use of line numbers has the disadvantage of requiring the programmer
to guesstimate ahead of program entry how many lines a given program part
will take. This need is most often met by habitually incrementing successive
line numbers by a regular interval, say 10, but naturally leads to problems
as soon as code added at a later time exceeds the place available between
the original lines. To alleviate this problem with early BASIC interpreters,
expert users soon wrote their own utility programs for renumbering their
programs after initial entry. Some BASIC interpreters later appeared with a
built-in RENUMBER command, thus eliminating the most pressing problem with
line numbers.
Modern BASIC dialects have abandoned line numbers, and support most (or all)
of the structured control and data declaration constructs as known in other
languages like C and Pascal (note that there were also some advanced
versions of line number based home computer BASICs incorporating such
constructs to good effect):
* do - loop - while - until - exit
* on x goto / gosub (switch & case)
Recent variants such as Visual Basic have introduced object-oriented
features, and even inheritance in the latest version. Memory management is
easier than in many other procedural programming languages because of the
commonly included garbage collector (for which one presumably has to pay a
run-time performance penalty, however).
The wealth of variants shows that the language is an "organic" one and that
it may be seen as a subculture dealing with computer programming rather than
as a fixed set of syntactic rules. The same applies to other "old" computer
languages like COBOL and FORTRAN as well, although the BASIC movement is by
far the largest; this may be explained by the large numbers of IT
professionals who cut their teeth at BASIC programming during the home
computer era in the 1980s.
Procedures and flow control
BASIC doesn't have a standard external library like other languages such as
C. Instead, the interpreter (or compiler) contains an extensive built-in
library of intrinsic procedures. These procedures include most of the tools
a programmer needs to learn programming and write simple applications
including functions for math, strings, console input and output, graphics
and file manipulation.
Some BASIC dialects do not allow programmers to write their own procedures.
Programmers must instead write their programs with large numbers of GOTO
statements for branching. This can result in very confusing source commonly
referred to as spaghetti code. GOSUB statements branch to simple kinds of
subroutines without parameters or local variables. Most modern versions of
BASIC such as Microsoft QuickBASIC have added support for full subroutines
and functions. This is another area where BASIC varies from many other
programming languages. BASIC, like Pascal, makes a distinction between a
procedure which does not return a value (called a subroutine) and a
procedure which does (called a function). Many other languages (notably C)
make no distinction and consider everything a function (with some returning
a "void" value).
While functions in the larger sense of subroutines returning values were a
latecomer to BASIC dialects, many early systems supported the definition of
one-line mathematical functions with DEF FN ("DEFine FunctioN"). The
original Dartmouth BASIC also supported Algol-like functions and subroutines
from an early date.
Data types
BASIC is well known for its good string manipulation functions. Already
early dialects had a set of fundamental functions (LEFT$, MID$, RIGHT$) to
deal with strings easily. As strings are often used in everyday applications
this was a considerable advantage over other languages at the time of its
introduction.
The original Dartmouth BASIC supported only numeric and string data types.
There was no integer type. All numeric variables were floating point.
Strings were dynamic length. Arrays of both numbers and strings were
supported, as well as matrices (two dimensional arrays).
Every modern BASIC dialect at least has the integer and string data types.
Data types are usually distinguished with a following character; string
identifiers end in $, whereas integers do not. In some dialects, variables
must be declared (with DIM) on first usage; other dialects do not require
this, but have the option to enforce it -- typically using a directive such
as Option Explicit. Many dialects also support additional types, such as 16
and 32-bit integers and floating-point numbers. Additionally some allow the
definition of user-defined types, similar to Pascal "records" or C
"structs".
Most BASIC dialects beyond the most primitive also support arrays of
integers or other types. In some, arrays must be preallocated before they
can be used (with the DIM statement). Support for two and higher-dimensional
arrays, as well as arrays of non-integer types, are common.
DIM myIntArray(100) AS INTEGER
DIM myNameList(50) AS STRING
Depending on the dialect of BASIC and on use of the Option Base statement,
values can range from myIntArray(0) to myIntArr(100), from myIntArr(1) to
myIntArr(100) or from myIntArray(LowInteger) to myIntArray(HighInteger).
Relational and logical operators
= equal <= less than or equal NOT logical negation
not equal >= greater than or equal AND logical conjunction
< less than OR logical disjunction
> greater than
(notice that there is no lexical distinction between the equality operator
and the assignment operator in BASIC)
Availability and dialect variants
BASIC is available for nearly every microprocessor platform made. One free
interpreted version that is compliant with standards and highly
cross-platform is Bywater BASIC (bwBASIC). The interpreter is written in C
and comes under a GNU license. It is meant for text console programs, and as
such does not include a builder for creating graphical user interfaces
(GUIs). A free BASIC which does include a GUI builder, is similar to Visual
Basic and runs on Windows and Linux is Phoenix Object Basic.
The best known compiled versions are Microsoft's Quick BASIC product line
and QBASIC (a version which does not generate standalone programs.) Some
versions of Visual Basic are also compiled, although Microsoft has kept
Visual Basic at least minimally compatible with even early versions of its
own BASICs.
Other versions include PowerBASIC's PowerBASIC programming language, as well
as True BASIC's True BASIC, which is compliant with the latest official
standards for BASIC. (True BASIC Inc. was founded by the original creators
of Dartmouth BASIC.)
REALbasic is a variant available for the Apple Macintosh which also
generates executables for Microsoft Windows. A variant of a simple BASIC
dialect for the parrot virtual machine shows how a BASIC interpreter is
implemented in an assembly-like language. PureBasic is a variant with a
simple syntax but which produces fast and tiny executable files for Windows
and Linux. It can as well compile in-line assembly instructions. SmallBASIC
is a dialect which runs on many platforms (Win32, DOS, Linux and PalmOS) and
comes under a GNU license (GPL).
Examples
Sample 1: Unstructured original BASIC (Applesoft BASIC) ---------- Sample 2:
Modern Structured BASIC
10 INPUT "What is your name: "; U$ INPUT "What is your name"; UserName$
20 PRINT "Hello "; U$ PRINT "Hello "; UserName$
30 INPUT "How many stars do you want: "; N DO INPUT "How many stars do you want"; NumStars
35 S$ = "" Stars$ = ""
40 FOR I = 1 TO N Stars$ = REPEAT$("*", NumStars) ' ""
90 A$ = LEFT$(A$, 1)
100 IF (A$ = "Y") OR (A$ = "y") THEN GOTO 30 LOOP WHILE UCASE$(LEFT$(Answer$, 1)) = "Y"
110 PRINT "Goodbye "; PRINT "Goodbye ";
120 FOR I = 1 TO 200 FOR I = 1 TO 200
130 PRINT U$; " "; PRINT UserName$; " ";
140 NEXT I NEXT I
150 PRINT PRINT
Dialects
* Altair BASIC (MITS Altair, S-100; Microsoft's first product)
* AMOS (Commodore Amiga)
* Apple Business BASIC (Apple ///)
* Applesoft BASIC (Apple II)
* ASIC (MSDOS)
* Atari BASIC (Atari 8-bit family)
* BASIC09 (for Motorola 6809 8-bit and 680x0 16 and 32 bit CPUs and the
OS9 and OS968K operating systems)
* BASICA (Advanced BASIC, available in ROM on IBM PCs) (later disk based
versions for PC-DOS)
* BASIC-E (aka 'submarine BASIC')
* BBC BASIC (Acorn/BBC Micro, RISC-OS, Cambridge Z88, CP/M, MSDOS)
* Blitz Basic (Commodore Amiga, MSDOS)
* Bywater BASIC (bwBASIC) (MSDOS, POSIX)
* CBASIC (successor of BASIC-E) (CP/M, MSDOS)
* Commodore BASIC (PET/CBM, VIC-20, C64, ...)
* Dartmouth BASIC (see also True BASIC)
* Ethos Basic (Windows)
* FutureBASIC (Macintosh)
* Gambas (Linux) (similar approach as Visual Basic)
* GNOME Basic (Linux) - discontinued Visual Basic clone
* GFA BASIC (Commodore Amiga)
* GW-BASIC (MS-DOS) (BASICA compatible not needing the IBM ROM routines)
* Hbasic (Linux) (similar approach as Visual Basic)
* IBasic (Windows)
* Integer BASIC (Apple II)
* Liberty BASIC (Windows)
* Locomotive BASIC (Amstrad CPC)
* LotusScript (Lotus Notes)
* Mallard BASIC (Amstrad PCW, CP/M on ZX Spectrum +3)
* MBASIC (Microsoft BASIC for CP/M)
* MSX BASIC (MSX)
* Phoenix Object Basic (Linux)
* PowerBASIC (successor of Turbo BASIC) (MSDOS, Win32)
* PureBasic (Win32, Linux and Amiga)
* QBASIC (MSDOS)
* Quick Basic (MSDOS)
* REALbasic (Macintosh, Win32)
* Revelation Basic (MSDOS)
* ROM BASIC
* SAM BASIC (Sam CoupŽ)
* ScriptBasic (Win32 and Linux, GPL)
* Sinclair BASIC (ZX80, ZX81/TS1000, ZX Spectrum)
* SmallBASIC (Linux, MSDOS, Win32, PalmOS; GPL)
* StarOffice Basic (aka StarBasic) (OpenOffice, StarOffice)
* STOS (Atari)
* SuperBasic (Sinclair QL)
* THEOS Multi-User Basic
* TI BASIC (TI 99/4A)
* TI Extended BASIC (ditto)
* Tiny BASIC
* True BASIC (DOS, Windows, Macintosh)
* TRS-80 LevelÊÊI BASIC
* TRS-80 Level II BASIC
* Turbo BASIC (successor of BASIC/Z) (see PowerBASIC)
* VBScript
* Visual Basic (Windows)
* Visual Basic for Applications (VBA) (MS Office on Windows and
Macintosh)
* Visual Basic .NET (Windows)
* XBasic (Win32 and Linux, GPL)
* YaBasic (Win32 and Linux, GPL)
Standards
* ANSI Standard for Minimal BASIC (ANSI X3.60-1978 "FOR MINIMAL BASIC")
* ISO Standard for Minimal BASIC (ISO/IEC 6373:1984 "DATA PROCESSING -
PROGRAMMING LANGUAGES - MINIMAL BASIC")
* ANSI Standard for Full BASIC (ANSI X3.113-1987 "PROGRAMMING LANGUAGES
FULL BASIC") $79 USD
* ISO Standard for Full BASIC (ISO/IEC 10279:1991 "INFORMATION TECHNOLOGY
- PROGRAMMING LANGUAGES - FULL BASIC") $53 USD
* ANSI Addendum Defining Modules (X3.113 INTERPRETATIONS-1992 "BASIC
TECHNICAL INFORMATION BULLETIN # 1 INTERPRETATIONS OF ANSI
03.113-1987")
* ISO Addendum Defining Modules (ISO/IEC 10279:1991/ Amd 1:1994 "MODULES
AND SINGLE CHARACTER INPUT ENHANCEMENT")
This content from Wikipedia is licensed under the GNU Free Documentation License.
|
