In my study of Tiny BASICs, one I overlooked reviewing was Sinclair 4K BASIC, which stands out for its unique keyboard, its approach to graphics, and its memory usage.
A friend’s family bought their first computer, which was either a ZX80 (4K BASIC) or ZX81 (8K BASIC), but I can’t recall which it was. I do remember learning the keyboard’s unique layout when we got together to help type in BASIC programs, which was a team effort when I was a kid.
The language was developed by John Grant of Nine Tiles.
Tokenized Keywords
Unlike other Tiny BASICs except for Astro BASIC, the Sinclair ZX80 tokenized BASIC keywords at the keyboard. For instance, after typing a line number, the cursor would flash with an inverse K, indicating that the next key you hit would insert a corresponding keyword that could start a BASIC line: for instance, typing V then didn’t produce a V but instead inserted the keyword GOSUB, typing Y inserted REM, and so on. (Sadly, these aren’t mnemonic: O is for PRINT, while P is unused; K is for LET and A is for LIST, while L is unused.) This keyword mode made efficient use of the 1K RAM the unit shipped with and also simplified and sped up parsing. It did, unusually, mean that LET was mandatory (e.g., LET X=X+1 not X=X+1).
In fact, the tokenization even extended to character coding. Perhaps unique among TINY BASICs, the ZX80 didn’t use ASCII but its own character set and codes above 213 contained entire keywords (saving screen RAM at the expense of variable-sized glyphs). The character set lacked such common punctuation marks as !@#%^&’.
Eight functions—which never start BASIC statements—were typed conventionally, a letter at a time, rather than input as tokens, and these were displayed on the sticker: CHR$, STR$, PEEK, USR, ABS, RND, CODE, and TL$.
Those last two functions were unique. A common idiom showcases the use of CODE() and TL$(). It’s a way to peel off one character at a time to parse strings. CODE(A$) gets the first character code, then TL$(A$) gets the rest of the string, being the same as MID$(A$, 2, 255) in other BASICs. For instance, this excerpt from the MASTERMIND program from 30 Programs for the Sinclair ZX-80, parses the input B$ a character at a time to count the number of digits that are the right digits (R) and the number that are in the correct position (C):
370 FOR I = 0 TO N
380 LET X = CODE (B$) - 28
390 IF X = A(I) THEN LET C = C + 1
400 FOR J = 0 TO N
410 IF X = A(J) THEN LET R = R + 1
420 NEXT J
430 LET B$ = TL$ (B$)
440 NEXT INote there was no LEN function to determine the length of a string nor any other way to access the characters within a string.
Lines were syntax checked while being entered; you couldn’t save an erroneous line to a program. You could only have one statement per line.
Graphics
The graphics were very simple—
Those symbols that were available at the keyboard could be entered directly into strings and manipulated that way:
For the LUNAR LANDER program, on the other hand, a bootstrap program required you to enter a string of numbers, both to access the graphics unavailable from the keyboard and because 4K BASIC lacked the DATA and READ statements.
Game Issues
Despite the graphics, the language lacked an INKEY$ function, so there was no way to get a single keypress, limiting the types of games that could be created. (Presumably there was a way to work around this with PEEK, POKE and USR, but I couldn’t find it.)
The 1K of RAM was another limitation; it meant most of the games from BASIC Computer Games couldn’t be run on the ZX80.
RAM
A note about RAM usage: “The computer’s RAM stored the screen display. As a result, the available screen size would decrease as the size of a program increased (and vice versa). With 1 KB RAM, a 990 byte program would result in only one row of characters being visible on the screen. At the other end, a full screen (32×24) would leave only 384 bytes to the programmer.” (TimexSinclair.com.)
For a Tiny BASIC especially, the ZX80 BASIC interpreter had a sophisticated method for handling variables. For contrast, Level I BASIC for the TRS-80 had numeric variables A-Z (though floating point), two strings A$ and B$ (limited to 16 characters each), and one array A(). That static arrangement removed the need for a symbol table, but allocated RAM for all the variables, whether they were used or not. The ZX80 had a symbol table supporting names of any length (constrained only by RAM!) for integer variables, 26 string variables A$ to Z$, and arrays of numbers or strings (single-letter names). (Apple I BASIC also supported long file names, so it wasn’t unprecedented.)
You can play with 4K BASIC in your browser using this ROM-based ZX80 emulator. It’s definitely one of my favorite Tiny BASICs from an implementation standpoint.
Image credits: Cover illustration from Wikimedia. Keyboard layout and memory map from A Course in BASIC Programming: ZX80 Operating Manual. Program listings from 30 Programs for the Sinclair ZX-80.