Diff — BASIC

{{infobox

| title = BASIC

| image = dartmouth-basic-1965.jpg

| caption = The Dartmouth BASIC compiler manual, February 1965 — public domain

| full_name = Beginner's All-purpose Symbolic Instruction Code

| designed_by = John G. Kemeny · Thomas E. Kurtz

| developer = Dartmouth College

| appeared = 1 May 1964, Dartmouth Time-Sharing System

| typing = Untyped, loosely typed variants

| influenced_by = [[FORTRAN]] · JOSS · [[ALGOL]]

| dialects = Dartmouth BASIC → Tiny BASIC → Microsoft/Altair BASIC → home-computer BASICs → GW-BASIC/QBASIC → Visual Basic → modern descendants incl. [[AdaLogic 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.

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:

```basic

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.

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.

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.

[[File:altair-byte-advert-1975.jpg|right|300px|A 1975 Byte advert for the machine that BASIC bootstrapped — the Altair 8800. Public domain]]

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** — 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 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 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.

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:

```basic

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

```

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

[[File:ten-print-maze.svg|center|480px|The maze that one line of Commodore BASIC draws forever — our own rendition]]

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.

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).

[[Category:Languages]]

[[Category:History]]

[[Category:Programming]]