BASIC

From Wikipedia, the free encyclopedia

Jump to: navigation, search

This article is about the programming language. For the think tank, see British American Security
Information Council. For the group of nations popularly called BASIC block, see G4 bloc.

This article is written like a personal reflection or essay and may require cleanup. Please help
improve it by rewriting it in an encyclopedic style. (January 2010)

Screenshot of Atari BASIC, an early BASIC language for small computers

BASIC

unstructured, later procedural,

Paradigm
later object-oriented

Appeared in 1963

John George Kemeny and Thomas

Designed by
Eugene Kurtz

Typing discipline strong

Apple BASIC, Commodore BASIC,

Major
Microsoft BASIC, BBC BASIC, TI-
implementations
BASIC

Influenced by ALGOL 60, FORTRAN II, JOSS

COMAL, Visual BASIC, Visual

Influenced Basic .NET, Realbasic, REXX, Perl,
GRASS
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 College in New Hampshire, USA to provide
computer access to non-science students. At the time, nearly all use of computers required writing
custom software, which was something only scientists and mathematicians tended to be able to do. The
language and its variants became widespread on microcomputers in the late 1970s and 1980s. BASIC
remains popular to this day in a handful of highly modified dialects and new languages influenced by
BASIC such as Microsoft Visual Basic. As of 2006, 59% of developers for the .NET platform used Visual
Basic .NET as their only language.[2]

Contents

[hide]

 1 History

o 1.1 Early years: the mainframe and mini-computer era

o 1.2 Explosive growth: the home computer era

o 1.3 Maturity: the personal computer era

 2 Examples

o 2.1 Unstructured BASIC

o 2.2 Structured BASIC

o 2.3 BASIC with object-oriented features

 3 Data types and variables

 4 List of typical BASIC keywords

o 4.1 Data manipulation

o 4.2 Program flow control

o 4.3 Input and output

o 4.4 Miscellaneous

 5 See also

 6 Notes

 7 References
 o 7.1 Standards

 8 External links

[edit] History

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 RAM and memory. In such a system the operating system alternates between
running processes, giving each one running time on the RAM 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
hundreds of users.

[edit] Early years: the mainframe and mini-computer era

The original BASIC language was designed in 1963 by John Kemeny and Thomas Kurtz[3] 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:

1. Be easy for beginners to use.

2. Be a general-purpose programming 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 quickly for small programs.

7. Not to 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. (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. At the time of its introduction, it was a compiled language. 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 Hanover, NH
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, and the Pick operating system. 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. [4] 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).

[edit] Explosive growth: the home computer era

MSX BASIC version 3.0

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 suitable text editors, large amounts of memory and available disk space, whereas
the early microcomputers had no resident editors, limited memory and often substituted recordable
audio tapes for disk space. All these issues allowed a language like BASIC, in its interpreted form with a
built-in code editor, to operate within those constraints.

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 Bill Gates and Paul Allen as the company Micro-Soft,
which grew into today's corporate giant, Microsoft. The first Altair version was co-written by Gates,
Allen, and Monte Davidoff. Versions of Microsoft BASIC (also known then, and most widely as M BASIC
or MBASIC) was soon bundled with the original floppy disk-based CP/M computers, which became
widespread in small business environments. 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 its version
to their platform.

When three major new computers were introduced in what Byte Magazine would later call the "1977
Trinity",[5] all three had BASIC as their primary programming language and operating environment.
Commodore Business Machines paid a one-time fee for an unlimited license to a version of Micro-Soft
BASIC that was ported to the MOS 6502 in their PET computer, while Apple II and TRS-80 both
introduced new, largely similar versions of the language. The similarities are striking because the first 50
tokens, used for conserving memory, were all the same. 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 an 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. Because of this legacy, there are more dialects of BASIC than there are of any other
programming language.

As the popularity of BASIC grew in this period, magazines (such as Creative Computing Magazine in the
US) published complete source code in BASIC for games, utilities, and other programs. Given BASIC's
straightforward nature, it was 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 considered universal and could be used in machines running any variant of BASIC
(sometimes with minor adaptations). Correcting the publishing errors that frequently occurred in
magazine listings was an educational exercise in itself.

BASIC source code was also published in fully-fledged books: the seminal examples being David Ahl's
BASIC Computer Games series.[6][7][8] Later packages, such as Learn to Program BASIC would also have
gaming as an introductory focus.

[edit] Maturity: the personal computer era

The examples and perspective in this article may not represent a worldwide view of the
subject. Please improve this article and discuss the issue on the talk page. (January 2010)

IBM Cassette BASIC 1.10

As early as 1979 Microsoft was in negotiations with IBM to supply their IBM PCs with an IBM Cassette
BASIC (BASIC C) inside BIOS. Microsoft sold several versions of BASIC for MS-DOS/PC-DOS including IBM
Disk BASIC (BASIC D), IBM BASICA (BASIC A), 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).
Microsoft wrote the windowing based AmigaBASIC that was supplied with version 1.1 of the pre-
emptive multitasking GUI Amiga computers (late 1985/ early 1986), although the product unusually did
not bear any Microsoft marks.

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. The new graphical features of these languages also
helped lay the groundwork for PC video gaming, with BASIC programs like DONKEY.BAS showing what
the PC could do.

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. The language, like QBasic before it,[9] also became a
favourite for amateur game development. [10]
Three modern Basic variants: Mono Basic, OpenOffice.org Basic and Gambas

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). One notable variant is
RealBasic which although first released in 1998 for Macintosh computers, has since 2005 fully compiled
programs for Microsoft Windows, Mac OS X and 32-bit x86 Linux, from the same object-oriented source
code. RealBasic compiled programs may execute natively on these platforms as services, consoles or
windowed applications. However in keeping with BASIC tradition, single-platform hobbyist versions are
also still maintained. 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. More complex examples of free
software BASIC implementations (development tools and compilers) include Gambas and FreeBASIC.

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 mourned
the loss of ubiquitous BASIC in a 2006 Salon article.[11]

[edit] Examples

This section does not cite any references or sources.

Please help improve this article by adding citations to reliable sources. Unsourced material
may be challenged and removed. (December 2008)

[edit] Unstructured BASIC

New BASIC programmers on a home computer might start with a simple program similar to the Hello
world program made famous by Kernighan and Ritchie. This generally involves simple use of the
language's PRINT statement to display the message (such as the programmer's name) to the screen.
Often an infinite loop was used to fill the display with the message. Most first generation BASIC
languages such as MSX BASIC and GW-BASIC supported simple data types, loop cycles and arrays. The
following example is written for GW-BASIC, but will work in most versions of BASIC with minimal
changes:

10 INPUT "What is your name: ", U$

20 PRINT "Hello "; U$

30 INPUT "How many stars do you want: ", N

40 S$ = ""

50 FOR I = 1 TO N

60 S$ = S$ + "*"

70 NEXT I

80 PRINT S$

90 INPUT "Do you want more stars? ", A$

100 IF LEN(A$) = 0 THEN GOTO 90

110 A$ = LEFT$(A$, 1)

120 IF A$ = "Y" OR A$ = "y" THEN GOTO 30

130 PRINT "Goodbye "; U$

140 END

[edit] Structured BASIC

Second generation BASICs (for example QuickBASIC and PowerBASIC) introduced a number of features
into the language, primarily related to structured and procedure-oriented programming. Usually, line
numbering is omitted from the language and replaced with labels (for GOTO) and procedures to
encourage easier and more flexible design. [12]

INPUT "What is your name: ", UserName$

PRINT "Hello "; UserName$

DO

INPUT "How many stars do you want: ", NumStars

Stars$ = STRING$(NumStars, "*")

 PRINT Stars$

DO

INPUT "Do you want more stars? ", Answer$

LOOP UNTIL Answer$ <> ""

Answer$ = LEFT$(Answer$, 1)

LOOP WHILE UCASE$(Answer$) = "Y"

PRINT "Goodbye "; UserName$

[edit] BASIC with object-oriented features

Third generation BASIC dialects such as Visual Basic, REALbasic, StarOffice Basic and BlitzMax introduced
features to support object-oriented and event-driven programming paradigm. Most built-in procedures
and functions now represented as methods of standard objects rather than operators.

The following example is in Visual Basic .NET:

Public Class StarsProgram

Public Shared Sub Main()

Dim UserName, Answer, stars As String, NumStars As Integer

Console.Write("What is your name: ")

UserName = Console.ReadLine()

Console.WriteLine("Hello {0}", UserName)

Do

Console.Write("How many stars do you want: ")

NumStars = CInt(Console.ReadLine())

stars = New String("*", NumStars)

Console.WriteLine(stars)

Do

Console.Write("Do you want more stars? ")

 Answer = Console.ReadLine()

Loop Until Answer <> ""

Answer = Answer.Substring(0, 1)

Loop While Answer.ToUpper() = "Y"

Console.WriteLine("Goodbye {0}", UserName)

End Sub

End Class

[edit] Data types and variables

Minimal versions of BASIC had only integer variables and single-letter variable names. More powerful
versions of BASIC offered floating-point arithmetic, and variables could be labelled with names six or
more characters long.

String variables are usually distinguished by having $ suffixed to their name, and string values are
typically enclosed in quotation marks.

Arrays in BASIC could contain integers, floating point or string variables.

[edit] List of typical BASIC keywords

[edit] Data manipulation

 LET Command - assigns a value (which may be the result of an expression) to a variable.

 DATA Statement - holds a list of values which are assigned sequentially using the READ
Command.

[edit] Program flow control

 IF ... THEN ... ELSE Statement - used to perform comparisons or make decisions.

 FOR ... NEXT Statement - repeat a section of code a given number of times. A variable that acts
as a counter is available within the loop.

 WHILE ... WEND and REPEAT ... UNTIL Commands - repeat a section of code while the specified
condition is true. The condition may be evaluated before each iteration of the loop, or after.

 GOTO Command - jumps to a numbered or labelled line in the program.

  GOSUB Command - temporarily jumps to a numbered or labelled line, returning to the following
line after encountering the RETURN Command. This is used to implement subroutines.

 ON ... GOTO/GOSUB Command - chooses where to jump based on the specified conditions. See
Switch statement for other forms.

[edit] Input and output

 PRINT Statement - displays a message on the screen or other output device.

 INPUT Statement - asks the user to enter the value of a variable. The statement may include a
prompt message.

 TAB or AT Function - sets the position where the next character will be shown on the screen or
printed on paper.

[edit] Miscellaneous

 REM (Remark) - holds a programmer's comment; often used to give a title to the program and to
help identify the purpose of a given section of code.