Dennis Allison’s 1975 article in Dr. Dobb’s Journal was a key moment in the history of Computer Science. It contained a formal specification of Tiny BASIC, a BASIC that could be implemented in less than 4 KB.

Stellar BASIC is very much in the same vein as Tiny BASIC, and is intended to evolve over time.

• Line-numbered programs
• LET (often optional)
• PRINT
• INPUT
• IF-THEN
• GOTO
• GOSUB and RETURN
• FOR-NEXT
• Usually only access to integer variables and integer based math
• Single letter variables (ex. A, B, Z)

• No floating-point math
• Very limited strings
• No arrays
• No file I/O
• Minimal error messages
• Very limited editing commands

Some versions stored programs as text, some as tokenized program code to save space.

10 LET A = 1
20 PRINT A
30 A = A + 1
40 IF A <= 10 THEN GOTO 20
50 END

Stellar BASIC will allow this even shorter form:

10 A=1
20 ?A
30 A=A+1
40 IF A<=10 GOTO 20

(? is shorthand for PRINT.)

Notable Tiny BASIC implementations

• Palo Alto Tiny BASIC (Dennis Allison)
• Li-Chen Wang’s Tiny BASIC
• 6800 Tiny BASIC
• NASCOM Tiny BASIC
• Apple I BASIC (inspired by Tiny BASIC ideas)
• Micro-Soft 8080 BASIC (larger, but influenced by Tiny BASIC work)

Stellar Basic is based on Pao Alto Tiny Basic, written by Dennis Allison in 1975. I implemented it in this order:

• Phase 1: Variable management (3 functions: get, set, clear_all)
• Expression stack (4 functions: push, pop, peek, clear)
• I/O & String Helpers (ex. IO_GETNUM)
• String comparison, number parsing (ex. STR_SKIP_SPACE)

• Phase 2: Stack Operations
• GOSUB/RETURN stack (3 functions)
• FOR/NEXT stack (4 functions)

• Phase 3: Program Line Management
• Find line by number
• Insert/delete lines
• Navigate through program (first line, next line)
• Program storage with line markers (opcode 251)

• Phase 4: IL Interpreter Core;
• Design IL bytecode table (~30-40 IL opcodes)
• IL fetch/decode/execute loop
• Expression evaluation using the stack
• Control flow (GOTO, GOSUB, IF/THEN, FOR/NEXT)

• Phase 5: BASIC Commands (~15-20%)
• PRINT, INPUT, LET
• RUN, LIST, NEW, CLEAR
• Integrate with term.ts to highlight a “Boot-to-basic” experience.

• Phase 6: Testing & Polish (~5%)
• End-to-end BASIC program tests
• Error handling and status messages
• Bug fixes
• Performance tuning

Everything in PATB is stack-based. This is a core design principle. There are three stacks:

1. Expression Stack - Arithmetic evaluation
   • “5 + 3 * 2” is “push 5”, “push 3”, “push 2”, “multiply” (pop 2 values, push result), “add” (pop 2 values, push result).
2. GOSUB Stack - Subroutine calls
   • “GOSUB 1000” – push current line number, jump to 1000
   • “RETURN” – pop line number, jump back
3. FOR Stack - Loop context
   • “FOR I=1 TO 10” – push (I, 10, 1)
   • “NEXT I” – peek stack, increment I, check if done, pop if finished

During the implementation phase I made several by-the-way changes to PATB in order to support a more advanced integration with the SD-8516. I added LINE_FIND_REVERSE and LINE_PREV as well as LINE_MAKE_SPACE and LINE_REMOVE_SPACE for line management. I am not sure how PATB does those things. I worked from example code and the specs but I did not really understand what I was doing. After the tests for the IL implementation passed I added string helpers. Some of these are in PATB (about 4 or 5 of them IIRC) but I added enough to support proper string handling, as it is the first thing I plan to add. After the basic port, of course.

I'm really excited to start working on these because I feel I understand them and they will be easy. LINE_INSERT is not easy It is long and hard. I do not understand it… YET!

• ; AH=$70: STR_COMPARE - Compare strings for keyword matching
• ; AH=$71: STR_TO_UPPER - Convert string to uppercase
• ; AH=$72: STR_SKIP_SPACE - Skip whitespace in ELM string
• ; AH=$73: STR_IS_DIGIT - Check if character is digit
• ; AH=$74: STR_IS_ALPHA - Check if character is letter
• ; AH=$75: STR_LENGTH - Get string length
• ; AH=$76: STR_COPY - Copy string from src to dst
• ; AH=$77: STR_CONCAT - Concatenate two strings
• ; AH=$78: STR_LEFT - Extract left N characters (LEFT$)
• ; AH=$79: STR_RIGHT - Extract right N characters (RIGHT$)
• ; AH=$7A: STR_MID - Extract middle substring (MID$)
• ; AH=$7B: STR_CHR - Convert byte to character (CHR$)
• ; AH=$7C: STR_ASC - Convert character to byte (ASC)
• ; AH=$7D: STR_VAL - Convert string to number (VAL)
• ; AH=$7E: STR_STR - Convert number to string (STR$)
• ; AH=$7F: STR_FIND - Find substring within string (INSTR)
• ; AH=$80: STR_LTRIM - Trim leading whitespace
• ; AH=$81: STR_RTRIM - Trim trailing whitespace
• ; AH=$82: STR_TRIM - Trim both leading and trailing whitespace
• ; AH=$83: STR_REVERSE - Reverse a string
• ; AH=$84: STR_REPEAT - Repeat character N times (STRING$)
• ; AH=$85: STR_SPLIT - Split string at delimiter
• ; AH=$86: STR_REPLACE - Replace substring with another