|
Don't know what should go here. Talk to me!
{{Inuse}}
Actually, what I meant was, if you'd like to know something. Ask!
'''BASIC''' is a family of high-level [[programming language|programming languages]]. Originally devised as an easy-to-use tool, it became widespread on [[home computer|home microcomputers]] in the [[1980s]], and remains popular to this day in a handful of heavily evolved dialects.
[[User:ZackStone|ZackStone]] 17:50, 9 October 2005 (UTC)
BASIC's name, coined in classic, [[computer science]] tradition to produce a nice [[acronym]], stands for
'''''B'''eginner's '''A'''ll-purpose '''S'''ymbolic '''I'''nstruction '''C'''ode'',¹ 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]]"). Several versions of the popular [[Jargon File]] once claimed that BASIC is a [[backronym]] created in the 1970s (recent versions have corrected this). Evidence from the original ''Dartmouth BASIC'' manual (1964) show this to be untrue, but numerous online dictionaries and reference works on the Internet have now proliferated the earlier Jargon File's error.
== History ==
=== Background ===
Prior to the mid-[[1960s]], computers were highly expensive tools used only for special-purpose tasks, which ran a single "job" at a time ([[batch processing]]). During the 1960s, however, computer prices started to drop to where even small companies could afford them, and their speed increased to the point they often sat idle, without jobs to run.
Programming languages of the era tended to be designed, like the machines on which they ran, for specific purposes such as scientific formula processing. Since single-job machines were expensive, the tendency was to consider execution speed the most important feature of all. In general, they were hard to use, and tended toward a certain "ugliness."
It was at this time that the [[time-sharing]] system concept started to become popular. In such a system the processing time of the main computer is "sliced up" and each user is given a small amount in alternation. The machines were fast enough for most users to feel they had a single machine all to themselves. In theory, timesharing reduced the cost of computing tremendously, as a single machine could be shared among hundreds of users.
=== Birth and early years ===
The original BASIC language was invented in [[1964]] by [[John George Kemeny|John Kemeny]] (1926–93) and [[Thomas Eugene Kurtz|Thomas Kurtz]] (1928–) at [[Dartmouth College]] and implemented by a team of Dartmouth students under their direction. 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 was 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 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 fast for small programs
# Not require an understanding of computer hardware
# Shield the user from the operating system
The language was based partly on [[FORTRAN programming language|FORTRAN II]] and partly on [[Algol programming language|ALGOL 60]], with additions to make it suitable for timesharing and, later, text processing and [[matrix (math)|matrix]] arithmetic. BASIC was first implemented on the [[GE-200 series|GE-265]]¹ mainframe which supported multiple terminals. Contrary to popular belief, it was a [[compiler|compiled]] language at the time of its introduction. 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. Some also derided BASIC as too slow and too simple.²
Nevertheless, the designers of the language decided that it should remain in the public ___domain in order to help it spread. They also made it available to high schools in the Dartmouth area and spent a considerable amount of effort in 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, and became fairly popular on newer [[minicomputer]]s like the [[Digital Equipment Corporation|DEC]] [[PDP]] series and the [[Data General]] [[Data General Nova|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 storage on paper tape (or later audio cassette tape: 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. BASIC also had the advantage that it was fairly well known to the young designers who took an interest in microcomputers at the time as a result of Kemeny and Kurtz's earlier proselytizing. One of the first to appear for this machine was [[Tiny BASIC programming language|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 [[1977]], [[Microsoft]] (then only two people—[[Bill Gates]] and [[Paul Allen]]) released [[Altair BASIC programming language|Altair BASIC]].
The version written for the Altair was co-authored by Gates, Allen and [[Monte Davidoff]]. Versions then started appearing on other platforms under license, and millions of copies and variants were soon in use; it became one of the standard languages on the [[Apple II family|Apple II]]. By [[1979]], Microsoft was talking with several microcomputer vendors, including [[International Business Machines|IBM]], about licensing a BASIC interpreter for their computers. A version was included in the IBM PC [[Read-only memory|ROM]] chips and PCs without hard disks automatically booted into BASIC.
Newer companies attempted to follow the successes of [[Altair]], [[IMSAI]], [[North Star]] and [[Apple Computer|Apple]], thus creating the [[home computer]] revolution; meanwhile, 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 the users of all other languages put together. Many programs, especially on the Apple II and IBM PC, depended on the presence of Microsoft's BASIC interpreter and would not run without it; in this way, Microsoft used its copyright licenses on its BASIC interpreter to gain leverage in negotiations with the computer vendors.
=== Maturity ===
Many newer BASIC versions were created during this period. Microsoft sold several versions of BASIC for MSDOS/PCDOS including [[Microsoft BASICA interpreter|BASICA]], [[Microsoft GW-BASIC interpreter|GW-BASIC]] (a BASICA-compatible version that didn't need IBM's ROM) and [[Quick BASIC programming language|Quick BASIC]]. Turbo Pascal-publisher [[Borland]] published [[Turbo BASIC programming language|Turbo BASIC]] 1.0 in 1985 (successor versions are still being sold by another company under the name [[PowerBASIC programming language|PowerBASIC]]). Various extensions of home computer BASIC appeared, typically with graphics, sound and [[DOS]] commands, as well as facilities for [[structured programming]]. Other languages used the widely-known BASIC syntax as the basis for otherwise completely different systems, [[GRASS programming language|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 interface]]s) that made BASIC less suitable for programming. At the same time, computers had progressed from a hobbyist interest to tools used primarily for applications written by others, and programming as a whole became less important for the growing majority of users. BASIC started to fade, though numerous versions remained available.
BASIC reversed in fortune once again with the introduction of [[Visual Basic]] from Microsoft. Though it is somewhat difficult to consider this language to be BASIC (despite its many familiar BASIC keywords) by the time of writing it had become one of the most-used languages on the [[Microsoft Windows|Windows]] platform. It is said to represent some 70 to 80% of all commercial development. Microsoft created a variant called WordBasic and used it in versions of [[MS Word]] before [[MS Word 97]]. Microsoft added [[Visual Basic for Applications|Visual Basic for Applications (VBA)]] to Excel 5.0 in 1993, to Access 95 in 1995, and to the rest of its Office suite in 1997. Internet Explorer 3.0 and later and Microsoft Outlook included a [[VBScript]] interpreter. The most recent version of Visual Basic is called [[Visual Basic .NET|VB.NET]]. The competing [[OpenOffice.org|OpenOffice]] suite includes a BASIC variant reportedly less powerful than its Microsoft counterpart. Many other BASIC variants and adaptations have also sprung up in the last few years, authored by hobbyists, equipment developers, and others who see the tremendous benefit of using the simplicity of the BASIC language for general programming needs.
== The language ==
=== Syntax ===
Basic 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 data structure|stack]]. Some early microcomputer implementations were this simple. If one adds a stack, nested FOR-loops and the GOSUB command can be added. An interpreter with these features requires the BASIC code to have line numbers.
Line numbers were a very distinctive aspect of classic home computer BASIC. Alas, the 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 later-added code exceeds the number-space 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 known in other languages like [[C programming language|C]] and [[Pascal programming language | Pascal]] (note also that some advanced versions of line number-based home computer BASICs incorporated such constructs as these to good effect):
<code>
* do - loop - while - until - exit
* on ''x'' goto / gosub (switch & case)
</code>
Recent variants such as [[Visual Basic]] have introduced [[object-oriented]] features, such as the For Each...Loop construct for looping through collections and arrays in VBA and Visual Basic 4 and later, and even [[inheritance (object-oriented programming)|inheritance]] in the latest version. Memory management is easier than in many other procedural programming languages because of the commonly included [[garbage collection (computer science)|garbage collector]] (presumably for which, however, one pays a run-time performance penalty).
This 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. This applies as well to other "old" computer languages like [[COBOL]] and [[FORTRAN]], although the BASIC movement is by far the largest; this may be explained by the large number of IT professionals who cut their teeth on 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/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 [[subroutine]]s without parameters or local variables. Most modern versions of BASIC such as [[Quick BASIC programming language|Microsoft QuickBASIC]] have added support for full subroutines and functions. This is another area where BASIC differs 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 by 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 good [[literal string|string]] manipulation functions. Early dialects already had a set of fundamental functions (LEFT$, MID$, RIGHT$) to deal with strings easily. Because 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 (computer science)|integer]] type. All numeric variables were [[floating point]]. Strings were dynamic in length. [[Array]]s 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 by a suffixed character; string identifiers end in $, whereas integers do not. In some dialects, variables must be declared (with DIM) on their first usage; other dialects do not require it, but can optionally enforce it—typically using a directive such as ''Option Explicit'' (in [[Visual Basic .NET|VB.NET]] it is on by default but can be turned off using ''Option Explicit Off''). Many dialects also support such additional types as 16- and 32-bit integers and floating-point numbers. Additionally, some allow user-defined types similar to Pascal [[record (computer science)|record]]s or C "structs".
Most BASIC dialects beyond the most primitive also support arrays of integers or other types. In some, arrays must be preallocated (with the DIM statement) before they can be used. Support for two- and higher-dimensional arrays, as well as arrays of non-integer types, is common.
DIM myIntArray (100) AS INTEGER
DIM myNameList (50) AS STRING
Depending on the dialect of BASIC and 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). However, in Visual Basic .NET, all arrays are zero-indexed, meaning the first element has an index of 0, as in the first of the above examples.
=== 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
(Note that there is no lexical distinction between the equality operator and the assignment operator in BASIC.)
== Availability and dialect variants ==
BASIC is available on nearly every microprocessor platform made. One interpreted free version, compliant with standards and highly cross-platform, is [[Bywater BASIC programming language|Bywater BASIC]] (bwBASIC). The interpreter is written in [[C programming language|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 interface]]s (GUIs). A free BASIC that includes a GUI builder, runs on [[Linux]] and Windows and is similar to Visual Basic is [[Phoenix Object Basic]].
[[Image:Qbasic.png|thumbnail|500px|A typical session in Microsoft QuickBASIC]]The best known compiled versions are Microsoft's [[Microsoft QuickBASIC compiler|QuickBASIC]] and [[QBasic programming language|QBasic]] (a version which does not generate standalone programs.) Some versions of [[Visual Basic programming language|Visual Basic]] are also compiled, though Microsoft has kept Visual Basic at least minimally compatible even with 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 BASIC standards. (True BASIC, Inc. was founded by the original creators of Dartmouth BASIC.)
[[REALbasic]], for Windows and Apple Macintosh, is a modern, object-oriented variant that generates executables for Microsoft Windows, Macintosh and Linux. [[REALbasic]] creates compiled code and generates native applications. [[REALbasic]] is very similar to Visual Basic so VB programs can be ported easily.
A simple BASIC dialect for the [[Parrot_virtual_machine|parrot]] [[virtual machine]] shows a BASIC interpreter implementation in an assembly-like language. [[PureBasic programming language | PureBasic]] is a variant with simple syntax that produces fast, tiny executable files for Windows and Linux, and is additionally capable of compiling in-line assembly instructions. The [[SmallBASIC programming language|SmallBASIC]] dialect runs on many platforms (Win32, DOS, Linux and PalmOS) and comes with a GNU license ([[GPL]]).
'''Business Basic''' is the name given collectively to the variants of BASIC which were specialised for business use on mini-computers in the 1970s. Business Basics added indexed file access methods to the normal set of BASIC commands, and were optimised for other input/output access. The two major families of Business Basic were [[MAI BasicFour]], and [[Data General Business Basic]]. In the 1980s, Business Basics were ported from their original proprietary environments to many [[Unix]] platforms, and to [[DOS]].
Other variants include [[RapidQ]], a free cross-platform BASIC compiler with additional capabilites for [[Win32 console|console]] and [[GUI]] programming.
==[[Hello world program]]==
10 PRINT "Hello, world!"
20 END
== Examples ==
'''Sample 1: Unstructured original BASIC''' ([[Applesoft BASIC programming language|Applesoft BASIC]])
10 INPUT "What is your name: "; U$
20 PRINT "Hello "; U$
25 REM
30 INPUT "How many stars do you want: "; N
35 S$ = ""
40 FOR I = 1 TO N
50 S$ = S$ + "*"
55 NEXT I
60 PRINT S$
65 REM
70 INPUT "Do you want more stars? "; A$
80 IF LEN(A$) = 0 THEN GOTO 70
90 A$ = LEFT$(A$, 1)
100 IF (A$ = "Y") OR (A$ = "y") THEN GOTO 30
110 PRINT "Goodbye ";
120 FOR I = 1 TO 200
130 PRINT U$; " ";
140 NEXT I
150 PRINT
'''Sample 2: Modern Structured BASIC''' (e.g. [[QBASIC programming language|QBASIC]])
INPUT "What is your name"; UserName$
PRINT "Hello "; UserName$
DO
INPUT "How many stars do you want"; NumStars
Stars$ = ""
Stars$ = REPEAT$("*", NumStars) ' <- ANSI BASIC
''--or--''
Stars$ = STRING$(NumStars, "*") ' <- MS BASIC
PRINT Stars$
DO
INPUT "Do you want more stars"; Answer$
LOOP UNTIL Answer$ <> ""
Answer$ = LEFT$(Answer$, 1)
LOOP WHILE UCASE$(Answer$) = "Y"
PRINT "Goodbye ";
FOR I = 1 TO 200
PRINT UserName$; " ";
NEXT I
PRINT
== Dialects ==
<!-- *[[dla basic]] -- The only stuff about "dla basic" I'm able to find by googling is some Polish web pages listing the phrase in e.g. VIC-20 & C64 specifications of ROM allocation; after checking with a Polish-English dictionary, I found that "dla" means "for", indicating that the phrase just means "for basic"... So please give some docs to prove "dla basic" existence. -->
*[[Altair BASIC]] (MITS Altair, S-100; Microsoft's first product)
*[[AmigaBASIC|Amiga BASIC]] (Commodore Amiga)
*[[AMOS BASIC]] (Commodore Amiga)
*[[Apple Business BASIC]] (Apple ///)
*[[Applesoft BASIC]] (Apple II)
*[[ASIC programming language|ASIC]] (MS-DOS)
*[[Atari 2600 Basic Programming]] (Atari 2600 video game console)
*[[ATARI BASIC]] (aka Sheperdson BASIC) (Atari 8-bit family)
*[[Atari Microsoft BASIC II]] (Atari 8-bit family)
*[[B32 Business Basic]] (Data General Eclipse MV, UNIX, MS-DOS)
*[[BASIC09]] (OS-9 and OS-9 68K on Motorola 6809 and 68K CPUs, respectively)
*[[Microsoft BASICA interpreter|BASICA]] (Advanced BASIC, available in ROM on IBM PCs) (later disk based versions for PC-DOS)
*[[BASCOM]] (BASIC compilers for the 8051 and AVR chips)
*[[BASIC-11]] (DEC PDP-11, RSX-11)
*[[BASIC A Plus|BASIC A+]] (Atari 8-bit family)
*[[BASIC-E]] (aka 'submarine BASIC') (CP/M)
*[[Basic Plus|BASIC-PLUS]] (DEC PDP-11, RSTS/E, RSX-11)
*[[BASICODE]] (KC85)
*[[BASIC XE]] (Atari 130XE)
*[[BBC BASIC]] (Acorn/BBC Micro, RISC OS, Tiki 100, Cambridge Z88, CP/M, MS-DOS)
*[[Blitz BASIC]] (Win32, Commodore Amiga)
*[[Business Basic]]
*[[Bywater BASIC]] (aka bwBASIC) (MS-DOS, POSIX)
*[[Caché Basic]] (One of the two scripting languages in [[Caché]] Database)
*[[CBASIC]] (successor of BASIC-E) (CP/M, MS-DOS)
*[[Chipmunk Basic]] (Apple Macintosh, CLI ports for Win32, GNU/Linux; copyrighted freeware)
*[[Color BASIC]] (Tandy Radio Shack TRS-80 Color Computer, aka CoCo)
*[[Commodore BASIC]] (Commodore 8-bit family)
*[[HP BASIC for OpenVMS|Compaq BASIC for OpenVMS]]
*[[DarkBASIC]] & [[DarkBASIC Professional]]
*[[Dartmouth BASIC]] (see also True BASIC)
*[[Data General Business Basic]] (Data General Nova and later DG minicomputers)
*[[HP BASIC for OpenVMS|DEC BASIC for OpenVMS]]
*[[Ethos Game Basic|Ethos Basic]] (MS Windows)
*[[Extended Color BASIC]] (TRS-80 Color Computer)
*[[FaST Basic]] (Atari ST)
*[[FreeBASIC]] (DOS, MS Windows and GNU/Linux) (GPL)
*[[FutureBASIC]] (Apple Macintosh)
*[[Gambas]] (GNU/Linux) (similar approach as Visual Basic)
*[[geoBASIC (GEOS)|geoBASIC]] (GEOS on Commodore 64)
*[[GeoBASIC (Leica)|GeoBASIC]] (Leica TPS 1000/1100 surveying stations)
*[[Gnome Basic]] (GNU/Linux) (discontinued Visual Basic clone)
*[[GFA BASIC]] (Commodore Amiga, Atari ST)
*[[Microsoft GW-BASIC interpreter|GW-BASIC]] (MS-DOS) (BASICA compatible; independent of IBM ROM routines)
*[[Hbasic]] (GNU/Linux) (similar approach as Visual Basic)
*[[HiSoft Basic]] (Atari ST, ZX Spectrum)
*[[HotBasic]] (Win32, Linux)
*[[HotPaw Basic programming language|HotPaw Basic]] (aka yBasic, nee cbasPad Pro) (PalmOS)
*[[HP BASIC]] (developed by HP to control electronics instruments through [[GPIB]] interfaces)
*[[HP BASIC for OpenVMS]] (originating from DEC's BASIC-PLUS-2 for RSX-11/M)
*[[HTBasic]] (TransEra's extension of HP's own HP BASIC)
*[[IBasic]] (MS Windows)
*[[Integer BASIC]] (Apple II)
*[[JustBasic]] (Win32)
*[[Liberty BASIC programming language|Liberty BASIC]] (MS Windows)
*[[Locomotive BASIC]] (Amstrad CPC)
*[[LotusScript]] (Lotus Notes)
*[[Luxor Basic]] (Luxor ABC80)
*[[MAI Basic Four Business Basic]] (misc. minicomputers)
*[[Mallard BASIC]] (Amstrad PCW, CP/M on ZX Spectrum +3)
*[[Microsoft BASIC]] (overview of Microsoft BASIC variants) (many microcomputer platforms)
*[[MBASIC]] (Microsoft BASIC for CP/M)
*[[MSX BASIC]] (MSX)
*[[N88-BASIC]] (Old NEC PC8801/9801) (Japan's most popular BASIC based on Microsoft's one)
*[[Northstar BASIC]] (Processor Technology, Northstar, later adapted to [[x86]] as Bazic '86)
*[[Omikron Basic]] (Atari ST)
*[[Phoenix Object Basic programming language|Phoenix Object Basic]] (GNU/Linux)
*[[PowerBASIC]] (successor of Turbo BASIC) (MSDOS, Win32)
*[[PureBasic]] (Win32, GNU/Linux and Commodore Amiga)
*[[QBASIC programming language|QBASIC]] (MS-DOS)
*[[Microsoft QuickBASIC compiler|QuickBASIC]] (MS-DOS)
*[[RapidQ]] (Cross-platform, free, no longer being developed)<!-- semi-oo interpreter. Includes RAD IDE -->
*[[REALbasic]] (Apple Macintosh, Win32)
*[[Revelation BASIC]] (MS-DOS)
*[[SAM Basic programming language|SAM BASIC]] (Sam Coupé)
*[[ScriptBasic]] (Win32 and GNU/Linux) (released under the [[Lesser General Public License]] aka LGPL)
*[[sdlBasic]] multiplatform, based on the core of [[wxBasic]], but with [[Simple_DirectMedia_Layer|SDL]] library.
*[[Sharp BASIC]] (Sharp pocket computers)
*[[Sinclair BASIC]] (ZX80, ZX81/TS1000, ZX Spectrum)
*[[SmallBASIC]] (GNU/Linux, MS-DOS, Win32, PalmOS; GPL)
*[[SmartBASIC]] (Coleco Adam)
*[[ST BASIC]] (Atari ST)
*[[StarOffice Basic]] (aka StarBasic) (OpenOffice, StarOffice)
*[[STOS BASIC]] (Atari ST)
*[[SuperBasic]] (Sinclair QL)
*[[THEOS Multi-User Basic]]
*[[TI-BASIC (calculators)|TI-BASIC]] (Texas Instruments programmable calculators)
*[[TI BASIC (TI 99/4A)|TI BASIC]] (Texas Instruments TI 99/4A) (note: no hyphen)
*[[TI Extended BASIC programming language|TI Extended BASIC]] (ditto)
*[[Tiny BASIC]] (any microcomputer, but mostly implemented on early S-100 machines)
*[[TRS-80 Level I BASIC programming language|TRS-80 Level I BASIC]] (TRS-80) (based on TinyBASIC)
*[[TRS-80 Level II BASIC programming language|TRS-80 Level II BASIC]] (TRS-80)
*[[True BASIC]] (MS-DOS, MS Windows, Apple Macintosh)
*[[Turbo BASIC]] (successor of BASIC/Z) (see PowerBASIC)
*[[Turbo Basic XL]] (based on ATARI BASIC) (Atari 8-bit family)
*[[HP BASIC for OpenVMS|VAX BASIC for OpenVMS]]
*[[VBScript]] (MS ASP, MS Windows with WSH)
*[[Vilnius BASIC]]
*[[Visual Basic]] (MS Windows)
*[[Visual Basic .NET]] (MS Windows)
*[[Visual Basic for Applications|Visual Basic for Applications (VBA)]] (MS Office on MS Windows and Apple Macintosh)
*[[Watcom Basic]]
*[[WordBasic]] (versions of MS Word before MS Word 97)
*[[wxBasic]] (BASIC interpreter using [[wxWidgets]])
*[[XBasic]] (Win32, GNU/Linux) (GPL)
*[[Yabasic interpreter|Yabasic]] (Win32, GNU/Linux, Playstation 2) (GPL)
==BASIC extensions==
*[[BASIC 8.0]] (Commodore 128)
*[[Simons' BASIC]] (Commodore 64)
==Related languages==
*[[COMAL programming language|COMAL]] (misc. microcomputers)
*[[Open programming language|OPL]] (Psion PDAs)
*[[FORTRAN]]
*[[ALGOL]]
==Tools==
*[[BCX]] (Win32, BASIC to C translator)
== 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") $18 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")
==Notes==
# Per correspondence with Thomas E. Kurtz.
# In a 1968 article [[Edsger Dijkstra]] considered programming languages using <code>[[GOTO]]</code> statements for program structuring purposes harmful for the productivity of the programmer as well as the quality of the resulting code (''Communications of the ACM'' Volume 11, 147-148. 1968, reprinted [http://www.acm.org/classics/oct95/ here]). This article does not mention any particular programming language. It merely states that the overuse of <code>GOTO</code> is a Bad Thing and gives the technical reasons why this should be so.<br /><br />In a 1975 tongue-in-cheek article, published in ''Sigplan Notices'' Volume 17 No. 5, ''How do We Tell Truths that Might Hurt'' (reprinted [http://www.cs.virginia.edu/~evans/cs655/readings/ewd498.html here]), he gives a list of uncomfortable ''truths'', including his opinion of several programming languages of the time, such as BASIC. It appears that many people confuse the two articles and conclude that Dijkstra particularly hated BASIC as a result of its GOTO statement. However BASIC receives no worse treatment than [[PL/I]], [[COBOL]] or [[APL programming language|APL]] in his articles.
==References==
* Lien, David A. (1986). ''The Basic Handbook: Encyclopedia of the BASIC Computer Language'' (3rd ed.). Compusoft Publishing. ISBN 0932760333. Documents dialect variation for over 250 versions of BASIC.
* Kemeny, John G.; & Kurtz, Thomas E. (1985). ''Back To BASIC -- The History, Corruption, and Future of the Language''. Addison Wesley Publishing. ISBN 0-201-13433-0.
== External links ==
*[http://www.blitzbasic.com/ BlitzBasic: Basic Language designed for very easy DirectX 3D and 2D game Creation]
*[http://wxbasic.sourceforge.net/ wxBASIC: Open Source BASIC interpreter with cross-platform GUI library]
*[http://gambas.sourceforge.net/ Gambas Basic: Open Source similar to Visual Basic]
*[http://www.darkbasic.com/ DarkBasic: Basic Language Designed for DirectX Game Programming]
*[http://www.gfasoft.gfa.net/eng/ GFA Basic]
*[http://www.ethosbasic.com/ Ethos Basic]
*[http://www.bitsavers.org/pdf/dartmouth/BASIC_Oct64.pdf A PDF version of the original Dartmouth BASIC manual]
*[http://www.freebasic.net/ FreeBASIC, an open source extendable compilier] Speed comes close to c++
<!-- *[http://www.mixtel.pwp.blueyonder.co.uk/tinyb.html Tiny BASIC] -->
<!-- (Dead link, so removed from text) -->
<!-- The following line might pertain to the entire article, or just to -->
<!-- note 1. Research into this should be done. --Wernher -->
''Based on an article originally written for [[Nupedia]] by Peter Fedorow <fedorowpATyahoo.com>, licensed under the GNU Free Documentation License.''
{{Major programming languages small}}
[[Category:Imperative programming languages]]
[[Category:Major programming languages]]
[[Category:Programming languages]]
[[Category:ANSI standards]]
[[Category:ISO standards]]
[[ca:BASIC]]
[[cs:BASIC]]
[[da:BASIC]]
[[de:BASIC]]
[[et:BASIC]]
[[es:BASIC]]
[[eo:BASIC Komputillingvo]]
[[fr:Basic]]
[[hr:BASIC]]
[[it:BASIC]]
[[ko:BASIC]]
[[hu:BASIC programozási nyelv]]
[[nl:BASIC]]
[[ja:BASIC]]
[[no:BASIC]]
[[pl:BASIC]]
[[pt:BASIC]]
[[ru:Бейсик]]
[[sr:БАСИЦ]]
[[fi:Basic]]
[[sv:BASIC]]
[[tr:BASIC]]
[[uk:Бейсік]]
[[zh:BASIC]]
| 