In
computer programming,
BASIC (an
acronym for
Beginner's All-purpose Symbolic Instruction Code[1]) is a family of
high-level programming languages. The
original BASIC was designed in 1964, by
John George Kemeny and
Thomas Eugene Kurtz at
Dartmouth in order to provide access for non-science students to computers. At the time, nearly all use of computers required writing custom software, which was something only
scientists and
mathematicians tended to do. The language (in one variant or another) became widespread on
microcomputers in the late 1970s and
home computers in the 1980s. BASIC remains popular to this day in a handful of highly modified
dialects and new languages based on BASIC such as
Microsoft Visual Basic.
Background
Before the mid-1960s,
computers were extremely expensive and used only for special-purpose tasks. A simple
batch processing arrangement ran only a single "job" at a time, one after another. But during the 1960s faster and more affordable computers became available. With this extra processing power, computers would sometimes sit idle, without jobs to run.
Programming languages in the batch programming era tended to be designed, like the machines on which they ran, for specific purposes (such as
scientific formula calculations or business data processing or eventually for
text editing). Since even the newer, less expensive machines were still major investments, there was a strong tendency to consider efficiency to be the most important feature of a language. In general, these specialized languages were difficult to use and had widely disparate
syntax.
As prices decreased, the possibility of sharing computer access began to move from research labs to commercial use. Newer computer systems supported
time-sharing, a system which allows multiple users or processes to use the
CPU and memory. In such a system the
operating system alternates between running processes, giving each one running time on the CPU before switching to another. The machines had become fast enough that most users could feel they had the machine all to themselves. In theory, timesharing reduced the cost of computing tremendously, as a single machine could be shared among (up to) hundreds of users.
Early years: the mini-computer era
The original BASIC language was designed in 1963 by
John Kemeny and
Thomas Kurtz[2] and implemented by a team of Dartmouth students under their direction. BASIC was designed to allow students to write programs for the
Dartmouth Time-Sharing System. It was intended to address the complexity issues of older languages with a new language design specifically for the new class of users that time-sharing systems allowed—that is, a less technical user who did not have the mathematical background of the more traditional users and was not interested in acquiring it. Being able to use a computer to support teaching and research was quite novel at the time. In the following years, as other dialects of BASIC appeared, Kemeny and Kurtz's original BASIC dialect became known as
Dartmouth BASIC.
The eight design principles of BASIC were:
- Be easy for beginners to use.
- Be a general-purpose programming language.
- Allow advanced features to be added for experts (while keeping the language simple for beginners).
- Be interactive.
- Provide clear and friendly error messages.
- Respond quickly for small programs.
- Not to require an understanding of computer hardware.
- Shield the user from the operating system.
The language was based partly on the
FORTRAN II and partly on the
ALGOL 60, with additions to make it suitable for timesharing. (The features of other time-sharing systems such as
JOSS and CORC, and to a lesser extent LISP, were also considered.) It had been preceded by other teaching-language experiments at Dartmouth such as the DARSIMCO (1956) and DOPE (1962 implementations of SAP and DART (1963) which was a simplified FORTRAN II). Initially, BASIC concentrated on supporting straightforward mathematical work, with
matrix arithmetic support from its initial implementation as a batch language and full string functionality being added by 1965. BASIC was first implemented on the
GE-265 mainframe which supported multiple
terminals. Contrary to popular belief
[citation needed], it was a
compiled language at the time of its introduction. It was also quite efficient, beating FORTRAN II and ALGOL 60 implementations on the 265 at several fairly computationally intensive (at the time) programming problems such as numerical integration by
Simpson's Rule.
The designers of the language decided to make the compiler available free of charge so that the language would become widespread. They also made it available to high schools in the Dartmouth area and put a considerable amount of effort into promoting the language. As a result, knowledge of BASIC became relatively widespread (for a computer language) and BASIC was implemented by a number of manufacturers, becoming fairly popular on newer
minicomputers like the
DEC PDP series and the
Data General Nova. The BASIC language was also central to the
HP Time-Shared BASIC system in the late 1960s and early 1970s. In these instances the language tended to be implemented as an
interpreter, instead of (or in addition to) a
compiler.
Several years after its release, highly-respected computer professionals, notably
Edsger W. Dijkstra, expressed their opinions that the use of
GOTO statements, which existed in many languages including BASIC, promoted poor programming practices.
[3] Some have also derided BASIC as too slow (most interpreted versions are slower than equivalent compiled versions) or too simple (many versions, especially for small computers left out important features and capabilities).
Explosive growth: the home computer era
Notwithstanding the language's use on several minicomputers, it was the introduction of the
MITS Altair 8800 "kit"
microcomputer in 1975 that provided BASIC a path to universality. Most programming languages required more memory (and/or disk space) than was available on the small computers most users could afford. With the slow memory access that
audio tapes provided and the lack of suitable text editors, a language like BASIC which could satisfy these constraints, as well as being
interpreted line by line from a tape device, was attractive.
BASIC also had the advantage that it was fairly well known to the young designers and computer hobbyists who took an interest in microcomputers, and generally worked in the electronics industries of the day. Kemeny and Kurtz's earlier proselytizing paid off in this respect and the few hobbyists journals of the era were filled with columns that made mentions of the language or focused entirely on one version compared to others.
One of the first to appear for the
8080 machines like the Altair 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. Dobb's Journal). The Tiny BASIC design and the full source code were published in 1976 in DDJ.
In 1975, MITS released
Altair BASIC, developed by college drop-outs
Bill Gates and
Paul Allen as the company
Micro-Soft (who started today's corporate giant, Microsoft). The first Altair version was co-written by Gates, Allen and
Monte Davidoff in a burst of enthusiasm and neglect of studies. Versions of
Microsoft BASIC (also known then, and most widely as
M BASIC or
MBASIC, see sidebar) was soon bundled with the original
floppy disk-based
CP/M computers, which became widespread in small business applications. As the popularity of BASIC on CP/M spread, newer computer designs also introduced their own version of the language, or had Micro-Soft port version to their platform.
When three major new computers were introduced in what
Byte Magazine would later call the "1977 Trinity",
[4] all three had BASIC as their primary programming language and operating environment. The
Commodore PET licensed a version of Micro-Soft BASIC that was ported to the
MOS 6502, while
Apple II and
TRS-80 both introduced new versions of the language that were largely similar. As new companies entered the field, additional versions were added that subtly changed the BASIC family. The
Atari 8-bit family had their own
Atari BASIC that was modified in order to fit on 8 kB ROM cartridge. The
BBC published
BBC BASIC, developed for them by
Acorn Computers Ltd, incorporating many extra structuring keywords. Most of the
home computers of the 1980s had a
ROM-resident BASIC interpreter, allowing the machines to boot directly into BASIC. There are more
dialects of BASIC than there are of any other programming language.
During this growth time for BASIC, many magazines were published such as
Creative Computing Magazine that included complete source codes for games, utilities, and other programs. Given BASIC's straightforward nature, it was considered a simple matter to
type in the code from the magazine and execute the program. Different magazines were published featuring programs for specific computers, though some BASIC programs were universal and could be input into any BASIC-using machine. A logical extension of the magazine idea was the publishing of BASIC source code in full-fledged books: probably the classic example was
David Ahl's series of Basic Computer Games.
Maturity: the personal computer era
As early as 1979 Microsoft was in negotiations with IBM to supply them with a version of BASIC. Microsoft sold several versions of BASIC for
MS-DOS/
PC-DOS including
BASICA,
GW-BASIC (a BASICA-compatible version that did not need IBM's ROM) and
QuickBASIC. Turbo
Pascal-publisher
Borland published
Turbo BASIC 1.0 in 1985 (successor versions are still being marketed by the original author under the name
PowerBASIC).
These languages introduced many extensions to the original home computer BASIC, such as improved
string manipulation and graphics support, access to the
file system and additional
data types. More important were the facilities for
structured programming, including additional
control structures and proper
subroutines supporting
local variables.
However, by the latter half of the 1980s newer computers were far more capable with more resources. At the same time, computers had progressed from a hobbyist interest to tools used primarily for applications written by others, and programming became less important for most users. BASIC started to recede in importance, though numerous versions remained available. Compiled BASIC or
CBASIC is still used in many IBM 4690 OS point of sale systems.
BASIC's fortunes reversed once again with the introduction of
Visual Basic by Microsoft. It is somewhat difficult to consider this language to be BASIC, because of the major shift in its orientation towards an
object-oriented and
event-driven perspective. The only significant similarity to older BASIC dialects was familiar syntax. Syntax itself no longer "fully defined" the language, since much development was done using "drag and drop" methods without exposing all code for commonly-used objects such as buttons and scrollbars to the developer. While this could be considered an evolution of the language, few of the distinctive features of early
Dartmouth BASIC, such as
line numbers and the
INPUT keyword, remain (although Visual Basic still uses
INPUT to read data from files, and
INPUTBOX is available for direct user input; line numbers can also optionally be used in all VB versions, even VB.NET, albeit they cannot be used in certain places, for instance before
SUB).
Ironically given the origin of BASIC as a "beginner's" language, and apparently even to the surprise of many at Microsoft who still initially marketed Visual Basic or "VB" as a language for hobbyists, the language had come into widespread use for small custom business applications shortly after the release of VB version 3.0, which is widely considered the first relatively stable version. While many advanced programmers still scoffed at its use, VB met the needs of small businesses efficiently wherever processing speed was less of a concern than easy development. (By that time, computers running Windows 3.1 had become fast enough that many business-related processes could be completed "in the blink of an eye" even using a "slow" language, as long as massive amounts of data were not involved.) Many small business owners found they could create their own small yet useful applications in a few evenings to meet their own specialized needs. Eventually, during the lengthy lifetime of VB3, knowledge of Visual Basic had become a marketable job skill.
Many BASIC dialects have also sprung up in the last few years, including
Bywater BASIC and
True BASIC (the direct successor to Dartmouth BASIC from a company controlled by Kurtz). Many other BASIC variants and adaptations have been written by hobbyists, equipment developers, and others, as it is a relatively simple language to develop translators for. An example of an open source interpreter, written in C, is
MiniBasic.
The ubiquity of BASIC interpreters on personal computers was such that textbooks once included simple "Try It In BASIC" exercises that encouraged students to experiment with mathematical and computational concepts on classroom or home computers. Futurist and sci-fi writer
David Brin mourns the loss of ubiquitous BASIC in a recent
Salon article.
[8]
