| Designed by | Dennis Allison |
|---|---|
| First appeared | 1975 |
| Implementation language | IL (Interpretive Language) |
| License | Public domain |
| Dialects | |
| Denver Tiny BASIC, Enhanced 6800 Tiny BASIC, MINOL, National Industrial Basic Language, Palo Alto Tiny BASIC, 6800 Tiny BASIC, TBI68K, Tiny BASIC Extended | |
| Influenced by | |
| Dartmouth BASIC, 8008 BASIC | |
| Influenced | |
| Astro BASIC,Atari BASIC,Level I BASIC | |
Tiny BASIC is a family ofdialects of theBASIC programming language that can fit into 4 or fewerKBs ofmemory. Tiny BASIC was designed byDennis Allison and thePeople's Computer Company (PCC) in response to theopen letter published byBill Gates complaining about userspiratingAltair BASIC, which sold for $150. Tiny BASIC was intended to be a completely free version of BASIC that would run on the sameearly microcomputers.
Tiny BASIC was released as a specification, not an implementation, published in the September 1975 issue of the PCC newsletter. The article invited programmers to implement it on their machines and send the resultingassembler language implementation back for inclusion in a series of three planned newsletters.Li-Chen Wang, author of Palo Alto Tiny BASIC, coined the term "copyleft" to describe this concept. The community response was so overwhelming that the newsletter was relaunched asDr. Dobb's Journal, the first regular periodical to focus on microcomputer software.Dr. Dobb's lasted in print form for 34 years and then online until 2014, when its website became a static archive.
The small size and free source code made these implementations invaluable in the early days of microcomputers in the mid-1970s, whenRAM was expensive and typical memory size was only 4 to 8 KB. While the minimal version of Microsoft's Altair BASIC would also run in 4 KB machines, it left only 790 bytes free for BASIC programs. More free space was a significant advantage of Tiny BASIC. To meet these strict size limits, Tiny BASIC dialects generally lacked a variety of features commonly found in other dialects, for instance, most versions lackedstring variables, lackedfloating-point math, and allowed only single-letter variable names.
Tiny BASIC implementations are still used today, for programmingmicrocontrollers such as theArduino.
The earliestmicrocomputers, like theMITSAltair 8800, generally had no built-ininput/output (I/O) beyond front-panel switches andLED lamps. Useful work generally required the addition of an I/Oexpansion card and the use of some form ofterminal. At the time, video-based terminals were very expensive, costing much more than the computer, so many users turned to mechanical devices like theTeletype Model 33. The Model 33, like mostteleprinters of the era, included atape punch system intended to allow operators to pre-record their messages and then play them at "high speed", faster than most individuals could type the message live. For the early microcomputers, this provided a convenientcomputer data storage format, allowing the users to write programs to paper tape and distribute them to other users.[1]
TheHomebrew Computer Club met for the first time in March 1975, and its members soon used the meetings to swap software on punched tape. At the June meeting, a tape containing a pre-release version ofAltair BASIC disappeared. The tape was given to Steve Dompier, who passed it on to Dan Sokol, who had access to a high-speed tape punch. At the next meeting, 50 copies of Altair BASIC on paper tape appeared in a cardboard box.[2] WhenEd Roberts, founder of MITS, learned of this, he stated "Anyone who is using a stolen copy of MITS BASIC should identify himself for what he is, a thief."[3]Bill Gates made this more formal, writing "An Open Letter to Hobbyists", complaining that "As the majority of hobbyists must be aware, most of you steal your software."[4]
The complaint was not well received. Among the many responses, Bob Albrecht, another Homebrew member and founder of thePeople's Computer Company (PCC), felt the best response would be to produce their own BASIC that was completely free to use by anyone. He approachedDennis Allison, a member of the Computer Science faculty atStanford University, to write a specification for a version of BASIC that would fit in 2 to 3 kilobytes of memory.[a] To aidporting, the design was based on anintermediate language (IL), an interpreter for the interpreter, which meant only a small portion of the total code had to be ported.
Allison's initial design was published in the September 1975 edition of the PCC newsletter, along with anIntel 8080 version of the IL interpreter. The article called on programmers to implement the design on their computer and send the resultingassembly language version back to the PCC. They stated their plans to publish three special newsletters containing these user-submitted versions, along with bug fixes, programs written in the new BASIC, and suggestions and enhancements. The concept gained further notice when it was republished in the January 1976 edition of theACM Special Interest Group on Programming Languages.[5] Submissions poured in. Among the notable early versions was Tiny BASIC Extended by Dick Whipple and John Arnold which ran in 3K of RAM, addedFOR...NXT loops, and allowed a single numeric array. They avoided the use of the IL and wrote it directly in machine code, usingoctal.[6]
The first of the three planned newsletters, with the title "Dr. Dobb's Journal of Computer Calisthenics & Orthodontia, Running Light Without Overbyte", was published in January 1976.[6] It starts with a note from Albrecht, under the penname "the dragon", suggesting that three editions would not be enough, and asked the readers if they would like to see it continue. It also reprinted the original article on Tiny BASIC from PCC, included the complete listing of Extended TB, and included a number of small BASIC programs including tips-and-tricks from Allison.[7] Response to the first issue was so impressive that the introduction to the second issue stated they had already decided to continue publishing the new newsletter under the simplified nameDr. Dobb's Journal. Over the next several issues, additional versions of the language were published, and similar articles began appearing in other magazines likeInterface Age.
By the middle of 1976, Tiny BASIC interpreters were available for theIntel 8080, theMotorola 6800 andMOS Technology 6502 processors. This was a forerunner of the free software community's collaborative development before the internet allowed easy transfer of files, and was an example of a free software project before thefree software movement.[9] Computer hobbyists would exchange paper tapes, cassettes or even retype the files from the printed listings.[10]
Jim Warren, editor ofDr. Dobb's, wrote in the July 1976ACMProgramming Language newsletter about the motivations and methods of this successful project. He started with this: "There is a viable alternative to the problems raised by Bill Gates in his irateletter to computer hobbyists concerning 'ripping off' software. When software is free, or so inexpensive that it's easier to pay for it than to duplicate it, then it won't be 'stolen'." The Bill Gates letter was written to make software intoproducts. The alternative method was to have an experienced professional do the overall design and then outline an implementation strategy. Knowledgeable amateurs would implement the design for a variety of computer systems. Warren predicted this strategy would be continued and expanded.[10]
The May 1976 issue ofDr. Dobbs hasLi-Chen Wang's Palo Alto Tiny BASIC for the 8080. The listing begins with the title, author's name, and date but it also has "@COPYLEFT ALL WRONGS RESERVED".[11] A fellowHomebrew Computer Club member, Roger Rauskolb, modified and improved Wang's program and this was published in the December 1976 issue ofInterface Age magazine.[8] Roger added his name and preserved the COPYLEFT Notice.
Tiny BASIC was designed to use as little memory as possible, and this is reflected in the paucity of features as well as details of itsinterpreter system. Early microcomputers lacked the RAM andsecondary storage for a BASICcompiler, which was more typical of timesharing systems.
Like most BASICs of the era, Tiny Basic was interactive with the user typing statements into a command line. As microcomputers of the era were often used with teletype machines or "dumb" terminals, direct editing of existing text was not possible and the editor instead used takeout characters, often the backslash, to indicate where the user backed up to edit existing text.
If the user typed a statement into the command line the system examined it to see if it started with a number. If it did not, the line was immediately parsed and operated on, potentially generating output viaPRINT. This was known as "direct mode".
If the line was entered with a leading number, the number was converted from decimal format, like "50", and converted to a 8-bit value, in this case,$32hexadecimal. This number was used as an index into anarray-like storage area where the rest of the line was stored in exactly the format it was typed. When the user typedLIST into the command line the system would loop over the array, convert the line number back to decimal format, and then print out the rest of the text in the line.
When a program was present in memory and the user types in theRUN command, the system enters "indirect mode". In this mode, a pointer is set to point to the first line of the program, for instance, 10 ($0Ahex). The original text for that line is then retrieved from the store and run as if the user had just typed it in direct mode. The pointer then advances to the next line and the process continues.
The grammar is listed below inBackus–Naur form, almost exactly as it was specified in the Design Note.[12] In the listing, an asterisk ("*") denotes zero or more of the object to its left – except for the first asterisk in the definition of "term", which is the multiplication operator; parentheses group objects; and an epsilon ("ε") signifies the empty string. As is common in computer language grammar notation, the vertical bar ("|") distinguishes alternatives, as does their being listed on separate lines. The symbol "CR" denotes acarriage return (usually generated by a keyboard's "Enter" key). A BREAK from the console will interrupt execution of the program.
line::=numberstatementCR|statementCRstatement::=PRINTexpr-listIFexpressionrelopexpressionTHENstatementGOTOexpressionINPUTvar-listLETvar=expressionGOSUBexpressionRETURNCLEARLISTRUNENDexpr-list::=(string|expression)(,(string|expression))*var-list::=var(,var)*expression::=(+|-|ε)term((+|-)term)*term::=factor((*|/)factor)*factor::=var|number|(expression)var::=A|B|C...|Y|Znumber::=digitdigit*digit::=0|1|2|3|...|8|9relop::=<(>|=|ε)|>(<|=|ε)|=string::=" ( |!|#|$ ... -|.|/|digit|: ... @|A|B|C ... |X|Y|Z)* "
Note that string wasn't defined in the Design Note.
This syntax, as simple as it was, added one innovation:GOTO andGOSUB could take an expression rather than just a line number, providing anassigned GOTO[13] rather than theswitch statement of theGOTO/GOSUB ... OF ..., a structure then supported inHP Time-Shared BASIC and predatingON ... GOTO. The syntax allowingIF-THEN statement (as opposed to just a line number to branch to) was not yet supported in Dartmouth BASIC at this time but had been introduced by Digital[14] and copied by Microsoft.
The Design Note specified avirtual machine, in which the Tiny BASICinterpreter is itself run on a virtual machine interpreter. The designer's idea to use an application virtual machine goes back to Val Schorre (withMETA II, 1964) and Glennie (Syntax Machine). The choice of a virtual machine approach economized on memory space and implementation effort, although the BASIC programs run thereon were executed somewhat slowly.[15]
Dialects that used the virtual machine included Tiny BASIC Extended,Tom Pittman's Tiny BASIC[16] and NIBL. Other dialects such as Denver Tiny BASIC (DTB) and Palo Alto Tiny BASIC were direct interpreters. Some programmers, such as Fred Greeb with DTB, treated the IL (Interpretive Language) program aspseudocode for thealgorithm to implement in assembly language; Denver Tiny BASIC did not use a virtual machine, but it did closely follow the IL program.
This is a representative excerpt from the 120-line IL program:
S1:TSTS3,'GO';GOTO OR GOSUB?TSTS2,'TO';YES...TO, OR...SUBCALLEXPR;GET LABELDONE;ERROR IF CR NOT NEXTXFER;SET UP AND JUMPS3:TSTS8,'PRINT';PRINT.
A common pattern in the program is to test for a keyword or part of a keyword, then act on that information. Each test is an assertion as to what is next in the line buffer. If the assertion fails, control jumps to a subsequent label (usually looking for a new keyword or token). Here the system advances its buffer cursor over any spaces and tests forGO and if it fails to find it then jumps to lineS3. If it finds it, execution continues with the next IL command. In this case, the system next tests forTO, skipping to lineS2 if it fails (a test forSUB, to see if this is instead aGOSUB command). If it passes, control continues; in this case, calling an IL subroutine that starts at labelEXPR, which parses an expression. In Tiny BASIC,GOTO X*10+100 (a computed GO TO) is as legal asGOTO 100 and is the alternative to the ON-GOTO of larger BASIC implementations. The subroutineEXPR pushes the result of the expression onto the arithmetic stack (in this case, the line number).DONE verifies no other text follows the expression and gives an error if it does.XFER pops the number from the stack and transfers execution (GOes TO) the corresponding line number, if it exists.
The following table gives a partial list of the 32 commands of the virtual machine in which the first Tiny BASIC interpreter was written.[17]
Tom Pittman, discussing the IL, says: "The TINY BASIC interpreter was designed by Dennis Allison as arecursive descent parser. Some of the elegant simplicity of this design was lost in the addition of syntactical sugar to the language but the basic form remains. The IL is especially suited to Recursive Descent parsing of TINY BASIC because of the general recursive nature of its procedures and the simplicity of the TINY BASIC tokens. The IL language is effectively optimized for the interpretation of TINY. Experience has shown that the difficulty of adding new features to the language is all out of proportion with the nature of the features. Usually it is necessary to add additional machine language subroutines to support the new features. Often the difficulty outweighs the advantages."[19]
Defining Tiny BASIC for the Homebrew Computer Club, Pittman wrote, "Tiny BASIC is a proper subset of Dartmouth BASIC, consisting of the following statement types only: LET, PRINT, INPUT, IF, GOTO, GOSUB, RETURN, END, CLEAR, LIST, RUN. Arithmetic is in 16-bit integers only with the operators + - * / and nested parentheses. There are only the 26 single letter variable names A, B, ...Z, and no functions. There are no strings or arrays... Tiny BASIC specifies line numbers less than 256."[20] He then went on to describe his implementation: "This language has been augmented to include the functions RND, USR, and PEEK and POKE, giving the user access to all his system components in the 6800 from the BASIC program."
Many implementers brought their own experiences withHP Time-Shared BASIC orDEC BASIC-PLUS to their designs and relaxed the formal Tiny BASIC language specification. Of the seven prominent implementations published by 1977:
RND(). Though not included in the specification, a newsletter article prior to the Design Note for Tiny BASIC requested only this function.LET to be optional and most let expressions in assignment statements containrelational operators.: although TBX used$ and PATB used;.IF statements, all but MINOL removed the need for expressions to contain relational operators (e.g.,IFXTHENLETY=X was valid). Implementations removedTHEN altogether or made it optional or supported it only for impliedGOTO. None supportedELSE clauses.PRINT to support print zones, using, to go to the next zone and; to not advance the cursor.NEW.SZE, DTB and PATB hadSIZE, L1B hadMEM, and NIBL hadTOP.DIMensionable arrays in TBX and DTB.REMark statement.FOR loop: PATB, NIBL, and L1B offeredFOR-TO-STEP/NEXT, while TBX did not supportSTEP and used the keywordNXT to end a loop.DO/UNTIL, despite Allison's lament in Issue 2 about problems with BASIC.As an alternative to tokenization, to save RAM, TBX,[21] DTB,[22] and MINOL[23] truncated keywords:PR forPRINT,IN forINPUT,RET forRETURN. The full, traditional keywords were not accepted. In contrast, PATB allowed accepted traditional keywords but also allowed any keyword to be abbreviated to its minimal unique string, with a trailing period. For instance,PRINT could be typedP., althoughPR. and other variations also worked. This system was retained inLevel I BASIC for theTRS-80, which used PATB, and was also later found inAtari BASIC and the BASIC of variousSharp Pocket Computers.[24]
The most prominent dialects of Tiny BASIC were the original Design Note, Tiny BASIC Extended, Palo Alto Tiny BASIC, and 6800 Tiny BASIC. However, many other versions of Tiny BASIC existed.
Tiny BASIC was first published in a newsletter offshoot of thePeople's Computer Company, a newsletter which becameDr. Dobb's Journal, a long-lived computing magazine. About ten versions were published in the magazine.
| Date published | Issue | Dialect | Author | Processor | Size |
|---|---|---|---|---|---|
| December 1975 | 1[25] | Design Note | Dennis Allison | — | — |
| February 1976 | 2[21] | Tiny BASIC Extended (TBX) | Dick Whipple & John Arnold | 8080 | 2.9K |
| March 1976 | 3[22] | Denver Tiny BASIC (DTB) | Fred Greeb | 8080 | 2.75K |
| March 1976 | 3[26] | 6800 Tiny BASIC (6800TB) | Tom Pittman | 6800 | 2K[27] |
| April 1976 | 4[23] | MINOL | Eric T. Mueller | 8080 | 1.75K |
| May 1976 | 5[28] | Palo Alto Tiny BASIC (PATB) | Li-Chen Wang | 8080 | 1.77K |
| November 1976 | 10[29] | National Industrial Basic Language (NIBL) | Mark Alexander & Steve Leininger | SC/MP | 4K |
| October 1980 | 49[30] | Enhanced 6800 Tiny BASIC | Robert Hudson | 6800 | — |
| February 1985 | 100[31] | TBI68K | Gordon Brandly | 68000 | — |
| January 2006 | 351[32] | Return of Tiny BASIC | Tom Pittman | — (C) | — |
TBX was also known as Texas Tiny BASIC.[33]
BothSCELBAL[34] and 6800 Tiny BASIC were announced in the magazine but did not publish their source code.
| Developer | Li Chen Wang |
|---|---|
| First appeared | 1976 |
| License | Public domain |
| Dialects | |
| 3K Control Basic | |
| Influenced by | |
| Tiny BASIC Design Note, Tiny BASIC Extended | |
| Influenced | |
| Astro BASIC,Level I BASIC,Sharp PC-1211 BASIC | |
One of the most popular of the many versions of Tiny BASIC was Palo Alto Tiny BASIC, or PATB for short, byLi-Chen Wang. PATB first appeared in the May 1976 edition ofDr. Dobbs, written in a customassembly language with non-standard mnemonics. This led to further ports that worked with conventional assemblers on the 8080.[24] The first version of the interpreter occupied 1.77kilobytes of memory and assumed the use of aTeletype Machine (TTY) for userinput/output. An erratum to the original article appeared in the June/July issue ofDr. Dobb's (Vol. 1, No 6). This article also included information on adding additional I/O devices, using code for theVDM video display byProcessor Technology as an example.
Wang was one of the first to use the wordcopyleft.In Palo Alto Tiny BASIC's distribution notice, he had written "@COPYLEFT ALL WRONGS RESERVED".[35] Tiny BASIC was not distributed under any formal form of copyleft distribution terms, but was presented in a context where source code was being shared and modified. In fact, Wang had earlier contributed edits to Tiny BASIC Extended before writing his own interpreter.[21] He encouraged others to adapt his source code and publish their adaptions, as with Roger Rauskolb's version of PATB published inInterface Age.[8] He also published a third version inPCC's Reference Book of Personal and Home Computing.[36]
One of the most notable changes in PATB is the addition of theFOR...NEXT loop. In the original TB, loops could only be implemented usingIF andGOTO. As inMicrosoft BASIC, the upper and lower bounds of the loop were set on loop entry, and did not change during the loop, so if one of the bounds was based on a variable expression; changing the variable did not change the bound. TheSTEP modifier was optional, as in MS.[24]
Another significant change was the ability to place several statements on a single line. For reasons not explained, PATB used the semicolon; to separate statements, rather than the already common colon:.
Other changes include the addition of a single numeric array, with the variable name@,STOP in addition toEND, and the use of# for not-equals in comparisons, as opposed to<>.[24][b]
PATB used words for error messages instead of numbers. To reduce the amount of memory required, there were only three messages and they consisted of single words. The system would respond withWHAT? for syntax errors,HOW? for run-time errors like GOTOs to a line that didn't exist or numeric overflows, andSORRY for out-of-memory problems.[24]
Wang also wrote aSTARTREK program in his Tiny BASIC that appeared in the July 1976 issue of thePeople's Computer Company Newsletter.[37][38]
He later adapted the language into 3K Control Basic forCromemco, adding variable names of the form letter-digit (e.g.,A0 toZ9), logic functions (AND(),OR(),XOR()), aCALL command to execute machine language routines, morePRINT-formatting options, and others (GET() andPUT() instead ofPEEK andPOKE; I/O port functions).[39]
Palo Alto Tiny BASIC was adapted for many other implementations, includingLevel I BASIC (1977), BASIC for theSharp PC-1211pocket computer (1980), andAstro BASIC (1982, byJamie Fenton).[40]
Written by a junior in high school, MINOL was the only implementation that didn't support the full Design Note, lackingoperator precedence, having only three relational operators (<, =, #), omittingGOSUB andRETURN.It only supported unsigned 8-bit precision (in contrast to signed 16-bit precision for every other implementation) and line numbers from 0 to 254.
No spaces were permitted except in strings;! returns a random number,$ before an expression loads a string at that address;OS returns to operating system. Memory was addressable as if it were a two-dimensioned array of high and low bytes (e.g., "(0,0)" to "(255,255)");CALL executes a machine language subroutine.[23]
Many dialects appeared in various other publications.
Inspired by PCC's call for Tiny BASICs, Robert Uiterwyk wrote MICRO BASIC 1.3 for theSWTPC 6800 system), which SWTPC published in the June 1976 issue of the SWTPC newsletter. Uiterwyk had handwritten the language on a legal tablet. He later expanded the language to 4K, adding support for floating point; this implementation was unique among BASIC interpreters by usingBinary Coded Decimal to 9 digits of precision, with a range up to 1099, and by being published for free as a"Floppy ROM" magazine insert. An 8K version added string variables andtrigonometry functions. Both the 4K and 8K versions were sold by SWTPC. In January, 1978, Uiterwyk sold the rights of the source code toMotorola.[41][42]
Thomas F. Waitman wrote a Tiny BASIC in 1976 for the Hewlett-Packard HP-2640 and HP-2645 terminals (which used the Intel 8008 and 8080 processors), which was published in theHewlett-Packard Journal.
Published in the December 1976 issue ofInterface Age was LLL (Lawrence Livermore Laboratory) BASIC, the first draft of which was developed by Steve Leininger from Allison's specification before Leininger leftNational Semiconductor forTandy Corporation. The final interpreter was developed by John Dickenson, Jerry Barber, and John Teeter at theUniversity of Idaho on a contract with LLL. Taking 5K, it included a floating-point package, developed by David Mead, Hal Brand, and Frank Olken. The program was placed into the public domain by LLL, which developed the system under the auspices of theU.S. Energy Research and Development Administration.[43]
Altair BASIC, 4K BASIC, could run within a 4 KB RAM machine, leaving only about 790 bytes free for program code.[44][45] The Tiny BASIC initiative started in response to the $150 charge for Altair 4K BASIC.
In 1975, Steve Wozniak joined the newly formedHomebrew Computer Club, which had fellow membersLi-Chen Wang (Palo Alto Tiny BASIC) andTom Pittman (6800 Tiny BASIC). Wozniak concluded that hismachine would have to have a BASIC of its own, which would, hopefully, be the first for theMOS Technology 6502 processor. As the language needed 4 KB RAM, he made that the minimum memory for the design.[46]Integer BASIC was originally published onCompact Cassette in 1976.
In 1977,Radio Shack (as it was known then) released their first computer, theTRS-80, aZ80 system withLevel I BASIC in a 4 KB ROM.Tandy-employee Steve Leininger had written the first draft of the NIBL (National Industrial Basic Language) interpreter for theSC/MP while employed atNational Semiconductor.[29] Unable to take that source code with him, he adaptedLi-Chen Wang's Palo Alto Tiny BASIC for the original prototype of the TRS-80 Model I. He extensively revised the interpreter, adding floating-point support, simple black-and-white graphics, andREAD/DATA/RESTORE statements.[47]
Originally developed in 1979,Sinclair 4K BASIC, written by John Grant, used as its language definition the 1978American National Standards Institute (ANSI) Minimal BASIC standard, but was itself an incomplete 4 KB implementation with integer arithmetic only.[48]
Tiny BASIC implementations have been adapted for processor control and formicrocontrollers such as theArduino:
In 2002, Emmanuel Chailloux, Pascal Manoury and Bruno Pagano published a Tiny BASIC (lackingGOSUB/RETURN) inDeveloping Applications with Objective Caml as an exampleObjective Caml application.[53]
In 2013, Alex Yang published an implementation inPython.[54]
In 2019, Sergey Kuznetsov published a version inRuby.[55]
Also in 2019, Oscar Toledo Gutierrez published bootBASIC, which fits in the 512 bytes of the boot sector of an 8086/8088 machine, making it the smallest BASIC implementation yet. To accomplish this, the language drops relational operators (IF statements work on nonzero values), limits lines of code to 19 characters or less, and doesn't update the display when backspace is pressed.[56] Additionally, it lacks GOSUB and RETURN but does include a RND function (without arguments, returning a value between 0 and 255).[57] The language uses an array to store program lines, requiring 20,000 bytes to do so.[58]
In 2023,Gordon Henderson published a Tiny Basic implementation in 6502 assembler. It is influenced by NIBL and can run in as little as 3.5KB of ROM requiring at least 1KB of RAM for data and program storage. It supports DO/UNTIL, FOR/NEXT, simple strings and memory peek/poke (byte or 16-bit word), GOSUB/RETURN, CALL, RND with facilities for hexadecimal input and output.[59]
The following table compares the language feature of Tiny BASIC implementations against other prominent BASICs that preceded them.
Date Published | Dialect | Programmer(s) | Processor | Type | INPUT | LET | GOTO | IF ...THEN | GOSUB | RETURN | END | RUN | LIST | CLEAR | NEW | REM | FOR/NEXT | READ / DATA / RESTORE | Added BASIC commands | Customizations | Expressions | relop | Functions | RND | Memory Function | Line numbers | Statement delimiter | Errors | Precision | Arithmetic | Variables | Arrays | Strings | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
October 1964 | DTSS Dartmouth BASIC (version 2)[60] | (Dartmouth students) | GE-225 | Compile-and-go | N/A [!] | LET var = expression | PRINT expr-list { , / ; / } | GO TO number | IF expression relop expression THEN line-number | GOSUB number | RETURN | END | RUN | LIST--start | — | NEW [prompts for program name] | REM | FOR / TO / STEP / NEXT | READ, DATA | STOP | — | precedence, ^ | < <= = >= > <> | INT, SIN, COS, TAN, ATN, EXP, LOG, ABS, SQR, DEF FN | RND(0) 0..1 | — | 1 to 99999 | None | 22 defined | 9 digits | ±999,999,999; E notation base 2 -256 to +255 (E±76). | A–Z, A0–Z9 | DIM (one letter name, two dimensions); if omitted, assumed to go from 0 to 10; up to 1500 elements across all arrays | None (added in version 4) |
February 1970 | DEC BASIC-8[61] | (DEC staff) | PDP-8 | Compile-and-go | INPUT var-list | LET var = expression | PRINT expr-list { , / ; / } | GO TO number | IF expression relop expression [THEN/GO TO] line-number | GOSUB number | RETURN | END | RUN | LIST (first (, last)) | — | NEW [prompts for program name] | REM | FOR / TO / STEP / NEXT | READ, DATA, RESTORE | STOP, OLD, SAVE, UNSAVE | DELETE (first (, last)), BYE | precedence, ^ | < <= = >= > <> | INT, SGN, SIN, COS, TAN, ATN, EXP, LOG, ABS, SQR, DEF FN | RND(0) 0..1 | — | 1 to 2045 | None | 23 defined | ? | ±134,217,727; 14E-38<N<1.7E38 | A–Z, AA–Z9 | DIM (one letter name, two dimensions) | None |
June 1974 | UIUC BASIC[62] | Alfred Weaver, Michael Tindall, Ronald Danielson | 8008 | Interpreter | INPUT <variable> {, <variable>}* | LET var = formula | PRINT <string> / <formula> {, <string> / <formula>}* | GO TO number | IF expression THEN line-number | GOSUB number | RETURN | END | RUN | not documented | not documented | not documented | REM | FOR / TO / STEP / NEXT | — | DEF FN, STOP | — | precedence, ^ | < <= = >= > # AND OR NOT | FNA..Z, SIN, COS, LOG, SQR, EXP, ATN | — | — | 0 to 999 | None | not documented | 4-byte mantissa and 1-byte exponent [Datapoint 2200 floating-point arithmetic package] | not documented | A–Z, A0–Z9 | DIM (one letter name, three dimensions) | None |
| 1975 | Altair 4K BASIC[63] | Bill Gates, Paul Allen, Monte Davidoff | 8080 | Interpreter | INPUT ("string",) var-list | (LET) var = expression | PRINT expr-list { , / ; } | GOTO number | IF expression THEN line-number/statement | GOSUB number | RETURN | END | RUN | LIST (start) | — | NEW | REM | FOR / TO / STEP / NEXT | READ, DATA, RESTORE | STOP | — | precedence | < <= = >= > <> | ABS, INT, SGN, SQR, TAB, USR | RND(X) <0, new using X as seed; =0, repeat; >0, next | — | 1 to 65535 | : | 12 defined | 40-bit operand floating | ? | ? | DIM (one dimension) | None |
December 1975 | Design Note[64] | Dennis Allison | — | Interpreter | INPUT var-list | LET var = expression | PRINT expr-list | GOTO expression | IF expression relop expression THEN statement | GOSUB expression | RETURN | END | RUN | LIST | [eq. to NEW] | — | — | — | — | — | — | precedence | < <= = >= > <> >< | None | None | — | 1 to 255 | None | 8 defined | 16-bit | ± 32767 | A–Z | None | None |
February 1976 | Tiny BASIC Extended[65] | Dick Whipple & John Arnold | 8080 | Interpreter | IN | (LET) var = expression | ;} | GO TO | IF expression [no THEN] statement | GO SUB | RET | END | RUN | LST (first (, last)) | — | NEW | — | FOR-NXT (no STEP) | DTA (array LET) | — | — | precedence | < <= = >= > <> >< | TB() spaces in print | RN (random 0-10000) | SZE | 1 to 65535 | $ | 14 defined | 16-bit | ± 32767 | A–Z | DIM, 1- or 2-dimensions, 255x255 max | None |
March 1976 | Denver Tiny BASIC[66] | Fred Greeb | 8080 | Interpreter | IN | (LET) var = expression | ;} | GOTO | IF expression [no THEN] statement | GOSUB | RET | END | RUN | LIST (first last) | [eq. to NEW] | — | — | — | — | TAPE [SAVE], LOAD | CLRS [CLS] | precedence | < <= = >= > <> >< | RND(0), RND(1) | SIZE | 2 to 255 | : | 20 defined | 16-bit | ± 32767 | A–Z, A1 to A6 to Z6 | DIM, 1 dimension | None | |
March 1976 | 6800 Tiny BASIC[66] | Tom Pittman | 6800 | Interpreter | INPUT (expression) var-list | LET var = expression | PRINT expr-list { , / ; } | GOTO expression | IF expression relop expression THEN statement | GOSUB expression | RETURN | END | RUN | LIST (first last) | [eq. to NEW] | — | REM | — | — | — | — | precedence | < <= = >= > <> >< | USR() | RND() | — | 1 to 65535 | None | 53 defined | 16-bit | ± 32767 | A–Z | None | None |
April 1976 | MINOL[67] | Eric T. Mueller | 8080 | Interpreter | IN | (LET)var=expression | PRexpr-list{;} | [GOTO0 jumps back to start of direct statement] | IFexpressionrelopexpression ;statement | — | — | END | RUN | LIST | CLEAR [only variables] | NEW | — | — | — | — | No spaces permitted except in strings | No operator precedence | < = # | $[CHR$] | ![RND] | — | 1 to 254 | : | 6 defined | 8-bit | 0 to 255 | A–Z | (H,L) memory location | single char |
May 1976 | Palo Alto Tiny BASIC[68] | Li-Chen Wang | 8080 | Interpreter | INPUT [(expression) var]* | (LET) var = expression | PRINT expr-list | GOTO expression | IF expression [no THEN] statement | GOSUB expression | RETURN | STOP | RUN | LIST (start) | — | NEW | REM | FOR / TO / STEP / NEXT | — | STOP | — | precedence | < <= = >= > # | ABS() | RND() | SIZE | 1 to 32767 | ; | 3 defined | 16-bit | ± 32767 | A–Z | @(1 array of 1 dimension) | None |
November 1976 | NIBL[69] | Mark Alexander & Steve Leininger | SC/MP | Interpreter | INPUT ($)var | (LET) var = expression | PR/PRINT expr-list | GOTO expression | IF expression (THEN) statement | GOSUB expression | RETURN | END | RUN | LIST (start) | CLEAR [variables & stack] | NEW | REM | FOR / TO / STEP / NEXT | — | DO/UNTIL | Memory addressing (@ [PEEK/POKE], STAT, PAGE) | precedence | < <= = >= > <> | MOD(), AND, OR, NOT, | RND(A,Z) | TOP | 0 to 32767 | : | 13 four-char defined | 16-bit | ± 32767 | A–Z | memory addressing | INPUT$,PRINT$,$exp=exp |
August 1977 | Level I BASIC[70] | Steve Leininger | Z80 | Interpreter | INPUT (#digit) [(expression) var]* | (LET) var = expression | PRINT (#digit) expr-list | GOTO number | IF expression THEN statement | GOSUB number | RETURN | END | RUN (start) | LIST (start) | — | NEW | REM | FOR / TO / STEP / NEXT | READ, DATA, RESTORE | STOP, CONT, ON-GOTO/GOSUB | CLOAD, CSAVE, CLS, SET, RESET | precedence | < <= = >= > <> >< | ABS(), INT(), MEM, POINT(X,Y) | RND() | MEM | 1 to 32767 | : | 3 defined | 16-bit | ± 32767 | A–Z | A(1 array of 1 dimension) | A$,B$ |
June 1976 | MICRO BASIC 1.3[71] | Robert Uiterwyk | 6800 | Interpreter | INPUT var-list | (LET) var = expression | PRINT expr-list { , / ; } | GOTO expression | IF expression relop expression THEN statement | GOSUB expression | RETURN | END | RUN | LIST (first (, last)) | — | NEW | — | FOR/TO/NEXT (no STEP) | — | TAB() | — | precedence | < <= = >= > <> >< | RND, SIZE | RND [returns 1-32762] | SIZE (statement that prints bytes used and bytes free) | 1 to 65535 | None | 17 defined | 16-bit [later BCD!] | ± 32767 | A–Z | DIM (two dimensions, max size of 255) | None |
June 1976 | Mark Arnold & Nat Wadsworth | 8008 | Interpreter | INPUT var-list | (LET) var = expression | PRINT expr-list {, / ; / } | GOTO number | THEN statement | GOSUB number | RETURN | END | RUN | LIST | — | SCR[atch] | REM | FOR / TO / STEP / NEXT | — | SAVE, LOAD | UDF [USR] | precedence, ^ | < <= = >= > <> | INT, SGN, ABS, SQR, CHR [usable only in PRINT], TAB | RND(0) 0..1 | — | 1 to 999999 | None | 18 defined | 32-bit operand floating or fixed point | ±134,217,727; 14E-38<N<1.7E38 | ? | DIM (one letter name, one dimension; up to 4 arrays of up to 64 entries in total) | None | |
October 1976 | Apple I BASIC[73] | Steve Wozniak | 6502 | Interpreter | INPUT ("string",) var-list | (LET) var = expression | PRINT expr-list { , / ; } | GOTO expression | IF expression relop expression THEN line-number/statement | GOSUB expression | RETURN | END | RUN (start) | LIST (first (, last)) | — | SCR | REM | FOR / TO / STEP / NEXT | — | AUTO, DEL, POKE | TAB (command), CALL | precedence | < <= = >= > <> # AND OR NOT MOD | SGN, ABS, PEEK(), LEN() | RND(X) 0..X (or X..0!) | HIMEM, LOMEM | 1 to 32767 | None [early version, then :] | 16 defined | 16-bit | ± 32767 | A–Z followed by any number of alphanumeric | DIM (one dimension) | dimensioned |
December 1976 | LLL BASIC[74] | (University of Idaho staff) | 8080 | Interpreter | INPUT var-list | (LET) var = expression | PRINT expr-list { , / ;} | GO TO number | IF expression relop expression (THEN) statement | GO SUB number | RETURN | END | RUN | LIST | — | SCR | REM | FOR/TO/NEXT (no STEP) | — | STOP | CALL, GET(), PUT() | precedence | < <= = >= > <> >< | No RND? | — | 0 to 32767 | : | 14 defined | 32-bit operand floating point | ? | A–Z, A0–Z9 | DIM (integers only, one letter name, one dimension, max size of 255) | None | |
January 1980 | Sinclair 4K BASIC[75] | John Grant | Z-80 | Interpreter | INPUT var | LET var = expression | PRINT expr-list { , / ;} | GO TO number | IF expression THEN statement | GO SUB number | RETURN | — | RUN (number) | LIST | CLEAR | NEW | REM | FOR/TO/NEXT (no STEP) | — | STOP | POKE | precedence | < = > | ABS, CHR$, CODE, PEEK, RND, STR$, TL$, USR | RND, RANDOMISE | — | 1 to 9999 | — | 10 defined | 16-bit integer | 16-bit integer | A–Z followed by any number of alphanumeric | DIM A-Z (integers only, one letter name, one dimension, max size of 255) | A$-Z$ |
;*********************************;; TINY BASIC FOR INTEL 8080; VERSION 2.0; BY LI-CHEN WANG; MODIFIED AND TRANSLATED; TO INTEL MNEMONICS; BY ROGER RAUSKOLB; 10 OCTOBER,1976; @COPYLEFT; ALL WRONGS RESERVED;;*********************************
The open software movement was founded by Dennis Allison in his release of Tiny BASIC in 1975
TINY BASIC FOR INTEL 8080VERSION 1.0BY LI-CHEN WANG10 JUNE, 1976@COPYLEFTALL WRONGS RESERVEDThe June date in the May issue is correct. The magazine was behind schedule, the June and July issues were combined to catch up.
CRLF there symbolizes a carriage return followed by aline feed.{{cite book}}:|first1= has generic name (help){{cite web}}:Missing or empty|title= (help)