FORTH: The Concise, Stack-Based Language

FORTH is one of the most unique and influential programming languages ever created. Designed in the late 1960s–early 1970s by Charles H. "Chuck" Moore, it is a minimalist, stack-based, concatenative language that prioritizes simplicity, speed, and interactivity. In the MicroBasement, FORTH represents the beauty of extreme minimalism in computing—doing a lot with very little code and resources. This write-up covers FORTH's history, core concepts, how it works, key features, uses, significance, and legacy.

History and Development

Chuck Moore began developing FORTH in 1968 while working on radio astronomy projects at the National Radio Astronomy Observatory. He needed a fast, interactive way to control telescope equipment and process data. The name "FORTH" is a play on "fourth" (fourth-generation language), though Moore later said it was just "forth" as in "going forth." The first implementation ran on an IBM 1130 minicomputer in 1970. Moore refined it through the 1970s, releasing FORTH-79 (1979) and FORTH-83 (1983) standards. In 1983, the FORTH Interest Group (FIG) released a public-domain version, and commercial systems like polyFORTH and MVP FORTH appeared. FORTH became popular in embedded systems, real-time control, and hobbyist computing.

Core Concepts: Stack-Based and Concatenative

FORTH uses a **reverse Polish notation** (postfix) and operates on one or more stacks:

Data Stack: Holds numbers and values (like a calculator stack).
Return Stack: Manages subroutine calls.
Dictionary: Stores words (functions) as linked lists.

Everything is a "word"—a named piece of code or data. Words are concatenated (placed next to each other) and executed left-to-right. No parentheses needed for precedence—order is explicit.

How It Works: Simple Example

Here is a classic FORTH example that calculates the factorial of 5:

: FACTORIAL   ( n -- n! )
    DUP 0= IF
        DROP 1
    ELSE
        DUP 1- RECURSE *
    THEN ;

5 FACTORIAL .    \ Prints 120

Explanation line by line:

: FACTORIAL: Defines a new word named FACTORIAL.
( n -- n! ): Stack comment: takes n, returns n!.
DUP 0=: Duplicates n and checks if it's 0.
IF ... THEN: Conditional block.
DROP 1: If n=0, drop n and return 1 (0! = 1).
DUP 1- RECURSE *: Otherwise, duplicate n, subtract 1, recurse, multiply result.
5 FACTORIAL .: Puts 5 on stack, calls FACTORIAL, prints result (120).

FORTH code is extremely concise—no semicolons, no curly braces, just words separated by spaces. The interpreter reads left-to-right, executing each word immediately or compiling it if inside a definition.

Key Features

FORTH's standout features include:

Postfix notation (reverse Polish)
Two stacks (data and return)
Extensible: you define new words that become part of the language
Very small footprint (early systems ran in 4–8KB)
Interactive (REPL-like environment)
Direct hardware access (inline assembly)
No types (everything is just numbers on stack)

It feels like building your own language on the fly.

Uses and Significance

FORTH was widely used in:

Embedded systems (telescopes, robotics, industrial control)
Real-time applications (flight simulators, medical devices)
Boot loaders and firmware
Hobbyist and homebrew computers (1980s)
Astronomy (Chuck Moore's original use case)

It influenced languages like PostScript, Joy, Factor, and even parts of Lisp and Smalltalk. Its stack-based nature inspired virtual machines like Java and .NET.

Legacy

FORTH is a language of extremes: minimal syntax, maximum flexibility. It proves you can build powerful systems with very little code. Though never mainstream, its philosophy of "write your own language" inspires retro computing, embedded developers, and anyone who loves minimalism. In the MicroBasement, FORTH reminds us that sometimes the most powerful tools are the simplest ones. As Chuck Moore said: "Keep it simple. Keep it small."

Back to Misc