Atari BASIC

<h2 id="development">Development</h2>
The machines that would become the <a href="/facts/Atari_8-bit_computers/aT04N5zR">Atari 8-bit computers</a> were originally developed as second-generation <a href="/facts/Video_game_console/K72D1NSS">video game consoles</a> intended to replace the <a href="/facts/Atari_2600/wSTCRAvp">Atari VCS</a>. <a href="/facts/Ray_Kassar/Qgv99LgH">Ray Kassar</a>, the new president of Atari, decided to challenge <a href="/facts/Apple_Inc./oTJYta3k">Apple Computer</a> by building a home computer instead.<a class="footnote-ref" id="fnref:5" href="#fn:5">5</a>
This meant the designs needed to include the <a href="/facts/BASIC/ELoTkjnM">BASIC</a> programming language, the standard for home computers. In early 1978, Atari licensed the <a href="/facts/Source_code/o9J6Jv23">source code</a> to the <a href="/facts/MOS_Technology_6502/q9YLwkzm">MOS 6502</a> version of <a href="/facts/Microsoft_BASIC/SuctFIyc">Microsoft BASIC</a>.<a class="footnote-ref" id="fnref:6" href="#fn:6">6</a> It was offered in two versions: one using a 32-bit floating point format that was about 7800 bytes when compiled, and another using an extended 40-bit format that was close to 9 KB.<a class="footnote-ref" id="fnref:7" href="#fn:7">7</a>
Even the 32-bit version barely fit into the 8 KB size of the machine's <a href="/facts/ROM_cartridge/mWLcNez7">ROM cartridge</a> format. Atari also felt that they needed to expand the language to support the hardware features of their computers, similar to what Apple had done with <a href="/facts/Applesoft_BASIC/H2YH0YS6">Applesoft BASIC</a>. This increased the size of Atari's version to around 11 KB; Applesoft BASIC on the <a href="/facts/Apple_II_Plus/UyAGBJ9t">Apple II+</a> was 10,240 bytes long.<a class="footnote-ref" id="fnref:8" href="#fn:8">8</a> After six months the code was pared down to almost fit in an 8 KB ROM,<a class="footnote-ref" id="fnref:9" href="#fn:9">9</a> but Atari was facing a January 1979 deadline for the <a href="/facts/Consumer_Electronics_Show/JUmN49Fl">Consumer Electronics Show</a> (CES) where the machines would be demonstrated. They decided to ask for help to get a version of BASIC ready in time for the show.<a class="footnote-ref" id="fnref:10" href="#fn:10">10</a>

<h3>Shepardson Microsystems</h3>

In September 1978, <a href="/facts/Shepardson_Microsystems/J2kRfFN3">Shepardson Microsystems</a> won the bid on completing BASIC.<a class="footnote-ref" id="fnref:11" href="#fn:11">11</a> At the time they were finishing Cromemco 16K Structured BASIC for the <a href="/facts/Zilog_Z80/Jeqe2h55">Z80</a>-based <a href="/facts/Cromemco/5s4vFkQK">Cromemco</a> <a href="/facts/S-100_bus/3C5L4KSt">S-100 bus</a> machines.<a class="footnote-ref" id="fnref:12" href="#fn:12">12</a><a class="footnote-ref" id="fnref:13" href="#fn:13">13</a> Developers Kathleen O'Brien and Paul Laughton used <a href="/facts/Data_General_Business_Basic/JXw6abLH">Data General Business Basic</a>, an integer-only implementation, as the inspiration for their BASIC, given Laughton's experience with Data General on a <a href="/facts/Time-sharing/LE5XT9Go">time-sharing</a> system.<a class="footnote-ref" id="fnref:14" href="#fn:14">14</a>
Cromemco BASIC includes an extended <a href="/facts/Floating-point_arithmetic/eIckahxe">floating point</a> implementation using a 14-digit <a href="/facts/Binary-coded_decimal/dWTaE7ES">binary-coded decimal</a> (BCD) format made possible using all 16 registers of the <a href="/facts/Zilog_Z80/Jeqe2h55">Zilog Z80</a> processor. As it converts all data to the internal format at edit time, small constants like "1" use ~8 bytes of memory, and this could be a particular issue when storing arrays of numbers. To address this, the language also supports a smaller 6-digit BCD format.<a class="footnote-ref" id="fnref:15" href="#fn:15">15</a>
Even the smallest BASICs on the 6502 used about 10K. For instance, <a href="/facts/Commodore_BASIC/wYrzVk3f">Commodore BASIC</a> used 9K but also relies on support from the <a href="/facts/KERNAL/HaVrj8fq">KERNAL</a>,<a class="footnote-ref" id="fnref:16" href="#fn:16">16</a> while <a href="/facts/Applesoft_BASIC/H2YH0YS6">Applesoft BASIC</a> is 10,780 bytes.<a class="footnote-ref" id="fnref:17" href="#fn:17">17</a> To meet the goal of fitting in an 8K ROM, the new BASIC would be in two parts: the language itself on the cartridge and a 2K floating point library in the system's 10K ROM supporting only the 6-digit format.<a class="footnote-ref" id="fnref:18" href="#fn:18">18</a>
Atari accepted the proposal, and when the specifications were finalized in October 1978, Laughton and O'Brien began work on the new language.<a class="footnote-ref" id="fnref:19" href="#fn:19">19</a> The contract specified the delivery date on or before 6 April 1979 and this also included a File Manager System (later known as DOS 1.0).<a class="footnote-ref" id="fnref:20" href="#fn:20">20</a> Atari's plans were to take an early 8K version of Microsoft BASIC to the 1979 CES, then switch to Atari BASIC for production. Development proceeded quickly, helped by a <a href="/facts/Consideration/78wBVflY">bonus clause</a> in the contract, which led to the initial version being delivered in October. Atari took an 8K cartridge version to CES instead of Microsoft's.<a class="footnote-ref" id="fnref:21" href="#fn:21">21</a> <a href="/facts/Atari_Microsoft_BASIC/TSJXSxT7">Atari Microsoft BASIC</a> was later a separate product.<a class="footnote-ref" id="fnref:22" href="#fn:22">22</a>

<h3>Releases</h3>
The version Shepardson gave to Atari for the CES demo was not intended to be final, and Shepardson continued to fix bugs.<a class="footnote-ref" id="fnref:23" href="#fn:23">23</a> Unknown to Shepardson, Atari had already sent the CES version to manufacturing.<a class="footnote-ref" id="fnref:24" href="#fn:24">24</a>
This version was later known as Revision A. It contains a major bug in a routine that copies memory: deleting lines of code that are exactly 256 bytes long causes a lockup after the next command is entered. The Reset key does not fix it.<a class="footnote-ref" id="fnref:25" href="#fn:25">25</a>
Revision B attempted to fix the major bugs in Revision A and was released in 1983 as a built-in ROM in the 600XL and 800XL models. While fixing the memory copying bug, the programmer noticed the same pattern of code in the section for inserting lines, and applied the same fix. This instead introduced the original bug into this code. Inserting new lines is much more common than deleting old ones, so the change dramatically increased the number of crashes.<a class="footnote-ref" id="fnref:26" href="#fn:26">26</a> Revision B also adds 16 bytes to a program every time it is SAVEd and LOADed, eventually causing the machine to run out of memory for even the smallest programs.<a class="footnote-ref" id="fnref:27" href="#fn:27">27</a><a class="footnote-ref" id="fnref:28" href="#fn:28">28</a> <a href="/facts/Mapping_the_Atari/YIfkU0Hf">Mapping the Atari</a> described these as "awesome bugs" and advised Revision B owners "Don't fool around; get the new ROM, which is available on cartridge" from Atari.<a class="footnote-ref" id="fnref:29" href="#fn:29">29</a> The book provides a <a href="/facts/Type-in_program/sTumWqhs">type-in program</a> to patch Revision B to Revision C for those without the cartridge.<a class="footnote-ref" id="fnref:30" href="#fn:30">30</a>
Revision C eliminates the memory leaks in Revision B.<a class="footnote-ref" id="fnref:31" href="#fn:31">31</a> It is built-in on later versions of the 800XL<a class="footnote-ref" id="fnref:32" href="#fn:32">32</a> and all XE models including the XEGS. Revision C was also available as a cartridge.<a class="footnote-ref" id="fnref:33" href="#fn:33">33</a>
The version can be determined by typing PRINT PEEK(43234) at the READY prompt. The result is 162 for Revision A, 96 for Revision B, and 234 for Revision C.<a class="footnote-ref" id="fnref:34" href="#fn:34">34</a>

<h2 id="description">Description</h2>
<h3>Program editing</h3>

Atari BASIC is anchored around its <a href="/facts/Line_editor/DdVGP8uP">line editor</a>. Program lines can be up to three physical screen lines of 40 characters, 120 characters total. The cursor can be moved freely, with the editor automatically tracking which BASIC program line the current screen line is part of. For instance, if the cursor is currently positioned in line 30 and the user uses cursor-up into line 20, any editing from that point will be carried out on line 20.
Atari BASIC's editor catches many errors are ignored in Microsoft-derived versions. If an error is found, the editor re-displays the line, highlighting the text near the error in <a href="/facts/Inverse_video/KrML9x2r">inverse video</a>. Errors are displayed as numeric codes, with the descriptions printed in the manual.<a class="footnote-ref" id="fnref:35" href="#fn:35">35</a> Because of the way the line editor works, the user can immediately fix the error. In the example pictured above (with PRUNT), the error can be fixed by moving the cursor over the U, typing I (the editor only has an overwrite mode), and hitting RETURN.
A line entered with a leading number, from 0 to 32767,<a class="footnote-ref" id="fnref:36" href="#fn:36">36</a> is inserted in the current program or replaces an existing line. If there's no line number, the interpreter assigns it the number -1 ($8000) and the commands are executed immediately, in "immediate mode". The RUN command executes the stored program from the lowest line number. Atari BASIC allows all commands to be executed in both modes. For example, LIST can be used inside a program, whereas in many interpreters this would be available in immediate mode only.
During entry, keywords can be abbreviated using the pattern set by <a href="/facts/Palo_Alto_Tiny_BASIC/Gvglhjku">Palo Alto Tiny BASIC</a>, by typing a period at any point in the word. So L. is expanded to LIST, as is LI.. Only enough letters have to be typed to make the abbreviation unique, so PLOT requires PL. because the single letter P is not unique. To expand an abbreviation, the tokenizer searches through its list of reserved words to find the first that matches the portion supplied. More commonly used commands occur first in the list of reserved words, with REM at the beginning (it can be typed as .). When the program is later LISTed it will always write out the full words with three exceptions: PRINT has a synonym, ?; GOTO has a synonym, GO TO; and LET has a synonym which is the empty string (so 10 LET A = 10 and 10 A = 10 mean the same thing). These are separate tokens, and so will remain as such in the program listing. MS BASICs also allowed ? as a short-form for PRINT, but this used the same token so it expanded back to PRINT when LISTed, treating it as an abbreviation, not a synonym.

<h3>Tokenizer</h3>
When the user presses RETURN while editing, the current line is copied into the BASIC Input Line Buffer in memory between $0580 and $05FF.<a class="footnote-ref" id="fnref:37" href="#fn:37">37</a> Atari BASIC's <a href="/facts/Token_(parser)/T1JYWpIf">tokenizer</a> scans the text, converting each keyword to a single-byte token (for example, PRINT is $20),<a class="footnote-ref" id="fnref:38" href="#fn:38">38</a> each number to a six-byte floating point value, each variable name to an index into a table, and so on, until the line is fully turned into an easy to interpret format. The result is stored in an output buffer located at the first 256 bytes of the lowest available free memory, pointed to by the LOMEM pointer stored at $80, $81.<a class="footnote-ref" id="fnref:39" href="#fn:39">39</a> The output from the tokenizer is then relocated. The program is stored as a <a href="/facts/Parse_tree/FeBEtXcz">parse tree</a>.<a class="footnote-ref" id="fnref:40" href="#fn:40">40</a>
Shepardson referred to this complete-tokenizing concept as a "pre-compiling interpreter".<a class="footnote-ref" id="fnref:41" href="#fn:41">41</a> The resulting tokenized code eliminates any parsing during runtime, making it run faster. It has the disadvantage that small constants, like 0 or 1, are six bytes each, longer than the original text.
A set of pointers (addresses) indicates various data: variable names are stored in the variable name table (VNTP – $82, $83) and their values are stored in the variable value table (pointed to at VVTP – $86, $87). By <a href="/facts/Indirection/JghDuGxe">indirecting</a> the variable names in this way, a reference to a variable needs only one byte to address its entry into the appropriate table. String variables have their own area (pointed to at STARP – $8C, $8D) as does the runtime stack (pointed to at RUNSTK – $8E, $8F) used to store the line numbers of looping statements (FOR...NEXT) and subroutines (GOSUB...RETURN). Finally, the end of BASIC memory usage is indicated by an address stored at MEMTOP – $90, $91) pointer.

<h3>Math functions</h3>
Atari BASIC includes three trigonometric functions: sine, cosine, and arc tangent. DEG and RAD set whether these functions use radians or degrees, defaulting to radians. Eight additional functions include rounding, logarithms, and square root. The random function, RND, generates a number between 0 and 1; the parameter not being used.

<h3>String handling</h3>
Atari BASIC copied the string-handling system of <a href="/facts/HP_Time-Shared_BASIC/VnKEA3Y6">Hewlett-Packard BASIC</a>,<a class="footnote-ref" id="fnref:42" href="#fn:42">42</a> where the basic data type is a single character, and strings are arrays of characters. Internally, a string is represented by a pointer to the first character in the string and its length. To initialize a string, it must be DIMensioned with its maximum length. For example:

10 DIM A$(20)
20 PRINT "ENTER MESSAGE: ";
30 INPUT A$
40 PRINT A$

In this program, a 20 character string is reserved, and any characters in excess of the string length will be truncated. The maximum length of a string is 32,768 characters. There is no support for arrays of strings.
A string is accessed using array indexing functions, or <a href="/facts/Array_slicing/IXvLFK7d">slicing</a>. A$(1,10) returns a string of the first 10 characters of A$. The arrays are 1-indexed, so a string of length 10 starts at 1 and ends at 10. Slicing functions simply set pointers to the start and end points within the existing allocated memory.
Arrays are not initialized, so a numeric array or string contains whatever data was in memory when it was allocated. The following trick allows fast string initialization, and it is also useful for clearing large areas of memory of unwanted garbage. Numeric arrays can only be cleared with a FOR...NEXT loop:

10 REM Initialize A$ with 1000 characters of X
20 DIM A$(1000)
30 A$="X":A$(1000)=A$:A$(2)=A$

String concatenation works as in the following example. The target string must be large enough to hold the combined string or an error will result:

10 DIM A$(12),B$(6)
20 A$="Hello ":B$="there!"
30 A$(LEN(A$)+1)=B$
40 PRINT A$

Values in DATA statements are comma-delimited and untyped. Consequently, strings in DATA statements are not typically enclosed by quote marks. As a result, it is not possible for data items to contain a comma but they can incorporate double-quotes. Numeric values in DATA statements are read as strings or as numbers according to the type of the variable they are read into. The READ statement cannot be used with array variables.

<h3>Input/output</h3>
The Atari <a href="/facts/Operating_system/8XTuvMh2">OS</a> includes a subsystem for <a href="/facts/Peripheral/3lEBPE14">peripheral</a> device input/output (I/O) known as CIO (Central Input/Output). Most programs can be written independently of what device they might use, as they all conform to a common interface; this was rare on home computers at the time. New device drivers could be written fairly easily that would automatically be available to Atari BASIC and any other program using the Atari OS, and existing drivers could be supplanted or augmented by new ones. A replacement E:, for example could displace the one in ROM to provide an 80-column display, or to piggyback on it to generate a <a href="/facts/Checksum/AqxQ0I8g">checksum</a> whenever a line is returned (such as used to verify a type-in program listing).
Atari BASIC supports CIO access with reserved words OPEN #, CLOSE #, PRINT #, INPUT #, GET #, PUT #, NOTE #, POINT # and XIO #. There are routines in the OS for simple graphics drawing functions but not all are available as specific BASIC keywords. PLOT and DRAWTO for line drawing are supported while a command providing area fill for primitive linear geometric shapes is not. The fill feature can be used through the general CIO entry point, which is called using the BASIC command XIO.
The BASIC statement OPEN # prepares a device for I/O access:

10 REM Opens the cassette device on channel 1 for reading in BASIC
20 OPEN #1,4,0,"C:MYPROG.DAT"

Here, OPEN # means "ensure channel 1 is free," call the C: driver to prepare the device (this will set the cassette tape spools onto tension and advance the heads keeping the cassette tape player "paused"). The 4 means "read" (other codes are 8 for write and 12 = 8 + 4 for "read-and-write"). The third number is auxiliary information, set to 0 when not needed. The C:MYPROG.DAT is the name of the device and the filename; the filename is ignored for the cassette driver. Physical devices can have numbers (mainly disks, printers and serial devices), so "P1:" might be the plotter and "P2:" the daisy-wheel printer, or "D1:" may be one disk drive and "D2:" and so on. If not present, 1 is assumed.
The LPRINT statement sends a string to the printer.
A is read by PEEKing memory locations maintained by the keyboard driver or by opening it as a file (e.g. OPEN 1,4,0,"K:":GET #1,A$). The latter waits for a keypress.
Typing DOS from BASIC exits to the <a href="/facts/Atari_DOS/WCbXpP5N">Atari DOS</a> command menu. Any unsaved programs are lost unless a memory-swapping file feature has been enabled on the current disk. There is no command to display a disk directory from within BASIC; this must be done by exiting to DOS.

<h3>Graphics and sound</h3>
Atari BASIC supports sound, (via the SOUND statement), graphics (GRAPHICS, SETCOLOR, COLOR, PLOT, DRAWTO), and controllers (STICK, STRIG, PADDLE, PTRIG).<a class="footnote-ref" id="fnref:43" href="#fn:43">43</a> The SOUND statement sets one of hardware's 4 square-wave channels with parameters for volume, pitch and distortion.
Advanced capabilities of the hardware such as higher pitch resolution, high-pass filters, digitised sound and waveforms, player/missile graphics (<a href="/facts/Sprite_(computer_graphics)/qLHf8V8e">sprites</a>), redefined character sets, scrolling, and custom graphics modes are not supported by BASIC; these will require machine language routines or PEEK/POKE statements. A few of the 16 basic character/graphics modes supported by the hardware cannot be simply accessed from BASIC on the Atari 400/800 as the OS ROMs do not support them. These include some multicolour character modes (ANTIC modes 4 & 5), descender character mode (ANTIC mode 3) and the highest resolution 2 and 4-color modes (ANTIC modes C & E, 160x192 pixels). The only way to access them is via PEEK/POKE or machine language, setting the ANTIC registers and Display List manually. The OS ROMs on the XL/XE added support for these modes except for ANTIC mode 3, which requires a character set redefined in RAM to operate correctly.<a class="footnote-ref" id="fnref:44" href="#fn:44">44</a>
Bitmap modes in BASIC are normally set to have a text window occupying the last four rows at the bottom of the screen so the user may display prompts and enter data in a program. If a 16 is added to the mode number invoked via the GRAPHICS statement, the entire screen will be in bitmap mode (e.g. GRAPHICS 8+16). If bitmap mode in full screen is invoked Atari BASIC will gracefully switch back into text mode when program execution is terminated, avoiding leaving the user with an unresponsive screen that must be escaped by typing a blind command or resetting the computer.
Bitmap coordinates are in the range of 0 to maximum row/column minus one, thus in Mode 6 (160x192), the maximum coordinates for a pixel can be 159 and 191. If Atari BASIC attempts to plot beyond the allowed coordinates for the mode a runtime error occurs.

<h2 id="advanced-techniques">Advanced techniques</h2>
<h3>Strings as a way to manipulate memory</h3>
The base addresses of a string is stored in a variable table. String addresses can be redirected to point to arbitrary areas of RAM. This allows the rapid memory-shifting routines underlying string and substring assignment can be applied from BASIC to the memory used for the screen or player/missile graphics. This is particularly useful for achieving rapid vertical movement of player/missile images directly from Atari BASIC.

<h3>Random access via DATA/RESTORE</h3>
Numeric variables and expressions can be used as the parameter for the RESTORE statement, allowing DATA statements to be randomly accessed through code such as RESTORE ROOMBASE+ROOMNUMBER:READ DESCRIPTION$, TREASURE$, EXITS. This can also be used to emulate static string arrays: RESTORE STRBASE+INDEX:READ A$:PRINT A$.

<h3>Error handling with TRAP</h3>
The TRAP statement jumps to a line number when an error occurs, and this reduces the need for manual error-checking. For example, when drawing graphics on the screen it is not necessary to check whether lines go beyond screen boundaries of the current graphics mode. This error state can be trapped, and the error handled if necessary.

<h3>Includes</h3>
The ENTER command reads source code from a device and merges it into the current program, as if the user had typed it in. This allows programs to be saved out in sections via LIST, reading them in using ENTER to merge or replace existing code. By using blocks of line numbers that do not overlap, programmers can build libraries of subroutines and merge them into new programs as needed.

<h3>Self-modifying code</h3>
The editor can be set-up to repeatedly read input from the screen until an EOF is reached. This allows a program to write new program code followed by a CONT statement to the screen then, positioning the screen cursor at the start of the new code, STOP the running program, causing the new code to be read in then execution be continued by the CONT statement.

<h3>Embedded machine language</h3>
Atari BASIC can call machine code subroutines stored in strings or POKEed into memory. The 256 byte area starting at address 1536 ($0600) is often used for this purpose.
Machine code is invoked with the USR function. The first parameter is the address of the subroutine and the following values are parameters. If the code is stored in a string named ROUTINE$ it can be called with two parameters as ANSWER=USR(ADR(ROUTINE$),VAR1,VAR2).
Parameters are pushed onto the hardware stack as 16-bit integers in the order specified in the USR call in low byte, high byte order. A final byte is pushed indicating the number of arguments. The machine language code must remove these values before returning via the RTS instruction. A 16-bit value can be returned to BASIC by placing it in addresses 212 and 213 ($D4 and $D5).

<h2 id="performance">Performance</h2>
In theory, Atari BASIC should run faster than contemporary BASICs based on the MS pattern. Because the source code is fully tokenized when it is entered, the entire tokenization and parsing steps are already complete. Even complex mathematical operations are ready-to-run, with any numerical constants already converted to the internal 40-bit format, and variables values are looked up by address rather than having to be searched for.<a class="footnote-ref" id="fnref:45" href="#fn:45">45</a> Despite these advantages, in practice, Atari BASIC is slower than most other <a href="/facts/Home_computer/CDEPVd1T">home computer</a> BASICs, often by a large amount.<a class="footnote-ref" id="fnref:46" href="#fn:46">46</a>
On two widely used <a href="/facts/Benchmark_(computing)/XSS42cRe">benchmarks</a> of the era, <a href="/facts/Byte_(magazine)/xWovF95Q">Byte</a> magazine's <a href="/facts/Byte_Sieve/N2LlNKQq">Sieve of Eratosthenes</a> and the <a href="/facts/Creative_Computing_benchmark/M0HEu4TJ">Creative Computing benchmark</a> test written by <a href="/facts/David_H._Ahl/JFhhCq7s">David H. Ahl</a>, the Atari finished near the end of the list in terms of performance, and was much slower than the contemporary <a href="/facts/Apple_II/se82CNvK">Apple II</a> and <a href="/facts/Commodore_PET/08R12Xk4">PET</a>,<a class="footnote-ref" id="fnref:47" href="#fn:47">47</a> in spite of having the same CPU running at roughly twice the speed. It finished behind slower machines like the <a href="/facts/ZX81/I0uDYb3n">ZX81</a> and even some programmable calculators.<a class="footnote-ref" id="fnref:48" href="#fn:48">48</a>
Most of the language's slowness stems from three problems.<a class="footnote-ref" id="fnref:49" href="#fn:49">49</a>
The first is that the floating-point math routines are poorly optimized. In the Ahl benchmark, a single exponent operation was responsible for much of the machine's poor showing.<a class="footnote-ref" id="fnref:50" href="#fn:50">50</a> The conversion between floating-point and 16-bit integers is also particularly slow. Internally, these integers are used for line numbers and array indexing, along with a few other tasks, but numbers in the tokenized program are stored in <a href="/facts/Binary-coded_decimal/dWTaE7ES">binary-coded decimal</a> (BCD) format.<a class="footnote-ref" id="fnref:51" href="#fn:51">51</a> Whenever one of these is encountered, such as the line number in GOTO 100, the BCD value is converted to an integer, which can take up to 3500 microseconds.<a class="footnote-ref" id="fnref:52" href="#fn:52">52</a>
Another issue is how Atari BASIC implements branches. To perform a branch in a GOTO or GOSUB, the interpreter searches through the entire program for the matching line number.<a class="footnote-ref" id="fnref:53" href="#fn:53">53</a> In contrast, contemporary versions of MS-derived BASICs would search forward from the current line if the line number of the branch target was greater, thereby improving branch performance about two times on average.
A related and more serious problem is the implementation of FOR...NEXT loops. When a FOR statement is executed, Atari BASIC records its line number. Every time the NEXT is reached, it searches through the program for that line, despite it being in the same place as the last time.<a class="footnote-ref" id="fnref:54" href="#fn:54">54</a> All other BASICs instead record the memory location of the FOR statement and can immediately return to it without having to search.
The reason for this poor performance is best illustrated by a quote from one of its primary authors, Bill Wilkinson; in 1982 he stated:

<blockquote>Personally, I have never been sure it is necessary for an interpreted language (e.g., BASIC) to be fast. Authors... have claimed that Atari BASIC is the slowest language ever created. My first impulse was to say, "Who cares?"<a class="footnote-ref" id="fnref:55" href="#fn:55">55</a></blockquote>
One may contrast this philosophy with that of <a href="/facts/Steve_Wozniak/qSHwIrMz">Steve Wozniak</a>'s <a href="/facts/Integer_BASIC/Bu2EdGjz">Apple BASIC</a> for the original <a href="/facts/Apple_I/MCLPkKgE">Apple I</a> which was designed specifically to have the performance required to write games:

<blockquote>After designing hardware arcade games, I knew that being able to program them in BASIC was going to change the world.<a class="footnote-ref" id="fnref:56" href="#fn:56">56</a></blockquote>
Several third-party BASICs emerged on the platform that addressed some or all of these issues. This included Wilkinson's own <a href="/facts/BASIC_XL/FnxzJslo">BASIC XL</a>, which reduced the time for the Byte benchmark from 194 to 58 seconds,<a class="footnote-ref" id="fnref:57" href="#fn:57">57</a> over three times as fast. On the Ahl benchmark, Atari BASIC required 405 seconds, while exactly the same code in Turbo-BASIC XL took 41.6 seconds, an order of magnitude improvement.<a class="footnote-ref" id="fnref:58" href="#fn:58">58</a>

<h2 id="differences-from-microsoft-basic">Differences from Microsoft BASIC</h2>
<ul><li>Syntax is checked and errors highlighted immediately on line entry.</li>
<li>Variable names can be of arbitrary length, and all characters are significant.</li>
<li>Any keyword can be used as a variable, if defined with LET.<a class="footnote-ref" id="fnref:59" href="#fn:59">59</a></li>
<li>The following keywords are not in Atari BASIC: INKEY$, CLS,DEF FN, SPC, TAB, ELSE.</li>
<li>All arrays must be dimensioned prior to use while Microsoft BASIC defaults an array to 10 elements if not dimensioned.</li>
<li>String variables are treated as character arrays and must be dimensioned before use. MS BASIC stores strings on the <a href="/facts/Heap_(programming)/vthLkUpz">heap</a> and sometimes pauses for <a href="/facts/Garbage_collection_(computer_science)/j2vlIu7g">garbage collection</a>.</li>
<li>The functions LEFT$, MID$, and RIGHT$ are replaced by string indexing.</li>
<li>There is not an operator for string concatenation.</li>
<li>There are no arrays of strings.</li>
<li>There is no support for integer variables.</li>
<li>There are no bitwise operators.</li>
<li>INPUT does not allow a prompt.</li>
<li>PRINT may be abbreviated as ? as in Microsoft BASIC, but Atari BASIC does not tokenize it into PRINT. It remains a question mark.</li>
<li>The target of GOTO and GOSUB can be a variable or expression.</li>
<li>RESTORE may take a numeric constant, variable, or expression as a parameter, causing the next READ to begin from the specified line number</li>
<li>FOR..NEXT loops in Atari BASIC must have a variable name referenced by the NEXT statement while Microsoft BASIC does not require it.</li>
<li>Multiple variables are not permitted with NEXT statements as they are in Microsoft BASIC (e.g., NEXT X,Y).</li>
<li>LIST uses a comma to separate a range instead of a minus sign.</li></ul>
<h2 id="keywords">Keywords</h2>
Atari BASIC keywords<table><tbody><tr><th>Keyword</th><th>Description</th></tr><tr><td>ABS</td><td>Returns the <a href="/facts/Absolute_value/dwJBpEs5">absolute value</a> of a number</td></tr><tr><td>ADR</td><td>Returns the address in memory of a variable (mostly used for machine code routines stored in variables)</td></tr><tr><td>AND</td><td><a href="/facts/Logical_conjunction/62uyyn1d">Logical conjunction</a></td></tr><tr><td>ASC</td><td>Returns the <a href="/facts/ATASCII/d3xS85B4">ATASCII</a> value of a character</td></tr><tr><td>ATN</td><td>Returns the <a href="/facts/Arctangent/bVwU9FPG">arctangent</a> of a number</td></tr><tr><td>BYE</td><td>Transfers control to the internal "Self Test" program ("Memo Pad" on early models)</td></tr><tr><td>CHR$</td><td>Returns a character given an <a href="/facts/ATASCII/d3xS85B4">ATASCII</a> value</td></tr><tr><td>CLOAD</td><td>Loads from <a href="/facts/Cassette_tape/w8I5uyfs">cassette tape</a> a <a href="/facts/Tokenization_(data_security)/QA2yomxu">tokenized</a> program that was saved with CSAVE</td></tr><tr><td>CLOG</td><td>Returns the <a href="/facts/Common_logarithm/q6EhDnWk">common logarithm</a> of a number</td></tr><tr><td>CLOSE</td><td>Terminates pending transfers (flush) and closes an I/O channel</td></tr><tr><td>CLR</td><td>Clears variables' memory and program stack</td></tr><tr><td>COLOR</td><td>Chooses which logical color to draw in</td></tr><tr><td>COM</td><td>Implementation of MS Basic's COMMON was cancelled. Recognized but the code for DIM is executed instead</td></tr><tr><td>CONT</td><td>Resumes execution of a program after a STOP at the next line number (see STOP)</td></tr><tr><td>COS</td><td>Returns the <a href="/facts/Cosine/czej7ur0">cosine</a> of a number</td></tr><tr><td>CSAVE</td><td>Saves to <a href="/facts/Cassette_tape/w8I5uyfs">cassette tape</a> a program in <a href="/facts/Tokenization_(data_security)/QA2yomxu">tokenized</a> form (see CLOAD)</td></tr><tr><td>DATA</td><td>Stores data in lists of numeric or string values</td></tr><tr><td>DEG</td><td>Switches trigonometric functions to compute in <a href="/facts/Degree_(angle)/f48Ns8SX">degrees</a> (<a href="/facts/Radian/Srd38Sxa">radians</a> is the default mode) (see RAD)</td></tr><tr><td>DIM</td><td>Defines the size of a string or array (see COM)</td></tr><tr><td>DOS</td><td>Transfers control to the Disk Operating System (DOS); if DOS was not loaded, same as BYE</td></tr><tr><td>DRAWTO</td><td>Draws a line to given <a href="/facts/Cartesian_coordinate_system/lkTqvMmB">coordinates</a></td></tr><tr><td>END</td><td>Finishes execution of the program, closes open I/O channels and stops any sound</td></tr><tr><td>ENTER</td><td>Loads and merges into memory a plain text program from an external device, usually from <a href="/facts/Cassette_tape/w8I5uyfs">cassette tape</a> or disk (see LIST)</td></tr><tr><td>EXP</td><td><a href="/facts/Exponential_function/ewlYxvR2">Exponential function</a></td></tr><tr><td>FOR</td><td>Starts a <a href="/facts/For_loop/cwV2nRzp">for loop</a></td></tr><tr><td>FRE</td><td>Returns the amount of free memory in bytes</td></tr><tr><td>GET</td><td>Reads one byte from an I/O channel (see PUT)</td></tr><tr><td><a href="/facts/GOSUB/VYMl5TmA">GOSUB</a></td><td>Jumps to a subroutine at a given line in the program, placing the return address on the stack (see POP and RETURN)</td></tr><tr><td><a href="/facts/GOTO/V3bV9yVn">GOTO</a> and GO TO</td><td>Jumps to a given line in the program. GOTO can be omitted in "IF ... THEN GOTO ..."</td></tr><tr><td>GRAPHICS</td><td>Sets the graphics mode</td></tr><tr><td>IF</td><td>Executes code depending on whether a condition is true or not</td></tr><tr><td>INPUT</td><td>Retrieves a stream of text from an I/O channel; usually data from keyboard (default), <a href="/facts/Cassette_tape/w8I5uyfs">cassette tape</a> or disk</td></tr><tr><td>INT</td><td>Returns the <a href="/facts/Floor_and_ceiling_functions/ssehyMMf">floor</a> of a number</td></tr><tr><td>LEN</td><td>Returns the length of a string</td></tr><tr><td>LET</td><td>Assigns a value to a variable. LET can be omitted</td></tr><tr><td>LIST</td><td>Lists (all or part of) the program to screen (default), printer, disk, <a href="/facts/Cassette_tape/w8I5uyfs">cassette tape</a>, or any other external device (see ENTER)</td></tr><tr><td>LOAD</td><td>Loads a <a href="/facts/Tokenization_(data_security)/QA2yomxu">tokenized</a> program from an external device; usually a <a href="/facts/Cassette_tape/w8I5uyfs">cassette tape</a> or disk (see SAVE)</td></tr><tr><td>LOCATE</td><td>Stores the logical color or <a href="/facts/ATASCII/d3xS85B4">ATASCII</a> character at given coordinates</td></tr><tr><td>LOG</td><td>Returns the <a href="/facts/Natural_logarithm/PnreKEzI">natural logarithm</a> of a number</td></tr><tr><td>LPRINT</td><td>Prints text to a printer device (same result can be achieved with OPEN, PRINT and CLOSE statements)</td></tr><tr><td>NEW</td><td>Erases the program and all the variables from memory; automatically executed before a LOAD or CLOAD</td></tr><tr><td>NEXT</td><td>Continues the next iteration of a FOR loop</td></tr><tr><td>NOT</td><td><a href="/facts/Negation/q5AQBvBj">Logical negation</a></td></tr><tr><td>NOTE</td><td>Returns the current position on an I/O channel</td></tr><tr><td>ON</td><td>A <a href="/facts/Computed_goto/V3bV9yVn">computed goto</a> or gosub - performs a jump based on the value of an expression</td></tr><tr><td>OPEN</td><td>Initialises an I/O channel</td></tr><tr><td>OR</td><td><a href="/facts/Logical_disjunction/jbI2EGlM">Logical disjunction</a></td></tr><tr><td>PADDLE</td><td>Returns the position of a <a href="/facts/Paddle_(game_controller)/dLUxdY1C">paddle controller</a></td></tr><tr><td><a href="/facts/PEEK_and_POKE/FbehgI9c">PEEK</a></td><td>Returns the value at an address in memory</td></tr><tr><td>PLOT</td><td>Draws a point at given coordinates</td></tr><tr><td>POINT</td><td>Sets the current position on an I/O channel</td></tr><tr><td><a href="/facts/PEEK_and_POKE/FbehgI9c">POKE</a></td><td>Sets a value at an address in memory</td></tr><tr><td>POP</td><td>Removes a subroutine return address from the stack (see GOSUB and RETURN)</td></tr><tr><td>POSITION</td><td>Sets the position of the graphics cursor</td></tr><tr><td>PRINT and ?</td><td>Writes text to an I/O channel; usually to screen (default), printer, <a href="/facts/Cassette_tape/w8I5uyfs">cassette tape</a> or disk (see LPRINT and INPUT)</td></tr><tr><td>PTRIG</td><td>Indicates whether a paddle trigger is pressed or not</td></tr><tr><td>PUT</td><td>Writes one byte to an I/O channel (see GET)</td></tr><tr><td>RAD</td><td>Switches trigonometric functions to compute in <a href="/facts/Radian/Srd38Sxa">radians</a> (see DEG)</td></tr><tr><td>READ</td><td>Reads data from a DATA statement</td></tr><tr><td>REM</td><td>Marks a comment in a program</td></tr><tr><td>RESTORE</td><td>Sets the position of where to read data from a DATA statement</td></tr><tr><td>RETURN</td><td>Ends a subroutine, effectively branching to the line immediately following the "calling" GOSUB (see GOSUB and POP)</td></tr><tr><td>RND</td><td>Returns a <a href="/facts/Pseudorandom_number_generator/sIrCxIBq">pseudorandom number</a></td></tr><tr><td>RUN</td><td>Starts execution of a program, optionally loading it from an external device (see LOAD)</td></tr><tr><td>SAVE</td><td>Writes a <a href="/facts/Tokenization_(data_security)/QA2yomxu">tokenized</a> program to an external device; usually a <a href="/facts/Cassette_tape/w8I5uyfs">cassette tape</a> or disk (see LOAD)</td></tr><tr><td>SETCOLOR</td><td>Maps a logical color to a physical color</td></tr><tr><td>SGN</td><td>Returns the <a href="/facts/Sign_function/VADy9zQq">signum</a> of a number</td></tr><tr><td>SIN</td><td>Returns the <a href="/facts/Sine_and_cosine/0UtQ97vu">sine</a> of a number</td></tr><tr><td>SOUND</td><td>Starts or stops playing a tone on a sound channel (see END)</td></tr><tr><td>SQR</td><td>Returns the <a href="/facts/Square_root/AfrzfBdQ">square root</a> of a number</td></tr><tr><td>STATUS</td><td>Returns the status of an I/O channel</td></tr><tr><td>STEP</td><td>Indicates the increment used in a FOR loop</td></tr><tr><td>STICK</td><td>Returns a <a href="/facts/Joystick/cY64dGpb">joystick</a> position</td></tr><tr><td>STOP</td><td>Stops the program, allowing later resumption (see CONT)</td></tr><tr><td>STRIG</td><td>Indicates whether a joystick trigger is pressed or not</td></tr><tr><td>STR$</td><td>Converts a number to string form</td></tr><tr><td>THEN</td><td>Indicates the statements to execute if the condition is true in an IF statement</td></tr><tr><td>TO</td><td>Indicates the limiting condition in a FOR statement</td></tr><tr><td>TRAP</td><td>Sets to jump to a given program line if an error occurs (TRAP 40000 cancels this order)</td></tr><tr><td>USR</td><td>Calls a machine code routine, optionally with parameters</td></tr><tr><td>VAL</td><td>Returns the numeric value of a string</td></tr><tr><td>XIO</td><td>General-purpose I/O routine (from "Fill screen" to "Rename file" to "Format disk" instructions)</td></tr></tbody></table>
<h2 id="see-also">See also</h2>
<ul><li><a href="/facts/Atari_Calculator/9bRpWpMA">Atari Calculator</a></li></ul>
<h2 id="notes">Notes</h2>

<h3>Citation</h3>

<h3>Bibliography</h3>

<ul><li><a href="https://web.archive.org/web/20050501034651/http://www.strotmann.de/twiki/bin/view/Infothek/AtBasicReferenceMa">The ATARI BASIC Reference Manual</a>. Atari Inc. 1980. Archived from <a href="https://www.strotmann.de/twiki/bin/view/Infothek/AtBasicReferenceMa">the original</a> on May 1, 2005.</li>
<li>Chadwick, Ian (1985). <a href="https://archive.org/details/ataribooks-mapping-the-atari">Mapping the Atari</a>. Compute! Publications. <a href="/facts/ISBN_(identifier)/15AdSPa9">ISBN</a> 0-87455-004-1.</li>
<li>Crawford, Chris (1982). <a href="https://archive.org/details/ataribooks-de-re-atari">De Re Atari</a>. Atari Program Exchange.</li>
<li><a href="https://www.autometer.de/unix4fun/z80pack/ftp/cromemco/Cromemco%2016K%20Extended%20BASIC%20Instruction%20023-0037%201978.pdf">Cromemco 16K Extended BASIC</a> (PDF). Cromemco. 1978.</li>
<li>Wilkinson, Bill (1982). <a href="http://www.atariarchives.org/iad/introduction.php">Inside Atari DOS</a>. Optimized Systems Software, Inc. <a href="/facts/ISBN_(identifier)/15AdSPa9">ISBN</a> 0-942386-02-7. Retrieved 2009-04-04.</li>
<li><a href="/facts/Joseph_C._Decuir/T6AyEcqN">Decuir, Joe</a> (December 30, 2004). <a href="https://www.atariarchives.org/dev/CGEXPO99.html">3 Generations of Game Machine Architecture</a> (Speech). Classic Gaming Expo 2004. San Jose Convention Center.</li>
<li>Wilkinson, Bill; O'Brien, Kathleen; Laughton, Paul (1983). <a href="https://archive.org/details/ataribooks-the-atari-basic-source-book">The Atari BASIC Source Book</a>. Compute! Books. <a href="/facts/ISBN_(identifier)/15AdSPa9">ISBN</a> 0-942386-15-9.</li>
<li>Wilkinson, Bill (February 1985). <a href="https://www.atarimagazines.com/compute/issue57/insight_atari.html">"INSIGHT: Atari"</a>. Creative Computing. pp. 139–140.</li></ul>

<h2 id="external-links">External links</h2>
<ul><li><a href="https://web.archive.org/web/20070524044410/http://www3.sympatico.ca/maury/other_stuff/atari_basic.html">Atari BASIC, The Good, the Bad, and the Ugly</a></li>
<li>Albrecht, Bob; Finkel, LeRoy; Brown, Jerald R. (1979). <a href="http://www.atariarchives.org/basic/">Atari Basic - A Self-Teaching Guide</a>. Retrieved 29 June 2013.</li>
<li>Albrecht, Bob; Finkel, LeRoy; Brown, Jerald R. (1985). <a href="http://www.atariarchives.org/basicxl/">Atari Basic - XL Edition</a>. Retrieved 29 June 2013.</li>
<li>Wikiversity: Atari BASIC programming</li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1">"Compute!'s First Book of Atari". www.atariarchives.org. Retrieved 2024-09-11. Carol Shaw, Keith Brewster. BASIC REFERENCE MANUAL. draft, Atari, Inc., Sunnyvale, CA (1979) <a href="https://www.atariarchives.org/c1ba/page007.php" target="_blank">https://www.atariarchives.org/c1ba/page007.php</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></li>
<li id="fn:2">Edwards, Benj (12 October 2011). "VC&G Interview: Carol Shaw, Atari's First Female Video Game Developer". They had a manual for Atari BASIC [for the Atari 800] and somebody wrote sort of a cutesy manual that was supposed to be very humorous, but it had a lot of technical errors in it. I ended up rewriting the manual. Retrieved 2024-09-11. <a href="https://www.vintagecomputing.com/index.php/archives/800/vcg-interview-carol-shaw-female-video-game-pioneer-2" target="_blank">https://www.vintagecomputing.com/index.php/archives/800/vcg-interview-carol-shaw-female-video-game-pioneer-2</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></li>
<li id="fn:3">"Women in tech: The groundbreaking career of video game pioneer Carol Shaw". blog.avast.com. Retrieved 2024-09-11. <a href="https://blog.avast.com/women-in-tech-carol-shaw" target="_blank">https://blog.avast.com/women-in-tech-carol-shaw</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></li>
<li id="fn:4">Wilkinson, O'Brien & Laughton 1983. - Wilkinson, Bill; O'Brien, Kathleen; Laughton, Paul (1983). The Atari BASIC Source Book. Compute! Books. ISBN 0-942386-15-9. <a href="https://archive.org/details/ataribooks-the-atari-basic-source-book" target="_blank">https://archive.org/details/ataribooks-the-atari-basic-source-book</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></li>
<li id="fn:5">Decuir 2004. - Decuir, Joe (December 30, 2004). 3 Generations of Game Machine Architecture (Speech). Classic Gaming Expo 2004. San Jose Convention Center. <a href="https://www.atariarchives.org/dev/CGEXPO99.html" target="_blank">https://www.atariarchives.org/dev/CGEXPO99.html</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></li>
<li id="fn:6">Wilkinson 1982, p. ix. - Wilkinson, Bill (1982). Inside Atari DOS. Optimized Systems Software, Inc. ISBN 0-942386-02-7. Retrieved 2009-04-04. <a href="http://www.atariarchives.org/iad/introduction.php" target="_blank">http://www.atariarchives.org/iad/introduction.php</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></li>
<li id="fn:7">Steil, Michael (20 October 2008). "Create your own Version of Microsoft BASIC for 6502". Some Assembly Required. <a href="https://www.pagetable.com/?p=46" target="_blank">https://www.pagetable.com/?p=46</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></li>
<li id="fn:8">AppleSoft BASIC occupied memory locations $D000 through $F7FF, a total of 10240 bytes. <a href="#fnref:8" class="footnote-back-ref">↩</a></li>
<li id="fn:9">Wilkinson 1982, p. ix. - Wilkinson, Bill (1982). Inside Atari DOS. Optimized Systems Software, Inc. ISBN 0-942386-02-7. Retrieved 2009-04-04. <a href="http://www.atariarchives.org/iad/introduction.php" target="_blank">http://www.atariarchives.org/iad/introduction.php</a> <a href="#fnref:9" class="footnote-back-ref">↩</a></li>
<li id="fn:10">Wilkinson 1982, p. ix. - Wilkinson, Bill (1982). Inside Atari DOS. Optimized Systems Software, Inc. ISBN 0-942386-02-7. Retrieved 2009-04-04. <a href="http://www.atariarchives.org/iad/introduction.php" target="_blank">http://www.atariarchives.org/iad/introduction.php</a> <a href="#fnref:10" class="footnote-back-ref">↩</a></li>
<li id="fn:11">Wilkinson 1982, p. ix. - Wilkinson, Bill (1982). Inside Atari DOS. Optimized Systems Software, Inc. ISBN 0-942386-02-7. Retrieved 2009-04-04. <a href="http://www.atariarchives.org/iad/introduction.php" target="_blank">http://www.atariarchives.org/iad/introduction.php</a> <a href="#fnref:11" class="footnote-back-ref">↩</a></li>
<li id="fn:12">Wilkinson 1982, pp. iv–v. - Wilkinson, Bill (1982). Inside Atari DOS. Optimized Systems Software, Inc. ISBN 0-942386-02-7. Retrieved 2009-04-04. <a href="http://www.atariarchives.org/iad/introduction.php" target="_blank">http://www.atariarchives.org/iad/introduction.php</a> <a href="#fnref:12" class="footnote-back-ref">↩</a></li>
<li id="fn:13">Cromemco 1978. - Cromemco 16K Extended BASIC (PDF). Cromemco. 1978. <a href="https://www.autometer.de/unix4fun/z80pack/ftp/cromemco/Cromemco%2016K%20Extended%20BASIC%20Instruction%20023-0037%201978.pdf" target="_blank">https://www.autometer.de/unix4fun/z80pack/ftp/cromemco/Cromemco%2016K%20Extended%20BASIC%20Instruction%20023-0037%201978.pdf</a> <a href="#fnref:13" class="footnote-back-ref">↩</a></li>
<li id="fn:14">Lorenzo, Mark (2017). Endless Loop: The History of the BASIC Programming Language. Philadelphia: SE Books. p. 106. ISBN 978-1974-27707-0. <a href="978-1974-27707-0" target="_blank">978-1974-27707-0</a> <a href="#fnref:14" class="footnote-back-ref">↩</a></li>
<li id="fn:15">Cromemco 1978, pp. 2, 3. - Cromemco 16K Extended BASIC (PDF). Cromemco. 1978. <a href="https://www.autometer.de/unix4fun/z80pack/ftp/cromemco/Cromemco%2016K%20Extended%20BASIC%20Instruction%20023-0037%201978.pdf" target="_blank">https://www.autometer.de/unix4fun/z80pack/ftp/cromemco/Cromemco%2016K%20Extended%20BASIC%20Instruction%20023-0037%201978.pdf</a> <a href="#fnref:15" class="footnote-back-ref">↩</a></li>
<li id="fn:16">Commodore BASIC used two main areas of memory, $A000-$BFFF and $E000-$E4D2.[12] <a href="#fnref:16" class="footnote-back-ref">↩</a></li>
<li id="fn:17">Applesoft was in the area from $D000-$F7FF, including the FP library.[13] <a href="#fnref:17" class="footnote-back-ref">↩</a></li>
<li id="fn:18">Wilkinson 1982, p. v. - Wilkinson, Bill (1982). Inside Atari DOS. Optimized Systems Software, Inc. ISBN 0-942386-02-7. Retrieved 2009-04-04. <a href="http://www.atariarchives.org/iad/introduction.php" target="_blank">http://www.atariarchives.org/iad/introduction.php</a> <a href="#fnref:18" class="footnote-back-ref">↩</a></li>
<li id="fn:19">Wilkinson 1982, p. ix. - Wilkinson, Bill (1982). Inside Atari DOS. Optimized Systems Software, Inc. ISBN 0-942386-02-7. Retrieved 2009-04-04. <a href="http://www.atariarchives.org/iad/introduction.php" target="_blank">http://www.atariarchives.org/iad/introduction.php</a> <a href="#fnref:19" class="footnote-back-ref">↩</a></li>
<li id="fn:20">Wilkinson 1982, p. v. - Wilkinson, Bill (1982). Inside Atari DOS. Optimized Systems Software, Inc. ISBN 0-942386-02-7. Retrieved 2009-04-04. <a href="http://www.atariarchives.org/iad/introduction.php" target="_blank">http://www.atariarchives.org/iad/introduction.php</a> <a href="#fnref:20" class="footnote-back-ref">↩</a></li>
<li id="fn:21">Wilkinson 1982, p. x. - Wilkinson, Bill (1982). Inside Atari DOS. Optimized Systems Software, Inc. ISBN 0-942386-02-7. Retrieved 2009-04-04. <a href="http://www.atariarchives.org/iad/introduction.php" target="_blank">http://www.atariarchives.org/iad/introduction.php</a> <a href="#fnref:21" class="footnote-back-ref">↩</a></li>
<li id="fn:22">Cherry, Charles (June 1987). "BASIC Bonanza". Antic. <a href="https://www.atarimagazines.com/v6n2/BASICBonanza.html" target="_blank">https://www.atarimagazines.com/v6n2/BASICBonanza.html</a> <a href="#fnref:22" class="footnote-back-ref">↩</a></li>
<li id="fn:23">Wilkinson 1982, p. x. - Wilkinson, Bill (1982). Inside Atari DOS. Optimized Systems Software, Inc. ISBN 0-942386-02-7. Retrieved 2009-04-04. <a href="http://www.atariarchives.org/iad/introduction.php" target="_blank">http://www.atariarchives.org/iad/introduction.php</a> <a href="#fnref:23" class="footnote-back-ref">↩</a></li>
<li id="fn:24">Wilkinson 1982, p. vi. - Wilkinson, Bill (1982). Inside Atari DOS. Optimized Systems Software, Inc. ISBN 0-942386-02-7. Retrieved 2009-04-04. <a href="http://www.atariarchives.org/iad/introduction.php" target="_blank">http://www.atariarchives.org/iad/introduction.php</a> <a href="#fnref:24" class="footnote-back-ref">↩</a></li>
<li id="fn:25">"Atari BASIC Bugs". Compute!. July 1986. p. 10. <a href="http://www.atarimagazines.com/compute/issue74/readers_feedback_10.php" target="_blank">http://www.atarimagazines.com/compute/issue74/readers_feedback_10.php</a> <a href="#fnref:25" class="footnote-back-ref">↩</a></li>
<li id="fn:26">"Atari BASIC Bugs". Compute!. July 1986. p. 10. <a href="http://www.atarimagazines.com/compute/issue74/readers_feedback_10.php" target="_blank">http://www.atarimagazines.com/compute/issue74/readers_feedback_10.php</a> <a href="#fnref:26" class="footnote-back-ref">↩</a></li>
<li id="fn:27">Radcliff, Matthew (September 1985). "Revision C Converter". Antic. Retrieved 2023-07-08. <a href="https://www.atarimagazines.com/v4n5/revisioncconverter.html" target="_blank">https://www.atarimagazines.com/v4n5/revisioncconverter.html</a> <a href="#fnref:27" class="footnote-back-ref">↩</a></li>
<li id="fn:28">Chadwick 1985, p. 230. - Chadwick, Ian (1985). Mapping the Atari. Compute! Publications. ISBN 0-87455-004-1. <a href="https://archive.org/details/ataribooks-mapping-the-atari" target="_blank">https://archive.org/details/ataribooks-mapping-the-atari</a> <a href="#fnref:28" class="footnote-back-ref">↩</a></li>
<li id="fn:29">Chadwick 1985, p. 230. - Chadwick, Ian (1985). Mapping the Atari. Compute! Publications. ISBN 0-87455-004-1. <a href="https://archive.org/details/ataribooks-mapping-the-atari" target="_blank">https://archive.org/details/ataribooks-mapping-the-atari</a> <a href="#fnref:29" class="footnote-back-ref">↩</a></li>
<li id="fn:30">Chadwick 1985, pp. 250–251. - Chadwick, Ian (1985). Mapping the Atari. Compute! Publications. ISBN 0-87455-004-1. <a href="https://archive.org/details/ataribooks-mapping-the-atari" target="_blank">https://archive.org/details/ataribooks-mapping-the-atari</a> <a href="#fnref:30" class="footnote-back-ref">↩</a></li>
<li id="fn:31">Chadwick 1985, p. 230. - Chadwick, Ian (1985). Mapping the Atari. Compute! Publications. ISBN 0-87455-004-1. <a href="https://archive.org/details/ataribooks-mapping-the-atari" target="_blank">https://archive.org/details/ataribooks-mapping-the-atari</a> <a href="#fnref:31" class="footnote-back-ref">↩</a></li>
<li id="fn:32">Radcliff, Matthew (September 1985). "Revision C Converter". Antic. Retrieved 2023-07-08. <a href="https://www.atarimagazines.com/v4n5/revisioncconverter.html" target="_blank">https://www.atarimagazines.com/v4n5/revisioncconverter.html</a> <a href="#fnref:32" class="footnote-back-ref">↩</a></li>
<li id="fn:33">Chadwick 1985, p. 230. - Chadwick, Ian (1985). Mapping the Atari. Compute! Publications. ISBN 0-87455-004-1. <a href="https://archive.org/details/ataribooks-mapping-the-atari" target="_blank">https://archive.org/details/ataribooks-mapping-the-atari</a> <a href="#fnref:33" class="footnote-back-ref">↩</a></li>
<li id="fn:34">Hardy, Bob (February 1993). "Keycode Getter". Atari Classics. p. 18. <a href="https://www.atarimagazines.com/atariclassics/v2n1/keycode.php" target="_blank">https://www.atarimagazines.com/atariclassics/v2n1/keycode.php</a> <a href="#fnref:34" class="footnote-back-ref">↩</a></li>
<li id="fn:35">Manual 1980, Appendix B. - The ATARI BASIC Reference Manual. Atari Inc. 1980. Archived from the original on May 1, 2005. <a href="https://web.archive.org/web/20050501034651/http://www.strotmann.de/twiki/bin/view/Infothek/AtBasicReferenceMa" target="_blank">https://web.archive.org/web/20050501034651/http://www.strotmann.de/twiki/bin/view/Infothek/AtBasicReferenceMa</a> <a href="#fnref:35" class="footnote-back-ref">↩</a></li>
<li id="fn:36">Crawford 1982, p. 10.3. - Crawford, Chris (1982). De Re Atari. Atari Program Exchange. <a href="https://archive.org/details/ataribooks-de-re-atari" target="_blank">https://archive.org/details/ataribooks-de-re-atari</a> <a href="#fnref:36" class="footnote-back-ref">↩</a></li>
<li id="fn:37">Crawford 1982, p. 10.3. - Crawford, Chris (1982). De Re Atari. Atari Program Exchange. <a href="https://archive.org/details/ataribooks-de-re-atari" target="_blank">https://archive.org/details/ataribooks-de-re-atari</a> <a href="#fnref:37" class="footnote-back-ref">↩</a></li>
<li id="fn:38">Crawford 1982, p. 10.6. - Crawford, Chris (1982). De Re Atari. Atari Program Exchange. <a href="https://archive.org/details/ataribooks-de-re-atari" target="_blank">https://archive.org/details/ataribooks-de-re-atari</a> <a href="#fnref:38" class="footnote-back-ref">↩</a></li>
<li id="fn:39">Crawford 1982, p. 10.3. - Crawford, Chris (1982). De Re Atari. Atari Program Exchange. <a href="https://archive.org/details/ataribooks-de-re-atari" target="_blank">https://archive.org/details/ataribooks-de-re-atari</a> <a href="#fnref:39" class="footnote-back-ref">↩</a></li>
<li id="fn:40">Although the parse tree is implemented as a set of tables, which is really an implementation detail. <a href="#fnref:40" class="footnote-back-ref">↩</a></li>
<li id="fn:41">Wilkinson, O'Brien & Laughton 1983, p. 5. - Wilkinson, Bill; O'Brien, Kathleen; Laughton, Paul (1983). The Atari BASIC Source Book. Compute! Books. ISBN 0-942386-15-9. <a href="https://archive.org/details/ataribooks-the-atari-basic-source-book" target="_blank">https://archive.org/details/ataribooks-the-atari-basic-source-book</a> <a href="#fnref:41" class="footnote-back-ref">↩</a></li>
<li id="fn:42">HP 2000/Access BASIC Reference Manual (PDF). Hewlett Packard. May 1976. pp. e. <a href="http://bitsavers.org/pdf/hp/2000TSB/22687-90001_AccessBasic9-75.pdf" target="_blank">http://bitsavers.org/pdf/hp/2000TSB/22687-90001_AccessBasic9-75.pdf</a> <a href="#fnref:42" class="footnote-back-ref">↩</a></li>
<li id="fn:43">Manual 1980, p. 54. - The ATARI BASIC Reference Manual. Atari Inc. 1980. Archived from the original on May 1, 2005. <a href="https://web.archive.org/web/20050501034651/http://www.strotmann.de/twiki/bin/view/Infothek/AtBasicReferenceMa" target="_blank">https://web.archive.org/web/20050501034651/http://www.strotmann.de/twiki/bin/view/Infothek/AtBasicReferenceMa</a> <a href="#fnref:43" class="footnote-back-ref">↩</a></li>
<li id="fn:44">"ATR: chpt.15: Display Lists". <a href="http://www.atarimax.com/freenet/freenet_material/12.AtariLibrary/2.MiscellaneousTextFiles/showarticle.php?44" target="_blank">http://www.atarimax.com/freenet/freenet_material/12.AtariLibrary/2.MiscellaneousTextFiles/showarticle.php?44</a> <a href="#fnref:44" class="footnote-back-ref">↩</a></li>
<li id="fn:45">This is the reason MS-BASICs only have two significant letters in variable names, they are stored in a list with only two bytes of ASCII for the name in order to improve searching time. <a href="#fnref:45" class="footnote-back-ref">↩</a></li>
<li id="fn:46">Wilkinson 1985, p. 139. - Wilkinson, Bill (February 1985). "INSIGHT: Atari". Creative Computing. pp. 139–140. <a href="https://www.atarimagazines.com/compute/issue57/insight_atari.html" target="_blank">https://www.atarimagazines.com/compute/issue57/insight_atari.html</a> <a href="#fnref:46" class="footnote-back-ref">↩</a></li>
<li id="fn:47">Ahl, David (November 1983). "Benchmark comparison test". Creative Computing. pp. 259–260. <a href="https://archive.org/stream/creativecomputing-1983-11/Creative_Computing_v09_n11_1983_November#page/n271" target="_blank">https://archive.org/stream/creativecomputing-1983-11/Creative_Computing_v09_n11_1983_November#page/n271</a> <a href="#fnref:47" class="footnote-back-ref">↩</a></li>
<li id="fn:48">Ahl, David (January 1984). "Creative Computing Benchmark". Creative Computing. p. 12. <a href="https://archive.org/stream/Creative_Computing_1984-01#page/n15/mode/2up" target="_blank">https://archive.org/stream/Creative_Computing_1984-01#page/n15/mode/2up</a> <a href="#fnref:48" class="footnote-back-ref">↩</a></li>
<li id="fn:49">Wilkinson 1985, p. 139. - Wilkinson, Bill (February 1985). "INSIGHT: Atari". Creative Computing. pp. 139–140. <a href="https://www.atarimagazines.com/compute/issue57/insight_atari.html" target="_blank">https://www.atarimagazines.com/compute/issue57/insight_atari.html</a> <a href="#fnref:49" class="footnote-back-ref">↩</a></li>
<li id="fn:50">Wilkinson 1985, p. 139. - Wilkinson, Bill (February 1985). "INSIGHT: Atari". Creative Computing. pp. 139–140. <a href="https://www.atarimagazines.com/compute/issue57/insight_atari.html" target="_blank">https://www.atarimagazines.com/compute/issue57/insight_atari.html</a> <a href="#fnref:50" class="footnote-back-ref">↩</a></li>
<li id="fn:51">Wilkinson, O'Brien & Laughton 1983, p. 17. - Wilkinson, Bill; O'Brien, Kathleen; Laughton, Paul (1983). The Atari BASIC Source Book. Compute! Books. ISBN 0-942386-15-9. <a href="https://archive.org/details/ataribooks-the-atari-basic-source-book" target="_blank">https://archive.org/details/ataribooks-the-atari-basic-source-book</a> <a href="#fnref:51" class="footnote-back-ref">↩</a></li>
<li id="fn:52">Crawford 1982, p. 8.45. - Crawford, Chris (1982). De Re Atari. Atari Program Exchange. <a href="https://archive.org/details/ataribooks-de-re-atari" target="_blank">https://archive.org/details/ataribooks-de-re-atari</a> <a href="#fnref:52" class="footnote-back-ref">↩</a></li>
<li id="fn:53">Winner, Lane (1982). "De Re Atari, Chapter 10: Atari BASIC". Atari, Inc. <a href="http://www.atariarchives.org/dere/chapt10.php" target="_blank">http://www.atariarchives.org/dere/chapt10.php</a> <a href="#fnref:53" class="footnote-back-ref">↩</a></li>
<li id="fn:54">Wilkinson 1985, p. 139. - Wilkinson, Bill (February 1985). "INSIGHT: Atari". Creative Computing. pp. 139–140. <a href="https://www.atarimagazines.com/compute/issue57/insight_atari.html" target="_blank">https://www.atarimagazines.com/compute/issue57/insight_atari.html</a> <a href="#fnref:54" class="footnote-back-ref">↩</a></li>
<li id="fn:55">Wilkinson, Bill (September 1982). "Insight: Atari". Compute!. p. 116. <a href="https://archive.org/details/BillWilkinsonArticles/page/n83/mode/2up" target="_blank">https://archive.org/details/BillWilkinsonArticles/page/n83/mode/2up</a> <a href="#fnref:55" class="footnote-back-ref">↩</a></li>
<li id="fn:56">Williams, Gregg; Moore, Rob (December 1984). "The Apple Story / Part 1: Early History". Byte. p. A71. <a href="https://archive.org/stream/byte-magazine-1984-12/1984_12_BYTE_09-13_Communications#page/n461" target="_blank">https://archive.org/stream/byte-magazine-1984-12/1984_12_BYTE_09-13_Communications#page/n461</a> <a href="#fnref:56" class="footnote-back-ref">↩</a></li>
<li id="fn:57">Wilkinson 1985, p. 139. - Wilkinson, Bill (February 1985). "INSIGHT: Atari". Creative Computing. pp. 139–140. <a href="https://www.atarimagazines.com/compute/issue57/insight_atari.html" target="_blank">https://www.atarimagazines.com/compute/issue57/insight_atari.html</a> <a href="#fnref:57" class="footnote-back-ref">↩</a></li>
<li id="fn:58">"Ahl's Benchmark?". 28 November 2007. <a href="http://atariage.com/forums/topic/116886-ahls-benchmark/" target="_blank">http://atariage.com/forums/topic/116886-ahls-benchmark/</a> <a href="#fnref:58" class="footnote-back-ref">↩</a></li>
<li id="fn:59">Victor, John (1981). "Atari BASIC Part II". Compute!'s First Book of Atari. COMPUTE! Books. p. 19. <a href="https://www.atariarchives.org/c1ba/page019.php" target="_blank">https://www.atariarchives.org/c1ba/page019.php</a> <a href="#fnref:59" class="footnote-back-ref">↩</a></li>
</ol>

Atari BASIC open-in-new

Atari BASIC