BASIC (an acronym for Beginner's All-purpose Symbolic Instruction
Code) is a family of general-purpose, high-level programming
languages whose design philosophy emphasizes ease of use. In 1964,
John G. Kemeny,
Thomas E. Kurtz
Thomas E. Kurtz and
Mary Kenneth Keller designed the
BASIC language at
Dartmouth College in New Hampshire, United
States. They wanted to enable students in fields other than science
and mathematics to use computers. At the time, nearly all use of
computers required writing custom software, which was something only
scientists and mathematicians tended to learn.
BASIC became widespread on microcomputers in the mid-1970s
and 1980s. Microcomputers usually shipped with BASIC, often in the
machine's firmware. Having an easy-to-learn language on these early
personal computers allowed small business owners, professionals,
hobbyists, and consultants to develop custom software on computers
they could afford.[original research?] In the 2010s,
BASIC was popular
in many computing dialects and in new languages influenced by BASIC,
such as Microsoft's Visual Basic.
2 Spread on minicomputers
3 Explosive growth: the home computer era
IBM PC and compatibles
5 Visual Basic
6 Post-1990 versions and dialects
8 Windows command line
11.2 Data types and variables
11.3.1 Unstructured BASIC
11.3.2 Structured BASIC
11.3.3 Object-oriented BASIC
13 See also
15.1 General references
16 External links
BASIC language was released on May 1, 1964 by John G.
Kemeny and Thomas E. Kurtz and implemented under their direction by
a team of
Dartmouth College students.[verification needed]
One of the graduate students on the implementation team was Mary
Kenneth Keller, one of the first people in the U.S. to earn a PhD in
BASIC comes from the name of an unpublished paper by
BASIC was designed to allow students to write
mainframe computer programs for the Dartmouth Time-Sharing System. It
was intended specifically for less technical users who did not have or
want the mathematical background previously expected. Being able to
use a computer to support teaching and research was quite novel at the
The language was based on FORTRAN II, with some influences from ALGOL
60 and with additions to make it suitable for timesharing. Initially,
BASIC concentrated on supporting straightforward mathematical work,
with matrix arithmetic support from its initial implementation as a
batch language, and character string functionality being added by
1965. Wanting use of the language to become widespread, its designers
made the compiler available free of charge. (In the 1960s, software
became a chargeable commodity; until then, it was provided without
charge as a service with the very expensive computers, usually
available only to lease.) They also made it available to high schools
in the Hanover,
New Hampshire area and put considerable effort into
promoting the language. In the following years, as other dialects of
BASIC appeared, Kemeny and Kurtz's original
BASIC dialect became known
as Dartmouth BASIC.
Spread on minicomputers
"Train Basic every day!" — reads a poster (bottom center) in a
Russian school. (ca. 1985–1986)
Knowledge of the relatively simple
BASIC became widespread for a
computer language, and it was implemented by a number of
manufacturers, becoming fairly popular on newer minicomputers such as
the DEC PDP series, where
BASIC-PLUS was an extended dialect for use
RSTS/E time-sharing operating system. The
BASIC language was
available for the Data General Nova, and also central to the HP
BASIC system in the late 1960s and early 1970s, where the
language was implemented as an interpreter. A version was a core part
Pick operating system from 1973 onward, where a compiler
renders it into bytecode, able to be interpreted by a virtual machine.
During this period a number of simple computer games were written in
BASIC, most notably Mike Mayfield's Star Trek. A number of these were
collected by DEC employee
David H. Ahl and published in a newsletter
he compiled. He later collected a number of these into book form, 101
BASIC Computer Games, published in 1973. During the same period,
Ahl was involved in the creation of a small computer for education
use, an early personal computer. When management refused to support
the concept, Ahl left DEC in 1974 to found the seminal computer
magazine, Creative Computing. The book remained popular, and was
re-published on several occasions.
Explosive growth: the home computer era
Commodore BASIC v2.0 on the Commodore 64
MSX BASIC version 3.0
The introduction of the first microcomputers in the mid-1970s was the
start of explosive growth for BASIC. It had the advantage that it was
fairly well known to the young designers and computer hobbyists who
took an interest in microcomputers. Despite Dijkstra's famous
judgement in 1975, "It is practically impossible to teach good
programming to students that have had a prior exposure to BASIC: as
potential programmers they are mentally mutilated beyond hope of
BASIC was one of the few languages that was both
high-level enough to be usable by those without training and small
enough to fit into the microcomputers of the day, making it the de
facto standard programming language on early microcomputers.
One of the first BASICs to appear was Tiny BASIC, a simple BASIC
variant designed by
Dennis Allison at the urging of
Bob Albrecht of
the Homebrew Computer Club. He had seen
BASIC on minicomputers and
felt it would be the perfect match for new machines like the MITS
Altair 8800. How to design and implement a stripped-down version of an
interpreter for the
BASIC language was covered in articles by Allison
in the first three quarterly issues of the People's Computer Company
newsletter published in 1975 and implementations with source code
published in Dr. Dobb's Journal of
Tiny BASIC Calisthenics &
Orthodontia: Running Light Without Overbyte. Versions were written by
Li-Chen Wang and Tom Pittman. In 1975 MITS released Altair BASIC,
Bill Gates and
Paul Allen as the company Micro-Soft,
which eventually grew into corporate giant Microsoft. The first Altair
version was co-written by Gates, Allen, and Monte Davidoff.
Almost universally, home computers of the 1980s had a ROM-resident
BASIC interpreter, which the machines booted directly into.[notes 1]
When the Apple II, PET 2001, and
TRS-80 were all released in 1977, all
BASIC as their primary programming language and operating
environment. Upon boot, a
BASIC interpreter in immediate mode was
presented, not the command-line interface used on systems running CP/M
Commodore Business Machines included a version of Microsoft
Apple II and
TRS-80 each had two versions of BASIC, a
smaller introductory version introduced with the initial releases of
the machines and a more advanced version developed as interest in the
platforms increased. As new companies entered the field, additional
versions were added that subtly changed the
BASIC family. The Atari
8-bit family had its own
Atari BASIC that was modified in order to fit
on an 8 kB ROM cartridge. The
BBC BASIC, developed
by Acorn Computers Ltd, incorporating many extra structured
programming keywords and advanced floating-point operation features.
As the popularity of
BASIC grew in this period, computer magazines
published complete source code in
BASIC for video 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). Many books of type-in programs
were also available, and in particular, Ahl published versions of the
BASIC games converted into the
Microsoft dialect and
published it from
Creative Computing as
BASIC Computer Games. This
book, and its sequels, provided hundreds of ready-to-go programs that
could be easily converted to practically any BASIC-running
platform. The book reached the stores in 1978, just as the
home computer market was starting off, and it became the first
million-selling computer book. Later packages, such as Learn to
BASIC would also have gaming as an introductory focus. On the
CP/M computers which soon became widespread in small
Microsoft BASIC (MBASIC) was one of the leading
IBM PC and compatibles
IBM Cassette BASIC 1.10
When IBM was designing the
IBM PC they followed the paradigm of
existing home computers in wanting to have a built-in BASIC. They
sourced this from
IBM Cassette BASIC – but Microsoft
also produced several other versions of
BASIC for MS-DOS/PC DOS
IBM Disk BASIC
IBM Disk BASIC (
IBM BASICA (
BASICA-compatible version that did not need IBM's ROM) and QBasic, all
typically bundled with the machine. In addition they produced the
Microsoft BASIC Compiler aimed at professional programmers. Turbo
Turbo Basic 1.0 in 1985 (successor
versions are still being marketed by the original author under the
Microsoft wrote the windowed
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. However, by the latter
half of the 1980s, users were increasingly using pre-made applications
written by others, rather than learning programming themselves, while
professional programmers now had a wide range of more advanced
languages available on small computers. C and later
C++ became the
languages of choice for professional "shrink wrap" application
Microsoft introduced Visual Basic, an evolutionary development
of QuickBasic. It included constructs from that language such as
block-structured control statements, parameterized subroutines, and
optional static typing, as well as object-oriented constructs from
other languages such as "With" and "For Each". The language retained
some compatibility with its predecessors, such as the Dim keyword for
declarations, "Gosub"/Return statements, and optional line numbers
which could be used to locate errors. An important driver for the
Visual Basic was as the new macro language for
Microsoft Excel, a spreadsheet program. To the surprise of many at
Microsoft who still initially marketed it as a language for hobbyists,
the language came 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 ease of development was more of
a concern than processing speed.[original research?]
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 large 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
Microsoft also produced
VBScript in 1996 and
Visual Basic .NET
in 2001. The latter has essentially the same power as C# and Java but
with syntax that reflects the original Basic language.
Three modern Basic variants: Mono Basic,
OpenOffice.org Basic and
Post-1990 versions and dialects
BASIC dialects have also sprung up since 1990, including
the open source
QB64 and FreeBASIC, inspired by QBasic, and the Visual
Basic For Qt and Gambas. Modern commercial
incarnations include PureBasic, PowerBASIC, Xojo,
Monkey X and True
BASIC (the direct successor to
Dartmouth BASIC from a company
controlled by Kurtz). Several web-based simple
BASIC interpreters also
now exist, including Quite
BASIC and Microsoft's Small Basic
(educational software). Versions of
BASIC have been showing up for use
on smartphones and tablets. Apple App Store contains such
implementations of B
ASIC programming language
ASIC programming language as smart BASIC, Basic!,
HotPaw Basic, BASIC-II, tech
BASIC and others. Android devices feature
such implementations of
BASIC as RFO
BASIC and Mintoris Basic.
Applications for some mobile computers with proprietary OS (CipherLab)
can be built with programming environment based on BASIC. An
application for the
Nintendo 3DS and
Nintendo DSi called Petit
Computer allows for programming in a slightly modified version of
BASIC with DS button support. A 3DS sequel was released in Japan
November 2014, in North America October 2015, and in Europe August
BASIC are available on graphing and otherwise programmable
calculators made by Texas Instruments, HP, Casio, and others.
Windows command line
QBasic, a version of
QuickBASIC without the linker to make
EXE files, is present in the
Windows NT and DOS-
Windows 95 streams of
operating systems and can be obtained for more recent releases like
Windows 7 which do not have them. Prior to DOS 5, the Basic
interpreter was GW-Basic. QuickBasic is part of a series of three
languages issued by
Microsoft for the home and office power user and
small scale professional development; QuickC and QuickPascal are the
other two. For
Windows 95 and 98, which do not have
by default, they can be copied from the installation disc, which will
have a set of directories for old and optional software; other missing
commands like Exe2Bin and others are in these same directories.
BASIC came to some video game systems, such as the Nintendo Famicom.
The various Microsoft, Lotus, and Corel office suites and related
products are programmable with
Visual Basic in one form or another,
including LotusScript, which is very similar to VBA 6. The Host
Explorer terminal emulator uses WWB as a macro language; or more
recently the programme and the suite in which it is contained is
programmable in an in-house Basic variant known as Hummingbird Basic.
VBScript variant is used for programming web content, Outlook 97,
Internet Explorer, and the Windows Script Host. WSH also has a Visual
Basic for Applications (VBA) engine installed as the third of the
default engines along with VBScript, JScript, and the numerous
proprietary or open source engines which can be installed like
PerlScript, a couple of Rexx-based engines, Python, Ruby, Tcl, Delphi,
XLNT, PHP, and others; meaning that the two versions of Basic can be
used along with the other mentioned languages, as well as LotusScript,
in a WSF file, through the component object model, and other WSH and
VBScript is one of the languages that can be
accessed by the 4Dos, 4NT, and Take Command enhanced shells. SaxBasic
and WWB are also very similar to the
Visual Basic line of Basic
implementations. The pre-Office 97 macro language for
is known as WordBASIC. Excel 4 and 5 use
Visual Basic itself as a
macro language. Chipmunk Basic, an old school interpreter similar to
BASICs of the 1970s, is available for GNU/Linux,
Microsoft Windows and
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. Popular computer magazines of
the day typically included type-in programs.
Futurist and sci-fi writer
David Brin mourned the loss of ubiquitous
BASIC in a 2006 Salon article as have others who first used
computers during this era. In turn, the article prompted
develop and release Small Basic. Dartmouth held a 50th anniversary
BASIC on 1 May 2014, as did other organisations;
at least one organisation of VBA programmers organised a 35th
anniversary observance in 1999.
Dartmouth College celebrated the 50th anniversary of the BASIC
language with a day of events on April 30, 2014. A short
documentary film was produced for the event.
LET—assigns a value (which may be the result of an expression) to a
DATA—holds a list of values which are assigned sequentially using
the READ command.
Program flow control
IF ... THEN ... ELSE—used to perform comparisons or make decisions.
FOR ... TO ... STEP ... NEXT—repeat a section of code a given
number of times. A variable that acts as a counter is available within
WHILE ... WEND and REPEAT ... UNTIL—repeat a section of code while
the specified condition is true. The condition may be evaluated before
each iteration of the loop, or after.
DO ... LOOP WHILE or UNTIL —repeat a section of code Forever or
While/Until the specified condition is true. The condition may be
evaluated before each iteration of the loop, or after.
GOTO—jumps to a numbered or labelled line in the program.
GOSUB—jumps to a numbered or labelled line, executes the code it
finds there until it reaches a RETURN Command, on which it jumps back
to the operator following the GOSUB – either after a colon, or on
the next line. This is used to implement subroutines.
ON ... GOTO/GOSUB—chooses where to jump based on the specified
Switch statement for other forms.
DEF FN—a pair of keywords introduced in the early 1960s to define
functions. The original
BASIC functions were modeled on FORTRAN
BASIC functions were one expression with
variable arguments, rather than subroutines, with a syntax on the
model of DEF FND(x) = x*x at the beginning of a program. Function
names were originally restricted to FN+one letter.
Input and output
LIST—displays all inputted code.
PRINT—displays a message on the screen or other output device.
INPUT—asks the user to enter the value of a variable. The statement
may include a prompt message.
TAB or AT: sets the position where the next character will be shown on
the screen or printed on paper.
List of functions
ATN—Arctangent value (result in radians)
COS—Cosine value (argument in radians)
LOG—Natural Logarithmic value
SIN—Sine value (argument in radians)
SQR—Square root value
TAN—Tangent value (argument in radians)
REM—holds a programmer's comment or REMark; often used to give a
title to the program and to help identify the purpose of a given
section of code.
USR—transfers program control to a machine language subroutine,
usually entered as an alphanumeric string or in a list of DATA
TRON—turns on display of each line number as it is run ("TRace ON").
This was useful for debugging or correcting of problems in a program.
TROFF—turns off the display line numbers.
ASM—some compilers such as Freebasic, Purebasic, and
Powerbasic also support inline assembly language, allowing the
programmer to intermix high-level and low-level code, typically
prefixed with "ASM" or "!" statements.
Data types and variables
Minimal versions of
BASIC had only integer variables and one- or
two-letter variable names, which minimized requirements of limited and
expensive memory (RAM). More powerful versions had floating-point
arithmetic, and variables could be labelled with names six or more
characters long. There were some problems and restrictions in early
implementations; for example, Applesoft allowed variable names to be
several characters long, but only the first two were significant, thus
it was possible to inadvertently write a program with variables "LOSS"
and "LOAN", which would be treated as being the same; assigning a
value to "LOAN" would silently overwrite the value intended as "LOSS".
Keywords could not be used in variables in many early BASICs; "SCORE"
would be interpreted as "SC" OR "E", where OR was a keyword. String
variables are usually distinguished in many microcomputer dialects by
having $ suffixed to their name, and values are often identified as
strings by being delimited by "double quotation marks". Arrays in
BASIC could contain integers, floating point or string variables.
Some dialects of
BASIC supported matrices and matrix operations,
useful for the solution of sets of simultaneous linear algebraic
equations. These dialects would directly support matrix operations
such as assignment, addition, multiplication (of compatible matrix
types), and evaluation of a determinant. Many microcomputer BASICs did
not support this data type; matrix operations were still possible, but
had to be programmed explicitly on array elements.
The original Dartmouth Basic was unusual in having a matrix keyword,
MAT.[notes 2] Although dropped by most later microprocessor
derivatives it is used in this example from the 1968 manual which
averages the numbers that are input:
5 LET S = 0
10 MAT INPUT V
20 LET N = NUM
30 IF N = 0 THEN 99
40 FOR I = 1 TO N
45 LET S = S + V(I)
50 NEXT I
60 PRINT S/N
70 GO TO 5
BASIC programmers on a home computer might start with a simple
program, perhaps using the language's PRINT statement to display a
message on the screen; a well-known and often-replicated example is
Kernighan and Ritchie's Hello world program:
10 PRINT "Hello, World!"
An infinite loop could be used to fill the display with the message.
BASIC versions 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
110 A$ = LEFT$(A$, 1)
120 IF A$ = "Y" OR A$ = "y" THEN
130 PRINT "Goodbye "; U$
The resulting dialog might resemble:
What is your name: Mike
How many stars do you want: 7
Do you want more stars? yes
How many stars do you want: 3
Do you want more stars? no
Second-generation BASICs (for example, VAX Basic, SuperBASIC, True
BBC BASIC, Pick BASIC,
PowerBASIC and arguably
COMAL) 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. In addition keywords and structures to support repetition,
selection and procedures with local variables were introduced.
The following example is in QuickBASIC:
DECLARE SUB PrintSomeStars (StarCount!)
INPUT "What is your name: ", UserName$
PRINT "Hello "; UserName$
INPUT "How many stars do you want: ", NumStars
INPUT "Do you want more stars? ", Answer$
LOOP UNTIL Answer$ <> ""
Answer$ = LEFT$(Answer$, 1)
LOOP WHILE UCASE$(Answer$) = "Y"
PRINT "Goodbye "; UserName$
SUB PrintSomeStars (StarCount)
REM This procedure uses a local variable called Stars$
Stars$ = STRING$(StarCount, "*")
BASIC dialects such as Visual Basic, Xojo, StarOffice
BlitzMax introduced features to support object-oriented and
event-driven programming paradigm. Most built-in procedures and
functions are now represented as methods of standard objects rather
than operators. Also, the
Operating System became more and more
available to the
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)
Console.Write("How many stars do you want: ")
NumStars = CInt(Console.ReadLine())
stars = New String("*", NumStars)
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)
ANSI/ISO/IEC Standard for Minimal BASIC:
ANSI X3.60-1978 "For minimal BASIC"
ISO/IEC 6373:1984 "Data Processing — Programming
Languages — Minimal BASIC"
BASIC (withdrawn, similar to ANSI X3.60-1978)
ANSI/ISO/IEC Standard for Full BASIC:
ANSI X3.113-1987 "Programming Languages Full BASIC"
INCITS/ISO/IEC 10279-1991 (R2005) "Information Technology –
Programming Languages – Full BASIC"
ANSI/ISO/IEC Addendum Defining Modules:
ANSI X3.113 Interpretations-1992 "
BASIC Technical Information Bulletin
# 1 Interpretations of ANSI 03.113-1987"
ISO/IEC 10279:1991/ Amd 1:1994 "Modules and Single Character Input
BASIC (withdrawn, similar to ANSI X3.113-1987)
List of Computers With On-Board BASIC
^ Probably the only exception was the Jupiter Ace, which instead used
^ From version 3 onwards.
^ Ring Team (5 December 2017). "Ring programming language and other
languages". ring-lang.net. ring-lang.
^ Kemeny, John G.; Kurtz, Thomas E. (1964). Basic: a manual for BASIC,
the elementary algebraic language designed for use with the Dartmouth
Time Sharing System (PDF) (1st ed.). Hanover, N.H.: Dartmouth College
Thomas E. Kurtz
Thomas E. Kurtz – History of Computer Programming Languages".
cis-alumni.org. Retrieved June 13, 2017.
^ Alfred, Randy (January 5, 2008). "May 1, 1964: First Basic Program
Runs". Wired. Retrieved June 13, 2017.
BASIC Programming Language Nearing 50th Anniversary". The
Spreadsheet. 16 (2): 3. February 27, 2014.
^ Gurer, Denise (January 1995). "Pioneering women in computer
science". Communications of the ACM. 38 (1): 45–54.
^ "BASIC". Jargon File. Retrieved June 13, 2017.
^ a b Ahl, David H. (1973). 101 Basic computer games. Morristown,
Creative Computing Press. OCLC 896774158.
^ Ahl, David H. (May 11, 1981). "Computer Games". InfoWorld.
Vol. 3 no. 9. p. 44. ISSN 0199-6649.
^ Edsger, Dijkstra (June 18, 1975). "How do we tell truths that might
hurt" (PDF). Selected Writings on Computing: A Personal Perspective.
Springer-Verlag (published 1982). pp. 129–131.
ISBN 0387906525. OCLC 693424350.
^ Pittman, Tom. "you had to pay $5 up front to get it..."
www.ittybittycomputers.com. Retrieved June 14, 2017.
^ "We have a BASIC". New Mexico Museum of Natural History and Science.
Archived from the original on November 30, 2012. Retrieved April 18,
^ Ahl, David H. (1979). More basic computer games. Morristown:
Creative Computing Press. ISBN 0894801376.
^ Ahl, David H. (1984). Big computer games. Morris Plains, N.J.:
Creative Computing Press. ISBN 0916688402.
^ "Osborne 1". oldcomputers.net. Retrieved June 14, 2017.
^ Pravin, Jain (2011). The Class Of Java. Pearson Education India.
^ "GNE: the C programming language". fysh.org. Retrieved June 14,
2017. During the 1980s, C compilers spread widely, and C became an
extremely popular language.
^ Brin, David (September 14, 2006). "Why Johnny Can't Code". Salon.
Archived from the original on September 18, 2013. Retrieved
^ "Small Basic".
Microsoft Developer Network. Archived from the
original on March 17, 2014. Retrieved June 19, 2017.
^ "Dartmouth plans celebration for 50th anniversary of
New Hampshire Union Leader. April 28, 2014. Retrieved June
^ "50th anniversary of
Google Search". Google.
BASIC at 50 – Event Schedule". Dartmouth College. Retrieved June
BASIC at 50". Dartmouth College. Retrieved June 14, 2017.
^ "KeyPgAsm". FreeBasic Wiki. Retrieved August 2, 2017.
^ "Inline x86 ASM". Pure Basic. Retrieved August 2, 2017.
^ "Using assembly-language in your code". Power Basic. Retrieved
August 2, 2017.
^ Kemeny, John G.; Kurtz, Thomas E. (January 1968). Basic: a manual
for BASIC, the elementary algebraic language designed for use with the
Dartmouth Time Sharing System (PDF) (4th ed.). Hanover, N.H.:
Dartmouth College Computation Center. p. 53.
^ "Differences Between
GW-BASIC and QBasic". 2003-05-12. Archived from
the original on 2013-10-19. Retrieved 2008-06-28.
Sammet, Jean E. (1969). Programming languages: history and
fundamentals. Englewood Cliffs, N.J.: Prentice-Hall.
Kurtz, Thomas E. (1981). "BASIC". In Wexelblat, Richard. History of
Programming Languages I. New York: ACM. pp. 515–537.
doi:10.1145/800025.1198404 (inactive June 19, 2017).
Kemeny, John G.; Kurtz, Thomas E. (1985). Back To BASIC: The History,
Corruption, and Future of the Language. Addison-Wesley. p. 141.
ISBN 9780201134339. OCLC 11399298.
Lien, David A. (1986). The Basic Handbook: Encyclopedia of the BASIC
Computer Language (3rd ed.). Compusoft Publishing.
ISBN 9780932760333. OCLC 12548310.
Wikibooks has a book on the topic of: Programming:BASIC
BASIC at Curlie (based on DMOZ)
"BASIC — Beginners All-purpose Symbolic Instruction Code". The
Encyclopedia of Computer Languages. Murdoch University.
The Birth of Basic on YouTube
Visual Basic .NET (VB.NET)
Dialects of the B
ASIC programming language
ASIC programming language (list)
Atari ST BASIC
Extended Color BASIC
Disk Extended Color BASIC
BASIC for OpenVMS
HP Time-Shared BASIC
Rocky Mountain BASIC
BASIC (Tandy, Casio, Sharp Pocket Computers)
BASIC (TI 99/4A)
TI Extended BASIC
TI Extended BASIC (aka XBasic)
Tymshare SUPER BASIC
Microsoft Small Basic
With object extensions
Basic For Qt (KBasic)
Visual Basic .NET
For mobile devices
Visual Basic .NET
Embedded Visual Basic
VB 5 for
Microsoft Excel 5.0
TRS-80 Basics (Level I, Level II, Level III)
Microsoft Small Basic
Basic For Qt