BASIC

BASIC — the Beginner's All-purpose Symbolic Instruction Code — is the family of programming languages created at Dartmouth College in 1964 to put computing within reach of people who weren't engineers. It may be the most-taught language family in history: for roughly two decades, nearly every microcomputer shipped with a BASIC in ROM, and for millions of people the first line of code they ever wrote began with a line number. Almost everything on this wiki — FORTRAN, COBOL, the ENIAC machines, the home-computer revolution — either fed into BASIC's creation or was reshaped by its spread.

Dartmouth, 1964

BASIC was designed by mathematicians John G. Kemeny and Thomas E. Kurtz at Dartmouth College, who believed — radically, for the era — that every student deserved to use a computer, not just scientists. Their Dartmouth Time-Sharing System let dozens of students share one GE-225 through teletype terminals simultaneously, an astonishing feat in a batch-processing world.

The language was designed around that goal in a single sweep of pragmatism: commands spelled out in near-English (PRINT, IF, FOR, NEXT, GOTO), numbers for every variable type so beginners never fought declarations, optional LET for assignment, and — the signature — line numbers, which gave every statement an address for editing on a terminal with no screen, no cursor, and no editor. At 4 a.m. on 1 May 1964, two students' programs ran at once on the DTSS and the world got BASIC.

It looked like this:

10 LET X = 1
20 FOR I = 1 TO 7
30 LET X = X * 2
40 NEXT I
50 PRINT "2 TO THE 7 IS", X
60 END

Kemeny and Kurtz gave the language away and watched it spread further than any language had ever spread.

The timesharing era (1964–1975)

Dartmouth kept revising its own BASIC through successive editions, and the concept — a friendly language you could type into right now — proved irresistible to every timesharing vendor:

• GE BASIC — General Electric shipped Dartmouth's work commercially on the Mark I timesharing network; BASIC was arguably timesharing's killer app.
• HP Time-Shared BASIC (1968) — Hewlett-Packard's minicomputer BASIC, one of the first on machines smaller than a mainframe.
• BASIC-PLUS (1972) — DEC's BASIC for the PDP-11 RSTS-11 system, written in assembler; dominated school districts and businesses through the seventies.
• Data General and Wang BASICs on minis; Tymshare SUPER BASIC; and BASIC-E (1977) — Gordon Eubanks' compiler that became a pillar of the coming CP/M world.

These BASICs differed in details — string handling was a famous swamp (A$ and MID$ conventions fought it out between Dartmouth, HP, and DEC camps) — but the formula held: interactive, immediate, forgiving.

The microcomputer explosion (1975–1984)

When the Altair 8800 arrived in January 1975 with 4K of memory, a language had to fit in kilobytes. Two answers appeared at once:

• Tiny BASIC (1975) — Li-Chen Wang's Palo Alto Tiny BASIC fit in 2K and was published in Dr. Dobb's Journal marked "@COPYLEFT ALL WRONGS RESERVED" — the first recorded use of the word "copyleft." A lineage of tiny interpreters followed.
• Altair BASIC (1975) — Bill Gates and Paul Allen, with Monte Davidoff, wrote an Altair BASIC without an Altair — Harvard's PDP-10 emulated the 8080. It became Micro-Soft's founding product, and its rampant piracy provoked Gates' famous Open Letter to Hobbyists, the industry's first big fight over software copying.

Then BASIC became the home-computer language, burned into ROM in millions of machines:

• Integer BASIC (1976) — Steve Wozniak's own interpreter for the Apple I and early II, hand-assembled at nights.
• Applesoft BASIC (1977) — Microsoft's 6502 BASIC licensed to Apple; the language a generation of kids learned in school computer labs.
• Commodore BASIC — the same Microsoft 6502 core in the PET (1977), VIC-20, and the best-selling computer ever made, the Commodore 64: READY. 10 PRINT RUN.
• TRS-80 Level I/II BASIC — Level I was written in-house by Steve Leininger (a Tiny BASIC descendant); Level II was again Microsoft.
• Atari BASIC (1979) — Shepardson Microsystems' ROM for the Atari 400/800.
• TI BASIC / TI Extended BASIC — Texas Instruments' 99/4 family.
• Sinclair BASIC — the ZX80 ran a 4K interpreter; the ZX Spectrum added colour commands in 16K. Keyword-per-key entry: press P, get PRINT.
• BBC BASIC (1981) — Sophie Wilson's structured masterpiece for the Acorn/BBC Micro: procedures, local variables, REPEAT…UNTIL, and an inline 6502 assembler. Often called the best dialect ever shipped.
• MSX BASIC (1983) — Microsoft's standard across a dozen Japanese manufacturers.

The dialects diverged wildly — graphics, sound, PEEK/POKE addresses differed per machine — but 10 PRINT "HELLO": GOTO 10 ran on nearly all of them, and that shared thumbprint is why "BASIC" is remembered as one language.

The structured PC era (1983–1991)

The IBM PC made BASIC a serious tool and a default fixture:

• BASICA / GW-BASIC — IBM/Microsoft's PC BASIC; GW-BASIC source was even released decades later.
• Locomotive BASIC — the Amstrad CPC line's fine dialect.
• AmigaBASIC (Microsoft), GFA BASIC (Atari ST/Amiga), and the game-authoring STOS and AMOS — BASICs that helped define the 16-bit bedroom-coding scene.
• QuickBASIC (1985) — Microsoft's compiler: structure without line numbers, real procedures, and an IDE; QBASIC (1991) shipped free inside every copy of MS-DOS 5 and taught another generation (Gorillas.bas and Nibbles.bas went with it).
• Turbo BASIC / PowerBASIC — Borland's fast compiler, continued by Bob Zale for decades.
• True BASIC (1985) — Kemeny and Kurtz returned to write a modern, structured, ANSI-standard BASIC and update their own creation — the official ANSI/ECMA BASIC standard dates from this era.

Visual and modern BASICs (1991–present)

• Visual Basic (1991) — drag a button onto a form, double-click, write the code behind it. VB made Windows programming accessible to business programmers worldwide; VB6 became one of the most-used languages on Earth.
• VBA (1993) — Visual Basic for Applications, the automation tongue still humming inside Office documents everywhere.
• VBScript (1996) — the scripting sibling of the early web.
• VB.NET (2001– ) — BASIC on .NET: a fully objected, compiled, modern language still maintained by Microsoft.
• The free/hobbyist lineage never died: QB64 (a modernized QBasic that compiles natively today), FreeBASIC, PowerBASIC's descendants, PureBASIC, Gambas, SmallBASIC, Liberty BASIC — and remarkably, BBC BASIC is still developed (BBC BASIC for SDL runs on modern desktops and phones).
• BASIC even went back into hardware: the Parallax BASIC Stamp put BASIC into classroom microcontrollers in the '90s, and MMBasic runs today on $4 Pi Pico boards — a sixty-year-old language family still blinking LEDs for beginners.

The language itself — and the argument over it

Classic BASIC's fingerprint: line numbers, LET, FOR…NEXT loops, GOSUB/RETURN, DATA/READ, IF…THEN, immediate-mode commands (LIST, RUN, NEW), and a machine that answered now. The GOTO that made it easy also made the spaghetti — Dijkstra's verdict that BASIC exposure "mutilates the mind" captured the establishment's contempt, while the counterpoint wrote itself: the people mocked for learning BASIC in 1982 built the software industry anyway.

The famous one-liner remains the family's folk art:

10 PRINT CHR$(205.5+RND(1)); : GOTO 10

— Commodore BASIC for an endless maze, immortalized in the book 10 PRINT:

The living descendant

BASIC didn't end; it kept being re-invented wherever someone wanted power without the priesthood. AdaLogic BASIC carries the family forward: a modern, multi-paradigm descendant with BASIC's readable heart — friendly syntax, real structure, compiled output, and the same sixty-year-old bet Kemeny and Kurtz made in 1964: programming belongs to everyone. The line numbers are gone. The idea isn't.

References

1. Kemeny, John G., and Thomas E. Kurtz. Back to BASIC: The History, Corruption, and Future of the Language (Addison-Wesley, 1985).
2. Kurtz, Thomas E. "BASIC." In Wexelblat (ed.), History of Programming Languages (Academic Press, 1981).
3. Lien, David A. The BASIC Handbook: An Encyclopedia of the BASIC Computer Language (Compusoft, 1981).