Skip to content
ALB Wiki

Diff — MUMPS

Comparing rev 1 → rev 2

{{infobox
| title = MUMPS
| full name = Massachusetts General Hospital Utility Multi-Programming System
| designers = Neil Pappalardo, Robert Greenes & Curt Marble / MGH, Boston
| first appeared = 1966–67 — a skunkworks escape from BBN's assembly development
| model = imperative language + integrated key-value database ("globals")
| status = ANSI standard "M" — still runs most of US healthcare
}}
# MUMPS
**MUMPS** — the Massachusetts General Hospital Utility Multi-Programming System — is the language most Americans' medical records run on and almost nobody's heard of. It began in 1966–67 as an internal **skunkworks** at MGH: Neil Pappalardo, Robert Greenes, and Curt Marble, working in Dr. Octo Barnett's lab, were frustrated watching their NIH hospital-systems project get built in assembly on a BBN time-shared [[PDP-1]] — so they built an alternative development environment of their own. When Dr. Barnett's 1967 NIH renewal proposed to build the hospital system *in MUMPS* instead, the gamble got funded.[[cite: [MUMPS](https://en.wikipedia.org/wiki/MUMPS) — the Pappalardo/Greenes/Marble skunkworks, the BBN frustration, and the 1967 NIH pivot]]
The design answers a specific pain — hospital data — with unusual economy. Its defining feature is the integrated database: **globals**, persistent sparse arrays that live on disk and are addressed with ordinary variable syntax (`^PATIENT(1234,"MEDS")`) — one of the first high-speed transactional key-value stores, a quarter-century before "NoSQL" had a name. Its syntax is legendarily terse: single-letter commands (`S X=5`, `W "HELLO"`), implicit everything, a language engineered for speed on tiny machines rather than readability. Ancestors reach back through BBN's TELCOMP and STRINGCOMP to RAND's [[JOSS]] — and it first ran on a **PDP-7**, moving to the PDP-9.[[cite: [MUMPS history and design](https://en.wikipedia.org/wiki/MUMPS) — the globals/persistent-array model, the terse syntax, the JOSS→TELCOMP lineage, and the PDP-7 origins]]
# Sixty years of invisible infrastructure
-
MUMPS was ahead of its era in a way that's easy to miss: it implemented **multitasking** on machines without threading or memory protection — and because MUMPS programs had *no way to reference raw memory*, process isolation was enforced by the language itself, not by hardware. It was standardized by ANSI as **X11.1** — officially just "M" — and its descendants are not legacy; they're the plumbing: **Epic's** system (the dominant US electronic health record, covering well over three-quarters of American patients) and the VA's **VistA** both run on M. If you've been treated in a US hospital, MUMPS handled your data.[[cite: [MUMPS](https://en.wikipedia.org/wiki/MUMPS) — the ANSI X11.1/M standard, the multitasking-by-language design, and Epic/VistA dominance]]
+
MUMPS was ahead of its era in a way that's easy to miss: it implemented **multitasking** on machines without threading or memory protection — and because MUMPS programs had *no way to reference raw memory*, process isolation was enforced by the language itself, not by hardware. It was standardized by ANSI as **X11.1** — officially just "M" — and its descendants are not legacy; they're the plumbing: **Epic's** system (the dominant US electronic health record, covering roughly three-quarters of American patients) and the VA's **VistA** both run on M. If you've been treated in a US hospital, MUMPS handled your data.[[cite: [MUMPS](https://en.wikipedia.org/wiki/MUMPS) — the ANSI X11.1/M standard, the multitasking-by-language design, and Epic/VistA dominance]]
```fact
MUMPS's real innovation is the *global* — a variable that's actually a database row, persistent, sparse, and hierarchical. Modern databases are still catching up to a 1966 design where `^LAB(42,"RESULT")` is both the query and the storage.
```
# Where it sits
MUMPS is the survival case of this catalogue: JOSS-era roots, PDP-7-era implementation, and a domain — medicine — where reliability outranks fashion. It proves a language can be ugly, sixty years old, and *load-bearing* — the health data of a nation is running on it right now.
## Check your understanding
- [ ] What does MUMPS stand for — and why was it built?
- [ ] What are "globals," and why are they historically important?
- [ ] How did MUMPS achieve multitasking on machines without threading?
- [ ] What modern systems still run on M?
```hide Show answers
1 — **Massachusetts General Hospital Utility Multi-Programming System** — built as a skunkworks alternative to assembly development for hospital records.
2 — **persistent sparse arrays on disk** — variable syntax that *is* the database; one of the first high-speed key-value stores.
3 — the language itself enforced isolation: **programs had no way to touch raw memory**, so no process could corrupt another.
4 — **Epic** (dominant US EHR) and the VA's **VistA** — the ANSI-standard descendant called **M**.
```
[[Category:Languages]]
[[Category:Programming]]
[[Category:History]]