Editing BASIC

{{Short description|Family of programming languages}}
{{Other uses}}
{{Use mdy dates|date=March 2018}}
{{Infobox programming language
| screenshot = AtariBASIC.png
| screenshot caption = [[Atari BASIC]] (1979) for [[Atari 8-bit computers]]
| paradigm = [[Non-structured programming|Non-structured]], later [[Procedural programming|procedural]], later [[Object-oriented programming|object-oriented]]
| designers = {{plainlist|
* [[John G. Kemeny]]
* [[Thomas E. Kurtz]]
}}
| released = {{Start date and age|1964|5|1}}
| implementations = {{flatlist|class=nowraplinks |
* [[Dartmouth BASIC]]
* [[Tiny BASIC]]
* [[Applesoft BASIC]]
* [[Atari BASIC]]
* [[Sinclair BASIC]]
* [[Commodore BASIC]]
* [[BBC BASIC]]
* [[TI-BASIC]]
* [[Casio BASIC]]
* [[Microsoft BASIC]]
* [[QB64]]
* [[FreeBASIC]]
* [[Liberty BASIC]]
* [[PowerBASIC]]
* [[QuickBASIC]]
* [[Yabasic|YABASIC]]
}}
| dialects = 
| influenced by = {{flatlist|
* [[ALGOL 60]]
* [[Fortran|FORTRAN II]]
* [[JOSS]]
}}
| influenced = {{flatlist|
* [[COMAL]]
* [[Visual Basic (classic)|Visual Basic]]
* [[Visual Basic .NET]]
* [[GRASS (programming language)|GRASS]]
* [[Xojo]]
}}
| wikibooks = BASIC Programming
}}

'''BASIC''' ('''Beginners' All-purpose Symbolic Instruction Code''')<ref>{{Cite book|url=http://bitsavers.trailing-edge.com/pdf/dartmouth/BASIC_Oct64.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.trailing-edge.com/pdf/dartmouth/BASIC_Oct64.pdf |archive-date=2022-10-09 |url-status=live|title=Basic: a manual for BASIC, the elementary algebraic language designed for use with the Dartmouth Time Sharing System|last1=Kemeny|first1=John G.|last2=Kurtz|first2=Thomas E.|date=1963|publisher=Dartmouth College Computation Center|location=Hanover, N.H.|language=en|edition=1st}}</ref> is a family of [[General-purpose programming language|general-purpose]], [[high-level programming language]]s designed for ease of use. [[Dartmouth BASIC|The original version]] was created by [[John G. Kemeny]] and [[Thomas E. Kurtz]] at [[Dartmouth College]] in 1964. They wanted to enable students in non-scientific fields to use computers. At the time, nearly all computers required writing custom software, which only [[scientist]]s and [[mathematician]]s tended to learn.

In addition to the programming language, Kemeny and Kurtz developed the [[Dartmouth Time-Sharing System]] (DTSS), which allowed multiple users to edit and run BASIC programs simultaneously on remote terminals. This general model became popular on [[minicomputer]] systems like the [[PDP-11]] and [[Data General Nova]] in the late 1960s and early 1970s. [[Hewlett-Packard]] produced an entire computer line for this method of operation, introducing the [[HP2000]] series in the late 1960s and continuing sales into the 1980s. Many early video games trace their history to one of these versions of BASIC.

The emergence of [[microcomputer]]s in the mid-1970s led to the development of multiple BASIC dialects, including [[Microsoft BASIC]] in 1975. Due to the tiny [[main memory]] available on these machines, often 4&nbsp;KB, a variety of [[Tiny BASIC]] dialects were also created. BASIC was available for almost any system of the era and became the ''de facto'' programming language for [[home computer]] systems that emerged in the late 1970s. These [[Personal Computer|PC]]s almost always had a [[BASIC interpreter]] installed by default, often in the machine's [[firmware]] or sometimes on a [[read-only memory|ROM]] cartridge.

BASIC declined in popularity in the 1990s, as more powerful microcomputers came to market and programming languages with advanced features (such as [[Pascal (programming language)|Pascal]] and [[C (programming language)|C]]) became tenable on such computers. By then, most nontechnical personal computer users relied on pre-written applications rather than writing their own programs. In 1991, [[Microsoft]] released [[Visual Basic (classic)|Visual Basic]], combining an updated version of BASIC with a [[Graphical user interface builder|visual forms builder]]. This reignited use of the language and "VB" remains a major programming language<ref>{{cite web|url=https://visualstudiomagazine.com/articles/2019/02/12/tiobe-feb-19.aspx|title=VB.NET Popularity Still Rising|first=David|last=Ramel|website=Visual Studio Magazine|date=2019-02-12|access-date=2023-03-28}}</ref><ref>{{cite web|url=https://raygun.com/blog/programming-languages/|title=40 most popular programming languages 2023: When and how to use them|website=Raygun|first=David|last=Swersky|date=2023-01-25|access-date=2023-03-25}}</ref> in the form of [[Visual Basic (.NET)|VB.NET]], while a hobbyist scene for BASIC more broadly continues to exist.<ref name="theregister_com">{{cite web|url=https://www.theregister.com/2023/03/28/nostalgic_for_basic/|title=Nostalgic for VB? BASIC is anything but dead|first=Liam|last=Proven|website=[[The Register]]|date=2023-03-28|access-date=2023-09-27}}</ref><ref>{{cite web|url=https://www.codeproject.com/Articles/5347103/BASIC-is-Not-Dead-Time-to-Erase-the-Myths-about-Ba|website=[[Code Project]]|title=BASIC is Not Dead. Time to Erase the Myths about Basic.|first=Chris|last=Boss|date=2022-11-15|access-date=2024-01-31}}</ref>

== Origin ==
[[John G. Kemeny]] was the chairman of the Dartmouth College Mathematics Department. Based largely on his reputation as an innovator in math teaching, in 1959 the college won an [[Alfred P. Sloan Foundation]] award for $500,000 to build a new department building.<ref>{{cite magazine |url=https://content.time.com/time/subscriber/article/0,33009,825616,00.html |title= High Math at Hanover |date=23 February 1959 |magazine=Time}}</ref> [[Thomas E. Kurtz]] had joined the department in 1956, and from the 1960s Kemeny and Kurtz agreed on the need for programming literacy among students outside the traditional [[Science, technology, engineering, and mathematics|STEM]] fields. Kemeny later noted that "Our vision was that every student on campus should have access to a [[computer]], and any faculty member should be able to use a computer in the classroom whenever appropriate. It was as simple as that."{{sfn|Time|2014}}

Kemeny and Kurtz had made two previous experiments with simplified languages, [[DARSIMCO]] (Dartmouth Simplified Code) and [[DOPE (Dartmouth Oversimplified Programming Experiment)]]. These did not progress past a single freshman class. New experiments using [[Fortran]] and [[ALGOL]] followed, but Kurtz concluded these languages were too tricky for what they desired. As Kurtz noted, Fortran had numerous oddly formed commands, notably an "almost impossible-to-memorize convention for specifying a loop: {{code|2=fortran|1=DO 100, I = 1, 10, 2}}. Is it '1, 10, 2' or '1, 2, 10', and is the comma after the line number required or not?"{{sfn|Time|2014}}

Moreover, the lack of any sort of immediate feedback was a key problem; the machines of the era used [[batch processing]] and took a long time to complete a run of a program. While Kurtz was visiting [[MIT]], [[John McCarthy (computer scientist)|John McCarthy]] suggested that [[time-sharing]] offered a solution; a single machine could divide up its processing time among many users, giving them the illusion of having a (slow) computer to themselves.<ref name="Rankin">{{Citation | last = Rankin| first = Joy Lisi | title = A People's History of Computing in the United States | place = Cambridge, Massachusetts  | publisher = Harvard University Press | year = 2018| isbn = 9780674970977 }}, p. 23</ref> Small programs would return results in a few seconds. This led to increasing interest in a system using time-sharing and a new language specifically for use by non-STEM students.{{sfn|Time|2014}}

Kemeny wrote the first version of BASIC. The [[acronym]] ''BASIC'' comes from the name of an unpublished paper by Thomas Kurtz.<ref>{{Cite web|url=http://www.catb.org/jargon/html/B/BASIC.html|title=BASIC|website=[[Jargon File]]|access-date=June 13, 2017}}</ref> The new language was heavily patterned on FORTRAN II; statements were one-to-a-line, numbers were used to indicate the target of loops and branches, and many of the commands were similar or identical to Fortran. However, the [[Syntax (programming languages)|syntax]] was changed wherever it could be improved. For instance, the difficult to remember <code>DO</code> loop was replaced by the much easier to remember {{code|2=basic|1=FOR I = 1 TO 10 STEP 2}}, and the line number used in the DO was instead indicated by the <code>NEXT I</code>.{{efn|Fortran's DO had a <code>continue</code> for this purpose, but still required the line number to be entered.}} Likewise, the cryptic <code>IF</code> statement of Fortran, whose syntax matched a particular instruction of the machine on which it was originally written, became the simpler {{code|2=basic|1=IF I=5 THEN GOTO 100}}. These changes made the language much less idiosyncratic while still having an overall structure and feel similar to the original FORTRAN.{{sfn|Time|2014}}

The project received a $300,000 grant from the [[National Science Foundation]], which was used to purchase a [[GE-225]] computer for processing, and a Datanet-30 realtime processor to handle the [[Teletype Model 33]] [[teleprinter]]s used for input and output. A team of a dozen undergraduates worked on the project for about a year, writing both the DTSS system and the BASIC compiler.{{sfn|Time|2014}} The first version BASIC language was released on 1 May 1964.<ref>{{Cite web|url=http://cis-alumni.org/TKurtz.html|title=Thomas E. Kurtz – History of Computer Programming Languages|website=cis-alumni.org|language=en|access-date=June 13, 2017}}</ref><ref>{{cite magazine|url=https://www.wired.com/2008/05/dayintech-0501-2/|title=May 1, 1964: First Basic Program Runs|last=Alfred|first=Randy|magazine=[[Wired (magazine)|Wired]]|date=January 5, 2008|access-date=June 13, 2017}}</ref>

Initially, BASIC concentrated on supporting straightforward mathematical work, with [[matrix (mathematics)|matrix]] arithmetic support from its initial implementation as a batch language, and [[character string]] functionality being added by 1965. Usage in the university rapidly expanded, requiring the main CPU to be replaced by a GE-235,{{sfn|Time|2014}} and still later by a GE-635. By the early 1970s there were hundreds of terminals connected to the machines at Dartmouth, some of them remotely.

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 expensive computers, usually available only to lease. They also made it available to high schools in the [[Hanover, New Hampshire]], area and regionally throughout New England on Teletype Model 33 and Model 35 teleprinter terminals connected to Dartmouth via dial-up phone lines, and they 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]]''.

New Hampshire recognized the accomplishment in 2019 when it erected a highway historical marker in Hanover describing the creation of "the first user-friendly programming language".<ref name = "Brooks, Concord Monitor, 2019">{{ Cite web | url = https://granitegeek.concordmonitor.com/2019/06/11/finally-a-historical-marker-that-talks-about-something-important/ | title = Finally, a historical marker that talks about something important | access-date = 11 August 2019 | first = David | last = Brooks | date = 11 June 2019 | website = [[Concord Monitor]] | archive-url = https://web.archive.org/web/20190611180750/https://granitegeek.concordmonitor.com/2019/06/11/finally-a-historical-marker-that-talks-about-something-important/ | archive-date = 11 June 2019 | df = dmy-all }}</ref>

== Spread on time-sharing services ==
The emergence of BASIC took place as part of a wider movement toward time-sharing systems. First conceptualized during the late 1950s, the idea became so dominant in the computer industry by the early 1960s that its proponents were speaking of a future in which users would "buy time on the computer much the same way that the average household buys power and water from utility companies".<ref name="wfbauer">Bauer, W. F., ''[https://www.computer.org/web/csdl/index/-/csdl/proceedings/afips/1958/5053/00/50530046.pdf Computer design from the programmer's viewpoint] {{Webarchive|url=https://web.archive.org/web/20160723012920/https://www.computer.org/web/csdl/index/-/csdl/proceedings/afips/1958/5053/00/50530046.pdf |date=July 23, 2016 }}'' (Eastern Joint Computer Conference, December 1958) One of the first descriptions of computer time-sharing.</ref>

General Electric, having worked on the Dartmouth project, wrote their own underlying operating system and launched an online time-sharing system known as Mark I. It featured BASIC as one of its primary selling points. Other companies in the emerging field quickly followed suit; [[Tymshare]] introduced [[SUPER BASIC]] in 1968, [[CompuServe]] had a version on the [[DEC-10]] at their launch in 1969, and by the early 1970s BASIC was largely universal on general-purpose [[mainframe computers]]. Even [[IBM]] eventually joined the club with the introduction of VS-BASIC in 1973.<ref>{{cite magazine |magazine=Computerworld |date=5 December 1973 |title=IBM VS the World: That's How It Is |url=https://books.google.com/books?id=sWeKU3wFLREC&pg=PA15}}</ref>

Although time-sharing services with BASIC were successful for a time, the widespread success predicted earlier was not to be. The emergence of minicomputers during the same period, and especially low-cost microcomputers in the mid-1970s, allowed anyone to purchase and run their own systems rather than buy online time which was typically billed at dollars per minute.{{efn|Tymshare charged about {{US$|10}} per hour ({{Inflation|US|10|1970|fmt=eq}}) for accessing their systems.}}<ref>{{cite book |title=A History of Online Information Services, 1963–1976 |first1= Charles |last1=Bourne |first2=Trudi Bellardo |last2=Hahn |page=387 |url=https://books.google.com/books?id=LTTvmUU8rskC&pg=PA387|isbn= 9780262261753 |date= August 2003 |publisher= MIT Press }}</ref>

== Spread on minicomputers ==
[[File:ESO Hewlett Packard 2116 minicomputer.jpg|thumb|The HP 2000 system was designed to run time-shared BASIC as its primary task.]]

BASIC, by its very nature of being small, was naturally suited to porting to the [[minicomputer]] market, which was emerging at the same time as the time-sharing services. These machines had small [[main memory]], perhaps as little as 4&nbsp;KB in modern terminology,{{efn|Widely regarded as the first "true" mini, the PDP-8's 12-bit memory space allowed 4,096 address of 12-bits each, or 6,144 bytes.}} and lacked high-performance storage like [[hard drive]]s that make compilers practical. On these systems, BASIC was normally implemented as an interpreter rather than a compiler due to its lower requirement for working memory.{{efn|Interpreters are ultimately similar to compilers in the tasks they perform, converting source code to machine code, but differ in when they perform it. Compilers convert the entire program at once and output a separate runnable program. Interpreters generally convert only a single line at a time (or even just a portion of it) and then immediately release that code once the line has completed running. This means they require only enough memory to run a single line, and do not require some form of high-performance secondary memory like a hard drive.}}

A particularly important example was [[HP Time-Shared BASIC]], which, like the original Dartmouth system, used two computers working together to implement a time-sharing system. The first, a low-end machine in the [[HP 2100]] series, was used to control user input and save and load their programs to tape or disk. The other, a high-end version of the same underlying machine, ran the programs and generated output. For a cost of about $100,000, one could own a machine capable of running between 16 and 32 users at the same time.<ref name=ts>{{Cite web |url=https://www.hpmuseum.net/display_item.php?hw=411 |title= 2000 Timeshare System}}</ref> The system, bundled as the HP 2000, was the first mini platform to offer time-sharing and was an immediate runaway success, catapulting HP to become the third-largest vendor in the minicomputer space, behind [[Digital Equipment Corporation|DEC]] and [[Data General]] (DG).<ref>{{Cite magazine |url=http://hpmemoryproject.org/news/tenyears_comp/measure_page_00.htm |title= Passing the 10-year mark |magazine= MEASURE Magazine |date= October 1976 |publisher= Hewlett Packard}}</ref>

DEC, the leader in the minicomputer space since the mid-1960s, had initially ignored BASIC. This was due to their work with [[RAND Corporation]], who had purchased a [[PDP-6]] to run their [[JOSS]] language, which was conceptually very similar to BASIC.<ref>{{cite tech report |title=The JOSS Years: Reflections on an experiment |last=Marks |first=Shirley |date=December 1971 |publisher=Rand |url=https://www.rand.org/content/dam/rand/pubs/reports/2008/R918.pdf |archive-url=https://ghostarchive.org/archive/20221009/https://www.rand.org/content/dam/rand/pubs/reports/2008/R918.pdf |archive-date=2022-10-09 |url-status=live}}</ref> This led DEC to introduce a smaller, cleaned up version of JOSS known as [[FOCAL (programming language)|FOCAL]], which they heavily promoted in the late 1960s. However, with timesharing systems widely offering BASIC, and all of their competition in the minicomputer space doing the same, DEC's customers were clamoring for BASIC. After management repeatedly ignored their pleas, [[David H. Ahl]] took it upon himself to buy a BASIC for the [[PDP-8]], which was a major success in the education market. By the early 1970s, FOCAL and JOSS had been forgotten and BASIC had become almost universal in the minicomputer market.<ref>{{cite interview |first=Kevin |last=Savetz |date=April 2013 |title=Dave Ahl and Betsy Ahl |url=https://computingpioneers.com/index.php?title=Dave_Ahl_and_Betsy_Ahl}}</ref> DEC would go on to introduce their updated version, [[BASIC-PLUS]], for use on the [[RSTS/E]] time-sharing operating system.

During this period a number of simple [[text-based game]]s were written in BASIC, most notably Mike Mayfield's ''[[Star Trek (text game)|Star Trek]]''. David Ahl collected these, some ported from FOCAL, and published them in an educational newsletter he compiled. He later collected a number of these into book form, ''101 BASIC Computer Games'', published in 1973.<ref name="basicgames">{{Cite book|url=http://www.atariarchives.org/basicgames/|title=101 Basic computer games|last=Ahl|first=David H.|date=1973|publisher=Creative Computing Press|location=Morristown, N.J. |language=en|oclc=896774158}}</ref> 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 (magazine)|Creative Computing]]''. The book remained popular, and was re-published on several occasions.<ref>{{Cite magazine|last=Ahl|first=David H.|date=May 11, 1981|title=Computer Games|url=https://books.google.com/books?id=Cz4EAAAAMBAJ&pg=PA44|magazine=[[InfoWorld]]|issn=0199-6649|volume=3|issue=9|page=44}}</ref>

== Explosive growth: the home computer era ==
{{See also|List of computers with on-board BASIC}}
[[File:CommodoreBasic.png|thumb|[[Commodore BASIC]] v2.0 on the [[Commodore 64]] ]]
[[File:Msxbasic.png|thumb|[[MSX BASIC]] version 3.0]]
[[File:Pn-pravez-class-5.jpg|thumb|right|"Train Basic every day!"—reads a poster (bottom center) in a Russian school ({{circa|1985–86}})]]

The introduction of the first [[microcomputer]]s 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, many of whom had seen BASIC on minis or mainframes. Despite [[Edsger W. Dijkstra|Dijkstra]]'s famous judgment 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 regeneration",<ref>{{Cite book|chapter-url=https://www.cs.utexas.edu/users/EWD/ewd04xx/EWD498.PDF |archive-url=https://ghostarchive.org/archive/20221009/https://www.cs.utexas.edu/users/EWD/ewd04xx/EWD498.PDF |archive-date=2022-10-09 |url-status=live|chapter=How do we tell truths that might hurt |title=Selected Writings on Computing: A Personal Perspective |first=Edsger W. |last=Dijkstra|date=June 18, 1975 |publication-date=1982 |publisher=[[Springer-Verlag]]|isbn=978-0387906522|oclc=693424350 |pages=[https://archive.org/details/selectedwritings0000dijk/page/129 129–131] |url=https://archive.org/details/selectedwritings0000dijk/page/129}}</ref> 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.

The first [[Altair BASIC|microcomputer version]] of BASIC was co-written by [[Bill Gates]], [[Paul Allen]] and [[Monte Davidoff]] for their newly formed company, Micro-Soft.<ref>{{Cite web |last=Johnson |first=Phil |date=2015-01-21 |title=The source code behind Microsoft BASIC for 6502 comes to light |url=https://www.computerworld.com/article/2872659/the-source-code-behind-microsoft-basic-for-6502-comes-to-light.html |access-date=2022-10-24 |website=Computerworld |language=en}}</ref> This was released by MITS in [[punch tape]] format for the [[Altair 8800]] shortly after the machine itself,<ref>{{Cite web|title=We have a BASIC|publisher=[[New Mexico Museum of Natural History and Science]]|url=http://startup.nmnaturalhistory.org/gallery/story.php?ii=20&sid=4|access-date=April 18, 2007|archive-url=https://web.archive.org/web/20121130051115/http://startup.nmnaturalhistory.org/gallery/story.php?ii=20&sid=4|archive-date=November 30, 2012}}</ref> immediately cementing BASIC as the primary language of early microcomputers. Members of the [[Homebrew Computer Club]] began circulating copies of the program, causing Gates to write his [[Open Letter to Hobbyists]], complaining about this early example of [[software piracy]].

Partially in response to Gates's letter, and partially to make an even smaller BASIC that would run usefully on 4&nbsp;KB machines,{{efn|Microsoft BASIC left 780 bytes free for user program code and variable values on a 4K machine, and that was running a cut-down version lacking string variables and other functionality.}} [[Bob Albrecht]] urged [[Dennis Allison]] to write their own variation of the language. How to design and implement a stripped-down version of an [[interpreter (computing)|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]]''. This led to a wide variety of [[Tiny BASIC]]s with added features or other improvements, with versions from Tom Pittman and [[Li-Chen Wang]] becoming particularly well known.<ref>{{Cite web |url=http://www.ittybittycomputers.com/IttyBitty/iNotes.html#TinyBasic|title=you had to pay $5 up front to get it… |last=Pittman |first=Tom |website=www.ittybittycomputers.com |access-date=June 14, 2017}}</ref>

Micro-Soft, by this time [[Microsoft]], ported their interpreter for the [[MOS 6502]], which quickly become one of the most popular microprocessors of the 8-bit era. When new microcomputers began to appear, notably the "1977 trinity" of the [[TRS-80]], [[Commodore PET]] and [[Apple II]], they either included a version of the MS code, or quickly introduced new models with it. [[Ohio Scientific|Ohio Scientific's]] personal computers also joined this trend at that time. By 1978, MS BASIC was a ''de facto'' standard and practically every [[home computer]] of the 1980s included it in [[read-only memory|ROM]]. Upon boot, a BASIC interpreter in [[direct mode]] was presented.

[[Commodore Business Machines]] includes [[Commodore BASIC]], based on Microsoft BASIC. The Apple II and TRS-80 each have two versions of BASIC: a smaller introductory version with the initial releases of the machines and a Microsoft-based version introduced 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 computers]] use the 8&nbsp;KB [[Atari BASIC]] which is not derived from Microsoft BASIC. [[Sinclair BASIC]] was introduced in 1980 with the Sinclair [[ZX80]], and was later extended for the Sinclair [[ZX81]] and the Sinclair [[ZX Spectrum]]. The [[BBC]] published [[BBC BASIC]], developed by [[Acorn Computers]], incorporates extra [[structured programming]] keywords and floating-point 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 program|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 original 101 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.<ref name="basicgames" /><ref>{{Cite book|url=http://www.atariarchives.org/morebasicgames/|title=More basic computer games|last=Ahl|first=David H.|date=1979|publisher=Creative Computing Press|isbn=978-0894801372|oclc=839377789|location=Morristown|language=en}}</ref><ref>{{Cite book|url=http://www.atariarchives.org/bigcomputergames/|title=Big computer games|last=Ahl|first=David H.|date=1984|publisher=Creative Computing Press|isbn=978-0916688400|oclc=872675092|location=Morris Plains, N.J.|language=en}}</ref> 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 Program BASIC would also have gaming as an introductory focus. On the business-focused [[CP/M]] computers which soon became widespread in small business environments, [[Microsoft BASIC]] ([[MBASIC]]) was one of the leading applications.<ref name="oldcomputer">{{Cite web|url=http://oldcomputers.net/osborne-1.html|title=Osborne 1|website=oldcomputers.net|access-date=June 14, 2017}}</ref>

In 1978, David Lien published the first edition of ''The BASIC Handbook: An Encyclopedia of the BASIC Computer Language'', documenting keywords across over 78 different computers. By 1981, the second edition documented keywords from over 250 different computers, showcasing the explosive growth of the microcomputer era.<ref>{{cite book |last1=Lien |first1=David |title=The BASIC Handbook |date=1981 |publisher=Compusoft Publishing |location=San Diego, CA |isbn=0-932760-00-7 |page=inside cover |edition=Second}}</ref>

== IBM PC and compatibles ==
[[File:IBM Cassette BASIC.png|thumb|[[IBM Cassette BASIC]] 1.10]]

When IBM was designing the [[IBM PC]], they followed the paradigm of existing home computers in having a built-in BASIC interpreter. They sourced this from Microsoft – [[IBM Cassette BASIC]] – but Microsoft also produced several other 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)<ref>{{Cite web |date= |title=Back to BASICs |url=http://peyre.sqweebs.com/GWBASIC/index.htm |url-status=dead |archive-url=https://web.archive.org/web/20091026133328/http://peyre.sqweebs.com/GWBASIC/index.htm |archive-date=2009-10-26 |access-date=2023-02-25 |website=peyre.sqweebs.com}}</ref> and [[QBasic]], all typically bundled with the machine. In addition they produced the [[QuickBASIC|Microsoft QuickBASIC]] Compiler (1985) for power users and hobbyists, and the Microsoft BASIC Professional Development System (PDS) for professional programmers. [[Turbo Pascal]]-publisher [[Borland]] published [[Turbo Basic]] 1.0 in 1985 (successor versions were marketed under the name [[PowerBASIC]]).

On [[Unix-like]] systems, specialized implementations were created such as [[XBasic]] and X11-Basic.<ref>{{cite web|url=http://www.linuxfocus.org/English/January2003/article277.shtml|title=BASIC programming with Unix|first=John|last=Perr|website=[[LinuxFocus (magazine)|LinuxFocus]]|date=2003-01-01|access-date=2023-09-26}}</ref> XBasic was ported to [[Microsoft Windows]] as [[XBLite]], and [[cross-platform]] variants such as [[SmallBasic]], [[yabasic]], [[Bywater BASIC]],<ref>{{cite web|url=https://www.ossblog.org/bwbasic-bywater-basic-interpreter/|title= bwBASIC: The Bywater BASIC Interpreter |website=OSS Blog|date= August 25, 2018 |access-date=2023-09-30}}</ref><ref>{{cite web|url=https://opensource.com/article/21/6/freedos-bywater-basic|title=Program on FreeDOS with Bywater BASIC|first=Jim|last=Hall|date=2021-06-23|access-date=2023-09-30|website=[[Opensource.com]]}}</ref> nuBasic,<ref>{{cite web|url=https://www.eantcal.eu/home/nubasic/why-nubasic|title=Why nuBASIC|first=Antonia|last=Calderone|access-date=2023-09-30}}</ref> MyBasic,<ref>{{cite web|url=https://www.codeproject.com/Articles/5202/MyBasic-A-Custom-BASIC-language-interpreter-writte|title=MyBasic - A Custom-BASIC language interpreter written in C++|first=Liu Xue|last=Song|date=2003-10-12|access-date=2023-09-30|website=[[Code Project]]}}</ref> Logic Basic,<ref>{{cite web|url=https://www.maxissoft.com/logicbasic/|title=LOGIC BASIC - Free programming language |access-date=2023-10-07}}</ref> [[Liberty BASIC]], and [[wxBasic]] emerged. [[FutureBASIC]] and [[Chipmunk Basic]] meanwhile targeted the [[Apple Macintosh]], while yab is a version of [[yaBasic]] optimized for [[BeOS]], [[ZETA (operating system)|ZETA]] and [[Haiku (operating system)|Haiku]].<ref>{{cite web|url=https://besly.de/index.php/development/yab-2/yab-beginners-tutorial|first=Christian|last=Albrecht|title=yab Beginners tutorial|website=BeSly - BeOS, Haiku & Zeta|date=2022-10-02|access-date=2024-02-25|others=Translation by Luc Schrijvers (Begasus)}}</ref>

These later variations introduced many extensions, such as improved [[string manipulation]] and graphics support, access to the [[file system]] and additional [[data type]]s. More important were the facilities for [[structured programming]], including additional [[control structures]] and proper [[subroutine]]s supporting [[local variable]]s.<ref name="GBvsQB" /> The addition of an [[integrated development environment]] (IDE) and electronic Help files made the products easier to work with and supported learning tools and school curriculum.

In 1989, [[Microsoft Press]] published ''[[Learn BASIC Now]]'', a book-and-software system designed to teach BASIC programming to self-taught learners who were using [[IBM-PC compatible]] systems and the Apple Macintosh. ''Learn BASIC Now'' included software disks containing the Microsoft QuickBASIC Interpreter and a programming tutorial written by [[Michael Halvorson]] and David Rygmyr. Learning systems like ''Learn BASIC Now'' popularized structured BASIC and helped QuickBASIC reach an installed base of four million active users.<ref>{{Cite book |last1=Halvorson |first1=Michael J. |title=Code Nation: Personal Computing and the Learn to Program Movement in America |date=2020 |publisher=ACM Books |location=New York, NY |page=146 |isbn = 978-1-4503-7757-7}}</ref>

By the late 1980s, many users were using pre-made applications written by others rather than learning programming themselves, and professional developers had a wide range of advanced languages available on small computers. [[C (programming language)|C]] and later [[C++]] became the languages of choice for professional [[Shrink wrap contract|"shrink wrap"]] application development.<ref>{{Cite book|url=https://books.google.com/books?id=lGRpeBZQYPoC|title=The Class Of Java|last=Pravin|first=Jain|date=2011|publisher=Pearson Education India|isbn=9788131755440|language=en}}</ref><ref>{{Cite web|url=http://www.fysh.org/~zefram/gne/c_programming_language/|title=GNE: the C programming language|website=fysh.org|access-date=June 14, 2017|quote=During the 1980s, C compilers spread widely, and C became an extremely popular language.}}</ref>

A niche that BASIC continued to fill was for hobbyist [[video game development]], as [[game creation system]]s and readily available [[game engine]]s were still in their infancy. The [[Atari ST]] had [[STOS BASIC]] while the [[Amiga]] had [[AMOS BASIC]] for this purpose. Microsoft first exhibited BASIC for game development with [[DONKEY.BAS]] for [[GW-BASIC]], and later [[GORILLA.BAS]] and [[NIBBLES.BAS]] for [[QuickBASIC]]. [[QBasic]] maintained an active game development community,<ref>{{cite news|url=https://www.techwalla.com/articles/easy-to-make-qbasic-games|title=Easy to Make Qbasic Games|first=Michael|last=Dance|website=Techwalla|access-date=2023-09-30}}</ref><ref>{{cite web|url=https://games.phatcode.net/|website=Phatcode|title=QBasic Games Directory|access-date=2023-09-30}}</ref> which helped later spawn the [[QB64]] and [[FreeBASIC]] implementations.<ref>{{cite web|url=http://games.freebasic.net/|title=FreeBASIC Games Directory|website=[[FreeBASIC]]|access-date=2023-09-30}}</ref> An early example of this market is the QBasic software package Microsoft Game Shop (1990), a hobbyist-inspired release that included six "arcade-style" games that were easily customizable in QBasic.<ref>{{Cite book |last1=Halvorson |first1=Michael J. |title=Code Nation: Personal Computing and the Learn to Program Movement in America |date=2020 |publisher=ACM Books |location=New York, NY |pages=153–156 |isbn = 978-1-4503-7757-7}}</ref>

In 2013, a game written in [[QBasic]] and compiled with [[QB64]] for modern computers entitled ''Black Annex'' was released on [[Steam (software)|Steam]].<ref>{{cite web|url=https://www.pcworld.com/article/457418/black-annex-is-the-best-qbasic-game-youve-ever-seen.html|website=[[PC World]]|title=Black Annex is the best QBASIC game you've ever seen|first=Alex|last=Cocilova|date=2013-04-16|access-date=2023-09-30}}</ref><ref>{{cite web|url=https://www.kotaku.com.au/2013/06/577447/|archive-url=https://web.archive.org/web/20130624055203/http://www.kotaku.com.au/2013/06/577447/|url-status=dead|archive-date=June 24, 2013|website=[[Kotaku]]|title=The Australian Who Built A Video Game Using QBASIC|first=Mark|last=Serrels|date=2013-06-24|access-date=2023-09-30}}</ref> [[Blitz Basic]], [[Dark Basic]], [[SdlBasic]], Super Game System Basic,<ref>{{cite web|url=https://www.indiedb.com/games/super-game-system-basic|title=Super Game System Basic|website=[[IndieDB]]|date=November 21, 2017 |access-date=2023-09-30}}</ref> PlayBASIC,<ref>{{cite web|url=https://playbasic.itch.io/|website=[[itch.io]]|title=PlayBasic|access-date=2023-09-30}}</ref> CoolBasic,<ref>{{cite web|url=https://www.indiedb.com/engines/coolbasic|website=IndieDB|title=CoolBasic|date=December 6, 2005 |access-date=2023-09-30}}</ref> [[Allegro (software library)|AllegroBASIC]],<ref>{{cite web|url=http://allegrobasic.pulsar2d.org/|archive-url=https://web.archive.org/web/20181115113443/http://allegrobasic.pulsar2d.org/|title=AllegroBASIC Homepage|website=AllegroBASIC|access-date=2023-10-07|archive-date=2018-11-15}}</ref> ethosBASIC,<ref>{{cite web|url=https://shareapp.net/ethos-game-basic_download/|title=Ethos Game Basic 1.3|website=shareApp|access-date=2023-09-30}}</ref> [[GLBasic]] and [[Basic4GL]] further filled this demand, right up to the modern RCBasic,<ref>{{cite web|url=https://www.moddb.com/engines/rc-basic|title=RC Basic|website=[[ModDB]]|date=August 18, 2015 |access-date=2023-09-30}}</ref> NaaLaa,<ref>{{cite web|url=https://www.softpedia.com/get/Programming/Coding-languages-Compilers/NaaLaa.shtml|title=NaaLaa|first=Andrei|last=Fercalo|date=2014-08-08|website=[[Softpedia]]|access-date=2023-10-01}}</ref> [[AppGameKit]],<ref>{{cite web|url=https://gamefromscratch.com/a-closer-look-at-appgamekit-2/|title=A Closer Look At AppGameKit 2|date=2015-06-12|access-date=2023-09-30|website=GameFromScratch}}</ref> Monkey 2, and Cerberus-X.<ref>{{cite web|url=https://gamefromscratch.com/cerberus-x-2018-08-10-released/|title=Cerberus X 2018-08-10 Released|website=GameFromScratch|date=2018-08-10|access-date=2023-09-30}}</ref>

== Visual Basic ==
{{Main|Visual Basic (classic)}}
In 1991, Microsoft introduced [[Visual Basic (classic)|Visual Basic]], an evolutionary development of [[QuickBASIC]]. It included constructs from that language such as block-structured control statements, parameterized subroutines and optional [[Type system#STATIC|static typing]] as well as [[object oriented language|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 development of 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. Microsoft also spun it off as [[Visual Basic for Applications]] and [[Embedded Visual Basic]].

While many advanced programmers still scoffed at its use, VB met the needs of [[small business]]es efficiently as 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 skill. Microsoft also produced [[VBScript]] in 1996 and [[Visual Basic .NET]] in 2001. The latter has essentially the same power as [[C Sharp (programming language)|C#]] and [[Java (programming language)|Java]] but with syntax that reflects the original Basic language, and also features some cross-platform capability through implementations such as [[Mono (software)|Mono-Basic]].<ref>{{cite web|url=https://www.theregister.com/2007/02/21/visual_basic_mono_linux/|website=[[The Register]]|title=Linux breakthrough for Visual Basic developers|first=Gavin|last=Clarke|date=2007-02-21|access-date=2023-10-01}}</ref> The [[Integrated development environment|IDE]], with its [[Event-driven programming|event-driven]] [[GUI builder]], was also influential on other [[rapid application development]] tools, most notably [[Borland Software]]'s [[Delphi (software)|Delphi]] for [[Object Pascal]] and its own descendants such as [[Lazarus (IDE)|Lazarus]].<ref>{{cite web| url = https://www.theregister.com/2020/02/14/25_years_delphi_programming/| title = 25 years of Delphi and no Oracle in sight: Not a Visual Basic killer but hard to kill | website=[[The Register]] |first=Tim | last=Anderson | date=2020-02-14 | access-date=2023-03-25 |quote=''Enter Borland Delphi, which combined Object Pascal with a VB-like visual form builder. Object Pascal was Borland's own language, with full support for inheritance. It is case-insensitive and not much harder than VB for coding, once you get used to typing begin and end a lot (loosely equivalent to curly braces in C). Unlike VB, it sensibly has different operators for assignment (:=) and comparison (=).''}}</ref><ref>{{cite web|url=https://www.theregister.com/2022/05/06/rad_basic_alpha_3/|title=RAD Basic – the Visual Basic 7 that never was – releases third alpha|website=[[The Register]]|first=Richard|last=Speed|date=2022-05-06|access-date=2023-03-26|quote=''Alternatively, one can relive the days of the whole BASIC/Pascal rivalry with Delphi-compatible Lazarus.''}}</ref>

Mainstream support for the final version 6.0 of the original Visual Basic ended on March 31, 2005, followed by extended support in March 2008.<ref>{{cite web|url=http://msdn2.microsoft.com/en-us/vbrun/ms788707.aspx |title=Product Family Life Cycle Guidelines for Visual Basic 6.0 |publisher=Msdn2.microsoft.com |date=2005-03-31 |access-date=2009-06-16}}</ref> Owing to its persistent remaining popularity,<ref>{{cite web|url=https://visualstudiomagazine.com/articles/2020/07/07/tiobe-july-2020-vb.aspx|title=Popularity Index: Classic Visual Basic Hangs In There|website=Visual Studio Magazine|first=David|last=Ramel|date=2020-07-07|access-date=2023-03-28}}</ref> third-party attempts to further support it exist.<ref>{{cite web|url=https://visualstudiomagazine.com/articles/2020/02/28/rubberduck.aspx|title=Visual Basic Resurgence? Project Seeks to 'Bring the VBE into This Century!'|first=David|last=Ramel|date=2020-02-28|website=Visual Studio Magazine|access-date=2023-03-28}}</ref> On February 2, 2017, Microsoft announced that development on VB.NET would no longer be in parallel with that of C#,<ref>{{cite web|url=https://visualstudiomagazine.com/articles/2017/06/13/visual-basic-future.aspx|title=Viva, Visual Basic! Or, Does VB Have a Future?|website=Visual Studio Magazine|first=Michael|last=Domingo|date=2017-06-13|access-date=2023-03-26}}</ref> and on March 11, 2020, it was announced that evolution of the VB.NET language had also concluded.<ref>{{cite web|url=https://visualstudiomagazine.com/articles/2020/03/12/vb-in-net-5.aspx|website=Visual Studio Magazine|title=Microsoft: 'We Do Not Plan to Evolve Visual Basic as a Language'|first=David|last=Ramel|date=2020-03-12|access-date=2023-03-26}}</ref> Even so, the language was still supported.<ref>{{cite web|url=https://visualstudiomagazine.com/articles/2023/02/08/language-update.aspx|website=Visual Studio Magazine|title=Microsoft Reaffirms Fate of Visual Basic|first=David|last=Ramel|date=2023-02-08|access-date=2023-03-25}}</ref>

[[File:TriBasicExample.png|thumb|Three modern Basic variants: [[Mono (software)|Mono]] Basic, [[OpenOffice.org Basic]] and [[Gambas]]]]

== Post-1990 versions and dialects ==
Many other BASIC dialects have also sprung up since 1990, including the [[Open-source software|open source]] [[QB64]] and [[FreeBASIC]], inspired by QBasic, and the Visual Basic-styled [[RapidQ]], [[HBasic]], [[Basic For Qt]] and [[Gambas]].<ref name="theregister_com" /> Modern commercial incarnations include [[PureBasic]], [[PowerBASIC]], [[Xojo]], [[Blitz Research|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 Microsoft's [[Microsoft Small Basic|Small Basic]] and [[Google]]'s wwwBASIC.<ref>{{cite web|url=https://hackaday.com/2018/09/17/its-the-web-basically/|title=It's The Web, Basically|first=Al|last=Williams|website=[[Hackaday]]|date=2018-09-17|access-date=2023-09-28}}</ref> A number of compilers also exist that convert BASIC into [[JavaScript]].<ref>{{cite web|url=https://codeavenger.com/2017/02/14/JavaScript-compilers.-Part-II-Languages-that-compile-to-JavaScript.html|website=Code Avenger|title=JavaScript compilers. Part II: Languages that compile to JavaScript|first=Marian|last=Veteanu|date=2017-02-14}}</ref> such as [[NS Basic]].[[File:PS2BASIC-Hello Wikipedia.png|thumb|234x234px|A sample BASIC programme running under [[Yabasic|YABASIC]] for the Sony [[PlayStation 2|PS2]]]]Building from earlier efforts such as [[Mobile Basic]],<ref>{{cite web|url=https://itecnote.com/tecnote/java-what-programming-languages-target-j2me/|title=Java – What programming languages target J2ME|website=iTecNote|access-date=2023-09-30|quote=''Now I've heard of other languages which supposedly make possible development without recourse to Java, languages like CellularBASIC (which looks a bit like QBASIC) and Hecl (which seems to be based on Tcl).''}}</ref><ref>{{cite web|url=https://gtello.pagesperso-orange.fr/lgks360_e.htm|title=LG KS 360|first=Guillaume|last=Tello|date=2007-12-15|access-date=2023-09-30|quote=''After some research on the Net, I came across this site about the CellularBASIC. It is a complete BASIC interpreter written in JAVA.''|archive-url=https://web.archive.org/web/20101028145645/https://gtello.pagesperso-orange.fr/lgks360_e.htm|archive-date=October 28, 2010}}</ref> many dialects are now available for [[smartphone]]s and tablets.

On game consoles, 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 version has also been released for [[Nintendo Switch]], which has also been supplied a version of the Fuze Code System,<ref>{{cite web|url=https://www.theverge.com/circuitbreaker/2017/6/19/15833220/fuze-code-studio-nintendo-switch-make-your-own-basic-games|title=Fuze Code Studio will let kids use the Switch to code their own Switch games|first=Paul|last=Miller|date=2017-06-19|website=[[The Verge]]|access-date=2023-09-30}}</ref> a BASIC variant<ref>{{cite web|url=https://www.thegadgetman.org.uk/back-to-basic-with-fuze/|website=The Gadget Man|title=Now kids can get back to BASIC with Fuze|first=Matt|last=Porter|date=2015-12-18|access-date=2023-09-30}}</ref> first implemented as a custom [[Raspberry Pi]] machine.<ref>{{cite web|url=https://www.thegadgetman.org.uk/back-to-basic-with-fuze/|website=The Gadget Man|title=FUZE powered by Raspberry Pi V2 review|first=Mike|last=Bedford|date=2015-10-21|access-date=2023-09-30}}</ref> Previously BASIC was made available on consoles as [[Family BASIC]] (for the [[Nintendo Famicom]]) and [[PlayStation (console)|PSX]] [[Chipmunk Basic]] (for the original [[PlayStation (console)|PlayStation]]), while [[yabasic]] was ported to the [[PlayStation 2]] and [[FreeBASIC]] to the original [[Xbox (console)|Xbox]].

== Calculators ==
Variants of BASIC are available on graphing and otherwise [[programmable calculator]]s made by [[Texas Instruments]] ([[TI-BASIC]]), HP ([[BASIC (HP calculators)|HP BASIC]]), Casio ([[Casio BASIC]]), and others.

== Windows command-line ==
[[QBasic]], a version of Microsoft [[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|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 QBasic installed 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.

== Other ==
[[File:Nintendo-Famicom-Family-Basic-Keyboard-wCart.jpg|thumb|right|BASIC came to some video game systems, such as the Nintendo [[Nintendo Entertainment System|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. The 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 VBA constructions. 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 Microsoft Word 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 [[Linux]], [[Microsoft Windows]] and [[macOS]].

== Legacy ==
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 program]]s.

Futurist and sci-fi writer [[David Brin]] mourned the loss of ubiquitous BASIC in a 2006 ''Salon'' article<ref>{{Cite web|url=https://www.salon.com/2006/09/14/basic_2/|archive-url=https://web.archive.org/web/20130918213750/http://www.salon.com/2006/09/14/basic_2/singleton/|archive-date=September 18, 2013|url-status=dead|title=Why Johnny Can't Code|last=Brin|first=David|date=September 14, 2006|website=[[Salon (website)|Salon]]|access-date=2017-06-19}}</ref> as have others who first used computers during this era. In turn, the article prompted Microsoft to develop and release [[Microsoft Small Basic|Small Basic]];<ref>{{Cite web|url=http://msdn.microsoft.com/en-us/beginner/hh182234.aspx|archive-url=https://web.archive.org/web/20140317001756/http://msdn.microsoft.com/en-us/beginner/hh182234.aspx|archive-date=March 17, 2014|url-status=dead|title=Small Basic|website=[[Microsoft Developer Network]]|access-date=June 19, 2017}}</ref> it also inspired similar projects like [[Basic-256]]<ref>{{cite web| url = https://basic256.org/| title = BASIC-256 homepage | quote=''Check out "Why Johnny Can't Code," the article that inspired BASIC-256.''}}</ref><ref>{{cite web|url=https://pclosmag.com/html/Issues/200810/page04.html|website=[[PCLinuxOS]] Magazine|access-date=2024-02-25|title=An Alphabet of Computer Languages: BASIC |first=Gary L.|last=Ratliff Sr.|date=October 2008}}</ref> and the web based Quite Basic.<ref>{{cite web|url=https://www.raphkoster.com/2006/11/21/quite-basic-web-basic-programming/|title=Quite BASIC — Web BASIC programming|first=Raph|last=Koster|date=2006-11-21|access-date=2024-02-25}}</ref> [[Dartmouth College|Dartmouth]] held a 50th anniversary celebration for BASIC on 1 May 2014.<ref>{{Cite news|url=http://www.unionleader.com/apps/pbcs.dll/article?AID=/20140429/NEWS04/140429054|title=Dartmouth plans celebration for 50th anniversary of BASIC computer language|newspaper=[[New Hampshire Union Leader]]|date=April 28, 2014|access-date=June 14, 2017|archive-date=June 20, 2017|archive-url=https://web.archive.org/web/20170620014749/http://www.unionleader.com/apps/pbcs.dll/article?AID=/20140429/NEWS04/140429054|url-status=dead}}</ref> The pedagogical use of BASIC has been followed by other languages, such as [[Pascal (programming language)|Pascal]], [[Java (programming language)|Java]] and particularly [[Python (programming language)|Python]].<ref>{{cite web|url=https://www.computerworld.com/article/2509286/how-are-students-learning-programming-in-a-post-basic-world-.amp.html|website=[[Computerworld]]|title=How are students learning programming in a post-Basic world?|first=Lamont|last=Wood|date=2011-06-23|access-date=2024-02-26}}</ref>

Dartmouth College celebrated the 50th anniversary of the BASIC language with a day of events<ref>{{Cite web|url=https://www.dartmouth.edu/basicfifty/events.html|title=BASIC at 50 – Event Schedule|publisher=[[Dartmouth College]]|language=en|access-date=June 14, 2017}}</ref> on April 30, 2014. A short documentary film was produced for the event.<ref>{{Cite web|url=https://www.dartmouth.edu/basicfifty/|title=BASIC at 50|publisher=[[Dartmouth College]]|language=en|access-date=June 14, 2017}}</ref>

== Syntax ==
=== Typical BASIC keywords{{Anchor|keywords}} ===
==== Data manipulation ====
; <code>LET</code> : assigns a value (which may be the result of an [[expression (programming)|expression]]) to a variable. In most dialects of BASIC, <code>LET</code> is optional, and a line with no other identifiable keyword will assume the keyword to be <code>LET</code>.
; <code>DATA</code> : holds a list of values which are assigned sequentially using the READ command.
; <code>READ</code> : reads a value from a <code>DATA</code> statement and assigns it to a variable. An internal pointer keeps track of the last <code>DATA</code> element that was read and moves it one position forward with each <code>READ</code>. Most dialects allow multiple variables as parameters, reading several values in a single operation.
; <code>RESTORE</code> : resets the internal pointer to the first <code>DATA</code> statement, allowing the program to begin <code>READ</code>ing from the first value. Many dialects allow an optional line number or ordinal value to allow the pointer to be reset to a selected location.
; <code>DIM</code> : Sets up an array.

==== Program flow control ====
; <code>IF ... THEN ... {ELSE}</code> : used to perform comparisons or make decisions. Early dialects only allowed a line number after the <code>THEN</code>, but later versions allowed any valid statement to follow. <code>ELSE</code> was not widely supported, especially in earlier versions.
; <code>FOR ... TO ... {STEP} ... NEXT</code> : repeat a section of code a given number of times. A variable that acts as a counter, the "index", is available within the [[Control flow#Loops|loop]].
; <code>WHILE ... WEND</code> and <code>REPEAT ... UNTIL</code> : repeat a section of code while the specified condition is true. The condition may be evaluated before each iteration of the loop, or after. Both of these commands are found mostly in later dialects.
; <code>DO ... LOOP {WHILE}</code> or <code>{UNTIL}</code> : repeat a section of code indefinitely or while/until the specified condition is true. The condition may be evaluated before each iteration of the loop, or after. Similar to <code>WHILE</code>, these keywords are mostly found in later dialects.
; <code>[[Goto|GOTO]]</code> : jumps to a numbered or labelled line in the program. Most dialects also allowed the form {{code|GO TO}}.
; <code>GOSUB ... RETURN</code> : jumps to a numbered or labelled line, executes the code it finds there until it reaches a <code>RETURN</code> command, on which it jumps back to the statement following the <code>GOSUB</code>, either after a colon, or on the next line. This is used to implement [[subroutine]]s.
; <code>ON ... GOTO/GOSUB</code> : chooses where to jump based on the specified conditions. See [[Switch statement]] for other forms.
; <code>DEF FN</code> : a pair of keywords introduced in the early 1960s to define functions. The original BASIC functions were modelled on FORTRAN single-line functions. BASIC functions were one expression with variable arguments, rather than [[subroutine]]s, with a syntax on the model of <code>DEF FND(x) = x*x</code> at the beginning of a program. Function names were originally restricted to FN, plus one letter, ''i.e.'', FNA, FNB&nbsp;...

==== Input and output ====
; <code>LIST</code> : displays the full source code of the current program.
; {{anchor|PRINT}}<code>PRINT</code> : displays a message on the screen or other output device.
; <code>INPUT</code> : asks the user to enter the value of a variable. The statement may include a prompt message.
; <code>TAB</code> : used with <code>PRINT</code> to set the position where the next character will be shown on the screen or printed on paper. <code>AT</code> is an alternative form.
; <code>SPC</code> : prints out a number of space characters. Similar in concept to <code>TAB</code> but moves by a number of additional spaces from the current column rather than moving to a specified column.

==== Mathematical functions ====
; <code>ABS</code> : Absolute value
; <code>ATN</code> : Arctangent (result in [[radian]]s)
; <code>COS</code> : Cosine (argument in [[radian]]s)
; <code>EXP</code> : Exponential function
; <code>INT</code> : Integer part (typically [[floor function]])
; <code>LOG</code> : Natural logarithm
; <code>RND</code> : [[Random number generation]]
; <code>SIN</code> : Sine (argument in [[radian]]s)
; <code>SQR</code> : Square root
; <code>TAN</code> : Tangent (argument in [[radian]]s)

==== Miscellaneous ====
; <code>REM</code> : 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.
;{{anchor|USR}} <code>USR</code> ("User Serviceable Routine"): transfers program control to a [[Machine code|machine language]] subroutine, usually entered as an alphanumeric [[String (computer science)|string]] or in a list of DATA statements.
; <code>CALL</code> : alternative form of <code>USR</code> found in some dialects. Does not require an artificial parameter to complete the function-like syntax of <code>USR</code>, and has a clearly defined method of calling different routines in memory.
; <code>TRON</code> /  <code>TROFF</code>: 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 it back off again.
; <code>ASM</code> : some compilers such as Freebasic,<ref>{{Cite web|url=http://www.freebasic.net/wiki/wikka.php?wakka=KeyPgAsm|title=KeyPgAsm|website=FreeBasic Wiki|access-date=August 2, 2017}}</ref> Purebasic,<ref>{{Cite web|url=https://www.purebasic.com/documentation/reference/inlinedasm.html|title=Inline x86 ASM|website=Pure Basic|access-date=August 2, 2017}}</ref> and Powerbasic<ref>{{Cite web|url=https://www.powerbasic.com/help/pbcc/using_assembly-language_in_your_code.htm|title=Using assembly-language in your code|website=Power Basic|access-date=August 2, 2017|archive-url=https://web.archive.org/web/20170802164032/https://www.powerbasic.com/help/pbcc/using_assembly-language_in_your_code.htm|archive-date=August 2, 2017|url-status=dead}}</ref> also support [[Inline assembler|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 BASIC 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 (computer science)|String]] variables are usually distinguished in many microcomputer dialects by having $ suffixed to their name as a [[Sigil (computer programming)|sigil]], 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 [[matrix (mathematics)|matrices and matrix operations]], which can be used to solve 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.

=== Examples ===
[[File:ARROW (Listing) (3300726999).png|thumb|A simple game implemented in BASIC]]

==== Unstructured BASIC ====
New 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 [[The C Programming Language|Kernighan and Ritchie]]'s [["Hello, World!" program]]:

<syntaxhighlight lang="basic">
10 PRINT "Hello, World!"
20 END
</syntaxhighlight>

An [[infinite loop]] could be used to fill the display with the message:

<syntaxhighlight lang="basic">
10 PRINT "Hello, World!"
20 GOTO 10
</syntaxhighlight>

Note that the <code>END</code> statement is optional and has no action in most dialects of BASIC. It was not always included, as is the case in this example. This same program can be modified to print a fixed number of messages using the common <code>FOR...NEXT</code> statement:

<syntaxhighlight lang="basic">
10 LET N=10
20 FOR I=1 TO N
30 PRINT "Hello, World!"
40 NEXT I
</syntaxhighlight>

Most home computers 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:

<syntaxhighlight lang="basic">
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
</syntaxhighlight>
The resulting dialog might resemble:

 What is your name: Mike
 Hello 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
 Goodbye Mike

The original Dartmouth Basic was unusual in having a matrix keyword, MAT.{{efn|From version 3 onwards.}} Although not implemented by most later microprocessor derivatives, it is used in this example from the 1968 manual<ref>{{Cite book|url=http://bitsavers.trailing-edge.com/pdf/dartmouth/BASIC_4th_Edition_Jan68.pdf |archive-url=https://web.archive.org/web/20140103140704/http://bitsavers.trailing-edge.com/pdf/dartmouth/BASIC_4th_Edition_Jan68.pdf |archive-date=2014-01-03 |url-status=live|title=Basic: a manual for BASIC, the elementary algebraic language designed for use with the Dartmouth Time Sharing System|last1=Kemeny|first1=John G.|last2=Kurtz|first2=Thomas E.|date=January 1968|publisher=Dartmouth College Computation Center|location=Hanover, N.H.|language=en|edition=4th|page=53}}</ref> which averages the numbers that are input:

<syntaxhighlight lang="basic">
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 
99 END
</syntaxhighlight>

==== Structured BASIC ====
Second-generation BASICs (for example, [[VSI BASIC for OpenVMS|VAX Basic]], [[SuperBASIC]], [[True BASIC]], [[QuickBASIC]], [[BBC BASIC]], [[Pick operating system|Pick BASIC]], [[PowerBASIC]], [[Liberty BASIC]], [[QB64]] and (arguably) [[COMAL]]) introduced a number of features into the language, primarily related to structured and procedure-oriented programming. Usually, [[line number]]ing is omitted from the language and replaced with [[label (computer science)|labels]] (for [[GOTO]]) and [[subroutine|procedures]] to encourage easier and more flexible design.<ref name="GBvsQB">{{cite web|url=http://support.microsoft.com/kb/73084|title=Differences Between GW-BASIC and QBasic|date=2003-05-12|access-date=2008-06-28|archive-url=https://web.archive.org/web/20131019181140/http://support.microsoft.com/kb/73084|archive-date=2013-10-19}}</ref> In addition keywords and structures to support repetition, selection and procedures with local variables were introduced.

The following example is in Microsoft QuickBASIC:

<syntaxhighlight lang="QBasic">
REM QuickBASIC example

REM Forward declaration - allows the main code to call a
REM    subroutine that is defined later in the source code
DECLARE SUB PrintSomeStars (StarCount!)

REM Main program follows
INPUT "What is your name: ", UserName$
PRINT "Hello "; UserName$
DO
   INPUT "How many stars do you want: ", NumStars
   CALL PrintSomeStars(NumStars)
   DO
      INPUT "Do you want more stars? ", Answer$
   LOOP UNTIL Answer$ <> ""
   Answer$ = LEFT$(Answer$, 1)
LOOP WHILE UCASE$(Answer$) = "Y"
PRINT "Goodbye "; UserName$
END

REM subroutine definition
SUB PrintSomeStars (StarCount)
   REM This procedure uses a local variable called Stars$
   Stars$ = STRING$(StarCount, "*")
   PRINT Stars$
END SUB
</syntaxhighlight>

==== Object-oriented BASIC ====
Third-generation BASIC dialects such as [[Visual Basic (classic)|Visual Basic]], [[Xojo]], [[Gambas]], [[StarOffice Basic]], [[BlitzMax]] and [[PureBasic]] 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 increasingly accessible to the BASIC language.

The following example is in [[Visual Basic .NET]]:

<!-- needs a better (event-driven?) example -->
<syntaxhighlight lang="vbnet">
Public Module StarsProgram
   Private Function Ask(prompt As String) As String
      Console.Write(prompt)
      Return Console.ReadLine()
   End Function

   Public Sub Main()
      Dim userName = Ask("What is your name: ")
      Console.WriteLine("Hello {0}", userName)

      Dim answer As String

      Do
         Dim numStars = CInt(Ask("How many stars do you want: "))
         Dim stars As New String("*"c, numStars)
         Console.WriteLine(stars)

         Do
            answer = Ask("Do you want more stars? ")
         Loop Until answer <> ""
      Loop While answer.StartsWith("Y", StringComparison.OrdinalIgnoreCase)

      Console.WriteLine("Goodbye {0}", userName)
   End Sub
End Module
</syntaxhighlight>

== Standards ==
;ANSI/ISO/IEC/ECMA for Minimal BASIC:
* ANSI X3.60-1978 "For minimal BASIC" ''(withdrawn<ref>{{cite web|access-date=16 May 2025 |author=Information Technology Industry Council |date=2013 |language=en |publisher=Intertek Inform |title=ANSI INCITS 60:1978 — Programming Language Minimal BASIC |url=https://www.intertekinform.com/en-gb/standards/ansi-incits-60-1978-614646_saig_iti_iti_1414086/}}<!-- auto-translated from Portuguese by Module:CS1 translator --></ref>)''
* ISO/IEC 6373:1984 "Data processing — Programming languages — Minimal BASIC" ''(withdrawn<ref>{{cite web|access-date=16 May 2025 |author=International Organization for Standardization |date=1984 |language=en |publisher=ISO |title=ISO 6373:1984 — Data processing — Programming languages — Minimal BASIC |url=https://www.iso.org/standard/12705.html}}<!-- auto-translated from Portuguese by Module:CS1 translator --></ref>)''
* [[Ecma International|ECMA]]-55 "Minimal BASIC" ''(withdrawn,<ref>{{cite web|access-date=16 May 2025 |author=Ecma International |date=1978 |language=en |publisher=Ecma International |title=ECMA-55: Minimal BASIC |url=https://ecma-international.org/publications-and-standards/standards/ecma-55/}}<!-- auto-translated from Portuguese by Module:CS1 translator --></ref> similar to ANSI X3.60-1978)''

;ANSI/ISO/IEC/ECMA for Full BASIC:
* ANSI X3.113-1987 "Programming Languages Full BASIC" ''(in force<ref>{{cite web|access-date=16 May 2025 |author=Information Technology Industry Council |date=2003 |language=en |publisher=Intertek Inform |title=ANSI INCITS 113:1987 — Information Systems – Programming Language – Full BASIC |url=https://www.intertekinform.com/en-gb/standards/ansi-incits-113-1987-614804_saig_iti_iti_1414429/}}<!-- auto-translated from Portuguese by Module:CS1 translator --></ref><ref>[https://archive.org/details/federalinformat6821nati_0/mode/2up ANSI X3.113-1987] (PDF, Internet Archive)</ref>)''
* INCITS/ISO/IEC 10279-1991 (Rev. 2024) "Information Technology – Programming Languages – Full BASIC" ''(in force<ref>{{cite web|access-date=16 May 2025 |author=International Organization for Standardization |date=1991 |language=en |publisher=ISO |title=ISO/IEC 10279:1991 — Information technology — Programming languages — Full BASIC |url=https://www.iso.org/standard/18321.html}}<!-- auto-translated from Portuguese by Module:CS1 translator --></ref>)''
* [[Ecma International|ECMA]]-116 "BASIC" ''(withdrawn,<ref>{{cite web|access-date=16 May 2025 |author=Ecma International |date=1986 |language=en |publisher=Ecma International |title=ECMA-116: BASIC |url=https://ecma-international.org/publications-and-standards/standards/ecma-116/}}<!-- auto-translated from Portuguese by Module:CS1 translator --></ref> similar to ANSI X3.113-1987)''

;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 Enhancement" ''(in force<ref>{{cite web|access-date=16 May 2025 |author=International Organization for Standardization |date=1994 |language=en |publisher=ISO |title=ISO/IEC 10279:1991/Amd 1:1994 — Information technology — Programming languages — Full BASIC — Amendment 1: Modules and single character input enhancement |url=https://www.iso.org/standard/20742.html}}<!-- auto-translated from Portuguese by Module:CS1 translator --></ref>)''

== Compilers and interpreters ==
{{excerpt|List of compilers|BASIC compilers}}
{{excerpt|List of compilers|BASIC interpreters}}

== See also ==
* [[List of BASIC dialects]]

== Notes ==
{{Notelist}}

== References ==
{{Reflist|30em}}

=== General references ===
{{Refbegin}}
* {{Cite book |last=Sammet |first=Jean E. |date=1969 |title=Programming Languages: History and Fundamentals |url=https://archive.org/details/programminglangu00unse |url-access=registration |location=Englewood Cliffs, N.J. |publisher=Prentice-Hall |isbn=978-0-13-729988-1 |language=en |lccn=68-028110 |oclc=819683527}}
* {{Cite encyclopedia
 |last         = Kurtz
 |first        = Thomas E.
 |date         = 1981
 |chapter      = BASIC
 |chapter-url  = http://doi.acm.org/10.1145/800025.1198404
 |editor-last  = Wexelblat
 |editor-first = Richard
 |encyclopedia = History of Programming Languages I
 |title        = History of Programming Languages
 |url          = https://archive.org/details/historyofprogram0000hist/mode/2up
 |location     = New York
 |publisher    = [[Association for Computing Machinery|ACM]]
 |isbn         = 978-0127450407
 |doi          = 10.1145/800025.1198404<!-- (currently broken, reported to issuer) -->
 |pages        = [https://archive.org/details/historyofprogram0000hist/page/515 515–537]
}}
* {{Cite book |last1=Kemeny |first1=John G. |last2=Kurtz |first2=Thomas E. |date=1985 |title=Back to BASIC: The History, Corruption, and Future of the Language |publisher=Addison-Wesley |pages=141 |isbn=9780201134339 |oclc=11399298}}
* {{Cite book |last=Lien |first=David A. |date=1986 |title=The Basic Handbook: Encyclopedia of the BASIC Computer Language |edition=3rd |publisher=Compusoft Publishing |isbn=9780932760333 |oclc=12548310}}
* {{cite magazine |title=Fifty Years of BASIC, the Programming Language That Made Computers Personal |url=https://time.com/69316/basic/ |magazine=Time |date=29 April 2014 |ref=CITEREFTime2014}}
{{Refend}}

== External links ==
{{Wikibooks|Programming:BASIC}}
<!-- Please do not add any links for specific implementations of BASIC here. Add them to ''[[List of BASIC dialects]]'' and ''[[List of BASIC dialects by platform]]'' instead -->
* {{YouTube|WYPNjSoDrqw|The Birth of Basic}}
* [https://gotbasic.com/ gotBASIC.com]—For all people interested in the continued usage and evolution of the BASIC programming language.
* [https://github.com/JohnBlood/awesome-basic Awesome Basic]—A curated list of awesome BASIC dialects, IDEs, and tutorials.
* [http://basic.mindteq.com/ The Basics' page (Since 2001)]—Comprehensive listing of dialects.

{{Programming languages}}
{{BASIC}}
{{Authority control}}

{{DEFAULTSORT:Basic}}
[[Category:BASIC programming language family| ]]
[[Category:American inventions]]
[[Category:Articles with example BASIC code]]
[[Category:Programming languages]]
[[Category:Programming languages created in 1964]]
[[Category:Programming languages with an ISO standard]]