MUMPS

MUMPS
Company type	Programming language
Industry	Software, Health information systems
Founded	January 1, 1966; 60 years ago
Founder	Dr. Octo Barnett, Neil Pappalardo, Robert A. Greenes, Curt Marble
Headquarters	Boston, United States
Products	MUMPS programming language and integrated database system

MUMPS (an acronym for "Massachusetts General Hospital Utility Multi-Programming System"), also known simply as M, is a high-level, imperative programming language that integrates a transactional key–value database system. Initially developed at Massachusetts General Hospital to handle patient medical records and laboratory management, MUMPS has evolved into the leading database technology underpinning health information systems and electronic health records across the United States. Notably, platforms such as Epic Systems rely on MUMPS-based architecture to serve over 78% of American patients.

One significant commercial benefit of MUMPS lies in its built-in database language, which allows direct, rapid read and write operations on persistent disk storage.

1960s-1970s – Origins

The creation of MUMPS took place between 1966 and 1967 at Massachusetts General Hospital (MGH) in Boston under the guidance of Dr. Octo Barnett, with key contributors Neil Pappalardo, Robert A. Greenes, and Curt Marble. Frustrated by the limitations of assembly language programming on a time-shared PDP-1 system provided by contractor Bolt, Beranek & Newman (BBN), the team initiated an internal "skunkworks" project aimed at developing a more effective programming environment. After demonstrating its potential, Dr. Barnett secured funding from the NIH in 1967 to implement a hospital system using MUMPS rather than BBN’s original method.

The first incarnation of MUMPS operated on a DEC PDP-7 and subsequently on a backward-compatible PDP-9, supporting functions such as patient admissions and laboratory test reporting. Although it was an interpreted language, MUMPS incorporated a hierarchical database file system that standardized data access and encapsulated disk operations within the language framework itself. Early deployments included systems for clinical progress notes and radiology report entry.

MUMPS design drew inspiration from RAND's JOSS and BBN's TELCOMP and STRINGCOMP languages, with portability across hardware platforms as a core objective. Unlike many contemporary mini-computers, MUMPS enforced multitasking at the language level, thereby mitigating risks linked to memory management issues that were otherwise unaddressed by hardware.

Dan Brevik adapted DEC’s MUMPS-15 for use on the PDP-15, with its initial installation taking place at Health Data Management Systems in Denver in 1971. The language’s portability attracted government research funding and facilitated its release into the public domain, enabling ports to various minicomputers including DEC PDP-8, Data General Nova, PDP-11, and Artronix PC12. Its adoption was primarily within healthcare settings where local customization was common.

Technical experts Dennis "Dan" Brevik and Paul Stylos undertook rewrites of DEC versions during 1970–71. By the early 1970s, several implementations were available across different platforms such as Paul Stylos' DEC MUMPS-11 for the PDP-11 and MEDITECH's MIIS. A 1972 conference held in Boston addressed the fragmented state of the language, resulting in the establishment of the MUMPS Users Group and the MUMPS Development Committee (MDC). This effort culminated in the approval of the ANSI X11.1-1977 standard on September 15, 1977.

At the same time as standardization efforts progressed, DEC introduced DSM-11 (Digital Standard MUMPS) for their PDP-11 series, which became the dominant reference implementation in the market. Concurrently, InterSystems released ISM-11 for the PDP-11 platform, which was functionally equivalent to DSM-11.

1980s

At the start of the 1980s, multiple vendors introduced MUMPS platforms adhering to the ANSI standard. Prominent contributors included:

Digital Equipment Corporation, which developed DSM (Digital Standard MUMPS). The DSM-11 version for the PDP-11 series appeared in 1977, followed by VAX DSM in 1978. Both hardware and software versions were supported until 1995. DSM-11 was subsequently adapted for the Alpha architecture as DSM for OpenVMS and DSM for Ultrix.
InterSystems offered ISM (InterSystems M) initially on VMS (M/VX), later extending to PDP-11 (M/11+), MS-DOS (M/PC), Data General (M/DG), IBM VM/CMS (M/VM), and Unix (M/UX) systems.
Founded in 1980, Greystone Technology Corporation created a compiled variant named GT.M compatible with AIX, HP-UX, UNIX, and OpenVMS platforms.
DataTree Inc. launched an Intel PC-based product called DTM in 1982.
Micronetics Design Corporation (established 1980) provided MSM across diverse environments including MSM-PC, MSM/386, MS-UNIX, MSM-NT, and MSM/VM for IBM, VAX/VMS, and OpenVMS Alpha.
Computer Consultants (later known as MGlobal) developed CCSM on Motorola processors before producing MacMUMPS, which was the first commercial MUMPS for IBM PC and the sole version for classic Mac OS. They also contributed to the MGM implementation.
Tandem Computers delivered a MUMPS version specifically designed for their fault-tolerant hardware.
IBM briefly marketed MUMPS/VM, operating as a virtual machine under VM/370.

Throughout this decade, the Medical Device Coordination Committee (MDC) remained active. The second ANSI MUMPS standard revision (X11.1-1984) was ratified on November 15, 1984.

1990s

The third revision of the ANSI standard (X11.1-1990) received approval on November 11, 1990.
In 1992, this standard was adopted internationally as ISO 11756–1992; additionally, the term M was recognized as an alternative designation for MUMPS.
The fourth ANSI update (X11.1-1995) was sanctioned on December 8, 1995, later incorporated by ISO in 1999 as ISO 11756:1999 and also published by ANSI. A subsequent MDC revision in 1998 was not forwarded to ANSI.
The final major M Standard (ISO-IEC 11756-1999) was reaffirmed by ISO in 2020 alongside related standards for Open MUMPS Interconnect (15851:1999) and Windowing API (15852:1999).

2000s

By 1998, InterSystems had emerged as the leading middleware provider in the MUMPS arena through acquisitions such as DataTree Inc. (1993) and DEC’s DSM line (1994). These technologies were unified into the OpenM suite across multiple hardware platforms. In 1997, InterSystems introduced Caché, based on ISM with elements borrowed from other implementations. Their acquisition of Micronetics Design Corporation (#2 market contender) in 1998 further solidified their dominance. Today, InterSystems remains a market leader offering MSM, DSM, ISM, DTM products along with its IRIS Data Platform targeting developers on various operating systems. The company has since distanced itself from using "M" terminology or strictly adhering to the M standard.
Greystone Technology Corporation’s GT.M was acquired by Sanchez Computer Associates (now part of FIS) in the mid-1990s. Sanchez released GT.M under GPL licensing for Linux in 2000 and extended open licensing to OpenVMS and Tru64 UNIX versions by 2005. GT.M continues to be available on other UNIX systems under traditional licenses.
In 2000, Ray Newman and colleagues launched MUMPS V1, an implementation resembling DSM-11 initially developed for FreeBSD but later ported to Linux, Mac OS X, Windows (via Cygwin), and now Raspberry Pi.
April 2002 saw Real Software Company (UK) introduce M21, derived from MSM.
Several open source MUMPS variants exist; notably Dr. Kevin O’Kane’s Mumps/II, which has been ported to Mac OS X.
Neil Pappalardo, one of MUMPS’ original creators, founded MEDITECH in 1969. MEDITECH developed MIIS and MAGIC languages inspired by MUMPS but currently uses these internally without distributing middleware products.
MiniM, a minimalistic implementation created by Eugene Karataev, discontinued development in 2024.

Name

The chief executive officer of InterSystems found the term MUMPS to be a marketing hindrance. As a result, the preference for the designation "M" became linked with InterSystems. The 1990 ANSI Standard recognized both "M" and "MUMPS," and following international deliberations in 1992, the Mumps User Groups formally adopted "M" as the official name. This disagreement over naming highlighted competition among entities such as the M Technology Association, MUMPS Development Committee, ANSI, and ISO regarding authority over the language’s official title.

By 2020, ISO continued to acknowledge both "M" and "MUMPS" as valid official names.

In 1971, Massachusetts General Hospital secured a trademark for "MUMPS" with the USPTO, renewed it in 1992, but allowed it to lapse in 2003.

Overview

MUMPS was primarily architected for developing database-driven applications, with additional design elements aimed at reducing resource consumption. Initial versions were interpreted; contemporary implementations may be either fully or partially compiled. Programs execute within memory partitions—initially capped at 2048 bytes—encouraging concise coding to facilitate multiprogramming on hardware with limited capacity. The language’s foundation on multi-user systems is reflected in its name ("Multi-Programming"), with early MUMPS platforms supporting multiple simultaneous jobs.

Given strict memory limitations, every command or function could be abbreviated to between one and three letters (for example, Quit as Q, $Piece as $P). The use of line scope and meaningful spacing allowed highly compact code—often requiring significantly fewer characters than other programming languages. However, this brevity resulted in minimal commenting and extensive abbreviation, making code comprehension challenging even for experienced developers.

Database interaction is a core aspect: MUMPS incorporates a hierarchical database composed of persistent sparse arrays that are automatically accessible to all applications. Variables beginning with a caret (^) represent permanent storage ("Globals"), shared across all active processes. This shared persistent data structure resembles document-oriented databases. Variables without the caret are temporary and local to each job ("locals"). Both globals and locals support hierarchical subscripting using any ASCII characters—a distinctive capability at the time of standardization. For instance:

<syntaxhighlight lang="text"> SET ^Car("Door","Color")="BLUE" </syntaxhighlight>

In this example, "Color" is a subscript under ^Car("Door"). Subscripts follow canonical sorting: numeric subscripts are ordered numerically, while non-numeric ones appear alphabetically after numbers. Employing non-negative integer subscripts allows simulation of arrays common in other languages. Although MUMPS does not natively enforce schemas or provide full DBMS functionalities, multiple database systems have been developed on top of it that offer flat-file, relational, and network database models.

Built-in operators treat delimited strings as arrays, facilitating efficient data storage and parsing that enhanced performance on early computing hardware.

MUMPS is typeless; it automatically coerces between numbers and strings—sometimes causing unexpected behavior (e.g., IF 20<"30 DUCKS" evaluates TRUE).

Features supporting multi-user environments include database locking mechanisms, process identifiers, and atomic transaction capabilities—all mandated by standard implementations to maintain data consistency during concurrent access.

Unlike languages such as C or those designed by Wirth, spacing between statements in MUMPS is meaningful: a single space separates commands from their arguments; two spaces distinguish commands without arguments from subsequent commands. Newlines also define command boundaries; multi-line control structures necessitate explicit DO blocks.

Hello, World! example

An elementary "Hello, World!" program in MUMPS can be written as:

 write "Hello, World!",!

</syntaxhighlight>

After saving, it executes with the command do ^hello. MUMPS mandates a "label" at the initial line to mark the starting point of execution. Commands may be abbreviated and combined on a single line, allowing this routine to be condensed to:

<syntaxhighlight lang="text"> w "Hello, World!",! </syntaxhighlight>

The ',!' sequence appends a newline character. This hands control back to the command prompt.

Features

MUMPS is formally standardized by ANSI X11.1-1995, with an annotated version accessible online.

Notable characteristics of the language include:

Data types: Utilizes a single universal data type that dynamically converts between string, integer, or floating-point as required.

Booleans (truthvalues): Expressions interpret strings numerically; any nonzero value represents True.

Declarations: Variables are implicitly created upon first use; explicit declarations are unnecessary.

Lines: Multiple commands can appear on one line; IF, ELSE, and FOR statements apply to the remainder of that line.

Case sensitivity: Commands and functions ignore case differences; however, variables and labels are case-sensitive.

Postconditionals: Nearly all commands can be executed conditionally using colon syntax (e.g., SET:N<10 A="FOO").

Abbreviation: Most commands and functions may be shortened to between one and three characters.

Reserved words: None exist; command names can also serve as variable identifiers, providing flexible naming options.

Arrays: Created dynamically and stored as B-trees that are sparse and automatically sorted. They support any number of string or numeric subscripts. Built-in functions such as , , and facilitate efficient traversal whether data resides on disk or in memory.

for i=10000:1:12345 set sqtable(i)=i*i set address("Smith","Daniel")="dpbsmith@world.std.com" </syntaxhighlight>

Local arrays: Variables without the caret prefix reside in process-private memory, with size limits depending on implementation.

Global arrays: Variables beginning with a caret (e.g., ^abc) are stored persistently on disk, accessible by multiple processes simultaneously. They support very large datasets and constitute MUMPS' primary database mechanism without relying on operating system file operations.

Indirection: The @VBL syntax allows dynamic referencing of variable names and delayed binding (for example, SET @XYZ=123).

Piece function: Splits strings by specified delimiters to access or modify segments (e.g., $PIECE(STRING,"^",3)).

SET X="dpbsmith@world.std.com" SET $P(X,"@",1)="office" </syntaxhighlight>

This changes X to "office@world.std.com".

Order function: Retrieves the next subscript in sorted arrays, enabling iteration over databases and content-addressable data structures.

Set stuff(6)="xyz",stuff(10)=26,stuff(15)="" </syntaxhighlight>

$Order(stuff("")) returns 6, $Order(stuff(6)) returns 10, etc.

Set i="" For Set i=$O(stuff(i)) Quit:i="" Write !,i,10,stuff(i) </syntaxhighlight>

Outputs all keys and their corresponding values sequentially.

MUMPS supports concurrent multi-user and multi-process operation even on platforms lacking native multitasking capabilities (such as MS-DOS). It also permits remote data manipulation by including machine identifiers within variable references (e.g., SET ^|"DENVER"|A(1000)="Foo").

Criticism

Certain elements of MUMPS syntax diverge considerably from those found in contemporary programming languages, leading to confusion and inconsistencies across different versions. For instance, some implementations prohibit spaces within expressions (so writing 2 + 3 is invalid; it must be 2+3). All operators share the same precedence level and associate from left to right, meaning an expression like 2+3*10 evaluates as 50. The operators representing "less than or equal to" and "greater than or equal to" are '> and '<, although certain versions accept the more conventional forms <= and >=. Instead of using whitespace, lines within a DO block are indented with periods (.). The ELSE statement functions by checking the built-in system variable $test, eliminating the need for a matching IF statement.

MUMPS employs more lenient scoping rules compared to modern languages. Local variables declared explicitly reside on the stack, permitting routines to access locals from lower stack levels unless a new stack frame is created using do and variables are aliased with syntax like . new x,y. Variables that are not declared remain accessible across all routines within the same process until the program terminates.

Because database references differ from internal variables solely by the presence of a caret prefix (^), inadvertent modifications or deletions in the database can easily occur.

Users

Among early prominent adopters of MUMPS was the US Department of Veterans Affairs (VA), whose development efforts significantly influenced numerous healthcare organizations worldwide. In 1995, the VA's patient Admission/Tracking/Discharge system, known as the Decentralized Hospital Computer Program (DHCP), received the Computerworld Smithsonian Award recognizing excellence in medical IT. Later, in 2006, the VA and Veterans Health Administration earned the Innovations in American Government Award for advancing DHCP into the Veterans Health Information Systems and Technology Architecture (VistA). Today, nearly every VA hospital, along with the Indian Health Service and large portions of the Department of Defense’s Composite Health Care System (CHCS), rely on MUMPS databases for managing clinical data.

Several healthcare IT companies also utilize MUMPS technology, including:

Epic Systems
MEDITECH
GE Healthcare (previously IDX Systems and Centricity)
AmeriPath (part of Quest Diagnostics)
Care Centric
Allscripts
Coventry Health Care
EMIS Health
Sunquest Information Systems (formerly Misys Healthcare)
Netsmart

Many reference laboratories such as DASA, Quest Diagnostics, and Dynacare employ MUMPS-based software originally developed by Antrim Corporation; Antrim was acquired by Misys Healthcare (now Sunquest Information Systems) in 2001.

Beyond healthcare, MUMPS has found extensive application in financial systems. It established an early presence in banking and credit unions and continues to be used by institutions like Barclays Bank and the Bank of England.

Implementations

Since 2005, Greystone Technology MUMPS (GT.M), developed by Fidelity National Information Services, along with InterSystems Corporation’s Caché, have been leading MUMPS implementations. Notably, the European Space Agency chose InterSystems Caché to support the Gaia mission, which aims to create a highly precise map of the Milky Way. InterSystems is currently migrating from Caché to its next-generation platform, Iris.

Other active MUMPS implementations include:

M21
YottaDB
MiniM
Reference Standard M (RSM)
FreeM

External links