Basics of the BASIC Language and Interpreters in Vintage Computers

BASIC (Beginner's All-purpose Symbolic Instruction Code) is a high-level programming language designed for ease of use, particularly for beginners. Developed in 1964 by John Kemeny and Thomas Kurtz at Dartmouth College, it became the lingua franca of early personal computing. From a hobbyist's perspective, BASIC allowed immediate interactive programming on microcomputers, with commands like PRINT, GOTO, and FOR loops making it accessible without deep hardware knowledge.

What is an Interpreter?

An interpreter is a program that executes code line-by-line, translating high-level instructions into machine code on the fly. Unlike compilers (which produce standalone executables ahead of time), interpreters allow immediate execution and debugging—type a line, run it, see results. In BASIC, the interpreter handles parsing commands, managing variables, and executing loops/subroutines. It resides in memory (often ROM for instant boot) and provides a REPL (Read-Eval-Print Loop) environment: e.g., type "PRINT 2+2" and get "4" instantly.

Example BASIC Program

Here is a simple BASIC program that counts from 1 to 100 and then prints "Hello Readers". This style would run on most vintage ROM'd BASIC interpreters (e.g., Commodore, Apple II, TRS-80):

10 FOR I = 1 TO 100
20 NEXT I
30 PRINT "Hello Readers"

Explanation:

• Line 10 starts a FOR loop, setting variable I from 1 to 100.
• Line 20 ends the loop (NEXT increments I and loops back until done).
• Line 30 prints the message once the loop finishes.

Type these lines directly at the READY prompt, then type RUN to execute. The loop acts as a simple delay before printing.

Vintage Computers with ROM'd BASIC Interpreters

Many vintage computers from the 1970s and 1980s included BASIC interpreters "ROM'd"—burned into read-only memory chips for instant availability upon power-on. This "turnkey" feature made them user-friendly, booting directly to a READY prompt. According to historical lists and sources, dozens of models had this, with estimates of over 50 popular ones across brands. Common examples include:

• Apple II (1977): Applesoft BASIC in ROM (licensed from Microsoft).
• Commodore PET (1977), VIC-20 (1981), C64 (1982): Commodore BASIC in ROM.
• TRS-80 Model I (1977): Level II BASIC in ROM (earlier Level I loaded from cassette).
• Sinclair ZX80/81 (1980/1981), ZX Spectrum (1982): Sinclair BASIC in ROM.
• Atari 400/800 (1979): Atari BASIC in ROM or cartridge.
• BBC Micro (1981): BBC BASIC in ROM.
• Texas Instruments TI-99/4A (1981): TI BASIC in ROM.
• Others: Acorn Atom, Oric-1, Dragon 32, MSX computers, and many more.

Not all were Microsoft-derived—e.g., BBC BASIC was custom—but Microsoft's versions dominated due to licensing.

Variations in BASIC Implementations

BASIC came in many forms, tailored to hardware constraints:

• Tokenized Keyboards: Machines like the ZX81 used a one-key entry system—press "P" for PRINT. Keywords were "tokenized" (stored as single-byte codes), reducing memory use in the 1 KB ZX81 (e.g., PRINT as token $F5 saved space vs. ASCII string).
• Loaded from Cassette or Paper Tape: Some systems required loading BASIC: Altair 8800 (1975) loaded Microsoft BASIC from paper tape or cassette; early Apple I (1976) used cassette for Woz's Integer BASIC.
• ROM'd Examples: TRS-80 Model I had Level II BASIC in ROM for instant use. The original IBM PC (1981) included Cassette BASIC in ROM (accessible without disk, for tape-based systems).

These variations reflected trade-offs: ROM'd BASIC was convenient but fixed; loadable allowed updates but required storage.

Legacy

BASIC interpreters taught a generation to program, with vintage machines booting to BASIC prompts fostering experimentation. Tokenization and ROM integration optimized for limited RAM. Today, emulators recreate this, and dialects like FreeBASIC carry the legacy forward.

Back to Misc