View source for MUMPS

{{Short description|Programming language}}
{{About|the programming language|the disease|Mumps|other uses|Mumps (disambiguation)}}
{{merge from|MUMPS syntax|date=October 2025}}
{{Infobox programming language
| name = MUMPS
| paradigm = [[Imperative programming|Imperative]], [[Procedural programming|procedural]]
| year = {{Start date and age|1966}}
| designer = [[Neil Pappalardo]],  Curt Marble, [[Robert A. Greenes]]
| latest_release_version = ANSI X11.1-1995
| latest_release_date = {{Start date|1995|12|08}}
| typing = Typeless
| influenced_by = [[JOSS]]
| influenced = [[Profile Scripting Language|PSL]], [[Caché ObjectScript]], [[GT.M]]
| operating_system = [[Cross-platform]]
}}

'''MUMPS''' ("Massachusetts General Hospital Utility Multi-Programming System"), or '''M''', is an imperative, high-level [[programming language]] with an integrated transaction processing [[key–value database]].  It was originally developed at [[Massachusetts General Hospital]] for managing patient medical records and hospital laboratory information systems.

MUMPS technology has since expanded as the predominant database for health information systems and [[electronic health record]]s in the United States.  MUMPS-based information systems, such as [[Epic Systems]], provide health information services for over 78% of patients across the U.S.<ref>{{Cite journal |last=November |first=Joseph |date=2016 |title=Ask your doctor... about computers |url=https://doi.org/10.1109/MAHC.2016.5 |journal=[[IEEE Annals of the History of Computing]] |volume=38 |issue=1 |pages=3–5|doi=10.1109/MAHC.2016.5 |url-access=subscription }}</ref>

A unique feature of the MUMPS technology is its integrated [[Query language|database language]], allowing direct, high-speed read-write access to permanent disk storage.{{r|Tweed_2008}}

== History ==

=== 1960s-1970s - Genesis ===

MUMPS was developed by [[Neil Pappalardo]], [[Robert A. Greenes]], and Curt Marble in Dr. Octo Barnett's lab at the [[Massachusetts General Hospital]] (MGH) in [[Boston]] during 1966 and 1967.<ref name="MUMPS1969" /> It grew out of frustration, during a [[National Institutes of Health]] (NIH) supported hospital information systems project at the MGH, with the development in assembly language on a time-shared [[PDP-1]] by primary contractor [[Bolt, Beranek & Newman]] (BBN).  MUMPS came out of an internal "[[Skunkworks project|skunkworks]]" project at MGH by Pappalardo, Greenes, and Marble to create an alternative development environment. As a result of initial demonstration of capabilities, Dr. Barnett's proposal to NIH in 1967 for renewal of the hospital computer project grant took the bold step of proposing that the system be built in MUMPS going forward, rather than relying on the BBN approach. The project was funded, and serious implementation of the system in MUMPS began.

The original MUMPS system was, like [[Unix]] a few years later, built on a [[Digital Equipment Corporation|DEC]] [[PDP-7]]. Octo Barnett and Neil Pappalardo obtained a [[backward compatible]] [[PDP-9]], and began using MUMPS in the admissions cycle and laboratory test reporting. MUMPS was then an [[interpreted language]], yet even then, it incorporated a [[hierarchical database]] file system to standardize interaction with the data and abstract disk operations so they were only done by the MUMPS language itself. MUMPS was also used in its earliest days in an experimental clinical progress note entry system<ref name="ProgNote1969" /> and a radiology report entry system.<ref name="Radiol1969" />

Some aspects of MUMPS can be traced from [[RAND Corporation]]'s [[JOSS]] through [[BBN Technologies|BBN]]'s [[TELCOMP]] and [[STRINGCOMP]].  The MUMPS team chose to include portability between machines as a design goal.

An advanced feature of the MUMPS language not widely supported in [[operating system]]s or in [[computer hardware]] of the era was [[computer multitasking|multitasking]]. Although [[time-sharing]] on [[mainframe computer]]s was increasingly common in systems such as [[Multics]], most mini-computers did not run parallel programs and threading was not available at all. Even on mainframes, the variant of batch processing where a program was run to completion was the most common implementation for an operating system of multi-programming.

It was a few years until Unix was developed. The lack of memory management hardware also meant that all multi-processing was fraught with the possibility that a memory pointer could change some other process. MUMPS programs do not have a standard way to refer to memory directly at all, in contrast to [[C language]], so since the multitasking was enforced by the language, not by any program written in the language it was impossible to have the risk that existed for other systems.

Dan Brevik's DEC MUMPS-15 system was adapted to a DEC [[PDP-15]], where it lived for some time. It was first installed at Health Data Management Systems of Denver in May 1971.{{r|FAQ}} The portability proved to be useful and MUMPS was awarded a government research grant, and so MUMPS was released to the public domain which was a requirement for grants. MUMPS was soon ported to a number of other systems including the popular DEC [[PDP-8]], the [[Data General Nova]] and on DEC [[PDP-11]] and the [[Artronix]] [[PC12 minicomputer]]. Word about MUMPS spread mostly through the medical community, and was in widespread use, often being locally modified for their own needs.

Versions of the MUMPS system were rewritten by technical leaders Dennis "Dan" Brevik and Paul Stylos{{r|FAQ}} of [[Digital Equipment Corporation|DEC]] in 1970 and 1971. By the early 1970s, there were many and varied implementations of MUMPS on a range of hardware platforms. Another noteworthy platform was Paul Stylos'{{r|FAQ}} DEC MUMPS-11 on the PDP-11, and [[MEDITECH]]'s [[MIIS (programming language)|MIIS]].  In the Fall of 1972, many MUMPS users attended a conference in Boston which standardized the then-fractured language, and created the '''MUMPS Users Group''' and '''MUMPS Development Committee''' (MDC) to do so. These efforts proved successful; a standard was complete by 1974, and was approved, on September 15, 1977, as [[American National Standards Institute|ANSI]] standard, X11.1-1977.  At about the same time DEC launched DSM-11 (Digital Standard MUMPS) for the PDP-11.  This quickly dominated the market, and became the reference implementation of the time. Also, [[InterSystems]] sold ISM-11 for the PDP-11 (which was identical to DSM-11).

=== 1980s ===

During the early 1980s several vendors brought MUMPS-based platforms that met the ANSI standard to market. The most significant were:
* Digital Equipment Corporation with '''DSM''' (Digital Standard MUMPS). For the PDP-11 series DSM-11 was released 1977.  '''VAX DSM'''<ref>{{cite book |title=VAX-11 DSM Language Reference Manual |date=1982 |publisher=Digital Equipment Corporation |oclc=29217964 }}</ref> was sold in parallel after released 1978. Both hardware families as well as MUMPS versions were available until 1995 from DEC. The DSM-11 was ported to the [[DEC Alpha|Alpha]] in two variants: '''DSM for OpenVMS''', and as '''DSM for Ultrix'''.
* [[InterSystems]] with '''ISM''' (InterSystems M) on VMS (M/VX), ISM-11 later M/11+ on the PDP-11 platform (1978), M/PC on MS-DOS, M/DG on [[Data General]], M/VM on IBM VM/CMS, and M/UX on various Unixes.
* Greystone Technology Corporation founded 1980, with a compiled version called [[GT.M]] for AIX, HP-UX, UNIX and OpenVMS
* DataTree Inc. with an Intel PC-based product called '''DTM'''. (1982)
* Micronetics Design Corporation (1980) with a product line called '''MSM.''' MSM-PC, MSM/386, MS-UNIX, MSM-NT, MSM/VM [[operating system|fo IBM]],  VAX/VMS platforms and OpenVMS Alpha platforms.
* Computer Consultants (later renamed MGlobal), a [[Houston]]-based company originally created '''CCSM''' on 6800, then 6809, and eventually a port to the 68000, which later became '''MacMUMPS''', a [[Classic Mac OS|Mac OS]]-based product. They also worked on the '''MGM''' MUMPS implementation. MGlobal also ported their implementation to the DOS platform. MGlobal MUMPS was the first commercial MUMPS for the IBM PC and the only implementation for the classic Mac OS.
* [[Tandem Computers]] developed an implementation for their fault-tolerant computers.<ref>{{ cite web |url=https://techlibrary.hpe.com/docs/enterprise/servers/nonstop/SPML_20_January_2012_final.pdf | access-date = 2014-05-17 | title = HP NonStop Servers, Software Product Maintenance List, Effective Date: January 2012 | publisher = Hewlett-Packard Development Company, L.P. | date = 2012-01-20 | page = 32 }}</ref>
* [[IBM]] briefly sold a MUMPS implementation named '''MUMPS/VM''' which ran as a [[virtual machine]] on top of [[VM/370]].<ref>{{cite news|title=Two versions of MUMPS out|url=https://books.google.com/books?id=7RERQMhC7cYC&pg=PP23|date=1987-11-30|newspaper=Computerworld|volume=XXI|issue=48|access-date=2022-07-09}}</ref>

This period also saw considerable MDC activity. The second revision of the ANSI standard for MUMPS (X11.1-1984) was approved on November 15, 1984.

=== 1990s ===

* On November 11, 1990, the third revision of the ANSI standard (X11.1-1990) was approved.
* In 1992 the same standard was also adopted as [[International Organization for Standardization|ISO]] standard 11756–1992. Use of '''M''' as an alternative name for the language was approved around the same time.
* On December 8, 1995, the fourth revision of the standard ([[X11.1-1995]]) was approved by ANSI, and by [[International Organization for Standardization|ISO]] in 1999 as [https://www.iso.org/standard/29268.html ISO 11756:1999], which was also [https://webstore.ansi.org/standards/iso/isoiec117561999 published by ANSI]. The MDC finalized a further revision to the standard in 1998 but this has not been presented to ANSI for approval.
* In 1999 the last M Standard (ISO-IEC 11756-1999) was approved. ISO re-affirmed this on 2020. Together with [https://www.iso.org/standard/29269.html ISO/IEC 15851:1999, Open MUMPS Interconnect] and [https://www.iso.org/standard/29270.html ISO/IEC 15852:1999, MUMPS Windowing Application Programmers Interface].

=== 2000s ===

* By 1998, the [[middleware (distributed applications)|middleware]] vendor InterSystems had become the dominant player in the MUMPS market with the purchase of several other vendors. Initially they acquired DataTree Inc. in 1993. On December 30, 1994, InterSystems acquired the DSM product line from DEC.{{r|Grabscheid_19950102}} InterSystems consolidated these products into a single product line, branding them, on several hardware platforms, as '''OpenM'''. In 1997, InterSystems launched a new product named [[InterSystems Caché|Caché]]. This was based on their ISM product, but with influences from the other implementations. Micronetics Design Corporation, at this time #2 on the market, was acquired by InterSystems on June 21, 1998. InterSystems remains the dominant "M vendor" owning MSM, DSM, ISM, DTM and selling its IRIS Data Platform (and, until 2018, its predecessor Caché) to M developers who write applications for a variety of operating systems. Also Intersystems did not use the term M anymore, neither followed the M standard. 
* Greystone Technology Corporation's GT.M implementation was sold to Sanchez Computer Associates (now part of [[Fidelity National Information Services|FIS]]) in the mid-1990s. On November 7, 2000, Sanchez made GT.M for Linux available under the [[GNU General Public License|GPL]] license{{r|Sanchez_20001107}} and on October 28, 2005, GT.M for [[OpenVMS]] and [[Tru64 UNIX]] were also made available under the AGPL license.<ref>{{cite web |url=https://sourceforge.net/projects/fis-gtm/files/ |title=GT.M High end TP database engine |publisher=Sourceforge.net |access-date=2013-08-12}}</ref> GT.M continues to be available on other [[UNIX]] platforms under a traditional license.
* During 2000, Ray Newman and others released MUMPS V1, an implementation of MUMPS (initially on FreeBSD) similar to DSM-11. MUMPS V1 has since been ported to [[Linux]], [[Mac OS X]], and [[Microsoft Windows|Windows]] (using cygwin).<ref>{{cite web |url=https://sourceforge.net/projects/mumps/files/ |title=MUMPS Database and Language |publisher=Sourceforge.net |access-date=2013-08-12}}</ref> Initially only for the x86 CPU, MUMPS V1 has now been ported to the Raspberry Pi.
* Released in April 2002 an '''MSM''' derivative called '''M21''' is offered from the Real Software Company of Rugby, [[UK]].
* There are also several open source implementations of MUMPS, including some research projects. The most notable of these is [https://www.cs.uni.edu/~okane/ Mumps/II], by Dr. Kevin O'Kane (Professor Emeritus, [[University of Northern Iowa]]) and students' project. Dr. O'Kane has also ported the interpreter to Mac OS X.<ref>{{cite web|url=https://www.rychannel.com/mumps |title=Mumps/Mii |publisher=Rychannel.com |date=2012-11-08 |access-date=2013-08-12}}</ref>
* One of the original creators of the MUMPS language, Neil Pappalardo, founded a company called [[MEDITECH]] in 1969. They extended and built on the MUMPS language, naming the new language MIIS (and later, another language named MAGIC). Unlike InterSystems, MEDITECH no longer sells middleware, so MIIS and MAGIC are now only used internally at MEDITECH.
* A lightweight implementation is MiniM from Eugene Karataev which halted development in 2024<ref>{{cite web | url=https://thedarkaugust.blogspot.com/2024/11/minim-database-server.html | title=The Dark August: MiniM Database Server }}</ref>
{{More citations needed section|date=October 2018}}

=== Name ===
The chief executive of InterSystems disliked the name MUMPS and felt that it represented a serious marketing obstacle. Thus, favoring M to some extent became identified as alignment with InterSystems. The 1990 ANSI Standard was open to both M and MUMPS and after a "world-wide" discussion in 1992 the Mumps User Groups officially changed the name to M. The dispute also reflected rivalry between organizations (the M Technology Association, the MUMPS Development Committee, the ANSI and ISO Standards Committees) as to who determines the "official" name of the language.{{citation needed|date=February 2022}}

As of 2020, the ISO still mentions both M and MUMPS as officially accepted names.<ref>{{Cite web |date=2020 |title=ISO/IEC 11756:1999(en) Information technology — Programming languages — M |url=https://www.iso.org/obp/ui/en/#iso:std:iso-iec:11756:ed-2:v1:en |access-date=2024-04-18 |website=www.iso.org}}</ref>

[[Massachusetts General Hospital]] registered "MUMPS" as a trademark with the USPTO on November 28, 1971, and renewed it on November 16, 1992, but let it expire on August 30, 2003.<ref>{{cite web |url=https://tsdr.uspto.gov/#caseNumber=72382020&caseType=SERIAL_NO&searchType=statusSearch |title=Trademark Status & Document Retrieval |website=tsdr.uspto.gov |access-date=26 February 2018}}</ref>

== Design ==
{{Main|MUMPS syntax}}
{{how-to|section|date=February 2022}}

=== Overview ===

MUMPS is a language intended for and designed to build database applications. Secondary language features were included to help programmers make applications using minimal computing resources. The original implementations were [[interpreter (computing)|interpreted]], though modern implementations may be fully or partially [[compiler|compiled]]. Individual "programs" run in memory [[memory management (operating systems)#Partitioned allocation|"partitions"]]. Early MUMPS memory partitions were limited to 2048 bytes so aggressive abbreviation greatly aided multi-programming on severely resource limited hardware, because more than one MUMPS job could fit into the very small memories extant in hardware at the time. The ability to provide multi-user systems was another language design feature. The word "'''M'''ulti-'''P'''rogramming" in the acronym points to this. Even the earliest machines running MUMPS supported multiple jobs running at the same time. With the change from mini-computers to micro-computers a few years later, even a "single user PC" with a single 8-bit CPU and 16K or 64K of memory could support multiple users, who could connect to it from (non-[[GUI|graphical]]) [[computer terminal|video display terminals]].

Since memory was tight originally, the language design for MUMPS valued very terse code. Thus, every MUMPS command or function name could be abbreviated from one to three letters in length, e.g. {{mono|Quit}} (exit program) as {{mono|Q}}, {{mono|$P}} = {{mono|$Piece}} function, {{mono|R}} = {{mono|Read}} command, {{mono|$TR}} = {{mono|$Translate}} function. Spaces and end-of-line markers are significant in MUMPS because line scope promoted the same terse language design. Thus, a single line of program code could express, with few characters, an idea for which other programming languages could require 5 to 10 times as many characters. Abbreviation was a common feature of languages designed in this period (e.g., [[FOCAL-69]], early BASICs such as [[Tiny BASIC]], etc.). An unfortunate side effect of this, coupled with the early need to write minimalist code, was that MUMPS programmers routinely did not comment code and used extensive abbreviations. This meant that even an expert MUMPS programmer could not just skim through a page of code to see its function but would have to analyze it line by line.

Database interaction is transparently built into the language. The MUMPS language provides a [[hierarchical database model|hierarchical database]] made up of [[persistence (computer science)|persistent]] [[sparse array]]s, which is implicitly "opened" for every MUMPS application. All variable names prefixed with the caret character ({{code|^}}) use permanent (instead of RAM) storage, will maintain their values after the application exits, and will be visible to (and modifiable by) other running applications. Variables using this shared and permanent storage are called ''Globals'' in MUMPS, because the scoping of these variables is "globally available" to all jobs on the system. The more recent and more common use of the name "global variables" in other languages is a more limited scoping of names, coming from the fact that [[scope (computer science)|unscoped variables]] are "globally" available to any programs running in the same process, but not shared among multiple processes. The MUMPS Storage mode (i.e. globals stored as persistent sparse arrays), gives the MUMPS database the characteristics of a [[document-oriented database]].<ref>{{cite web |url=http://gradvs1.mgateway.com/download/extreme1.pdf |title=Extreme Database programming with MUMPS Globals |publisher=Gradvs1.mjgateway.com |access-date=2013-08-13 |archive-date=2016-07-06 |archive-url=https://web.archive.org/web/20160706033008/http://gradvs1.mgateway.com/download/extreme1.pdf |url-status=dead }}</ref>

All variable names which are not prefixed with caret character ({{code|^}}) are temporary and private. Like global variables, they also have a hierarchical storage model, but are only "locally available" to a single job, thus they are called "locals". Both "globals" and "locals" can have child nodes (called ''subscripts'' in MUMPS terminology).  Subscripts are not limited to numerals—any [[ASCII]] character or group of characters can be a subscript identifier. While this is not uncommon for modern languages such as Perl or JavaScript, it was a highly unusual feature in the late 1970s. This capability was not universally implemented in MUMPS systems before the 1984 ANSI standard, as only canonically numeric subscripts were required by the standard to be allowed.<ref>{{cite web |url=http://71.174.62.16/Demo/AnnoStd?Frame=Main&Page=a202005&Edition=1977 |title=The Annotated M[UMPS&#93; Standards |publisher=71.174.62.16 |date=2011-11-29 |access-date=2013-08-12}}</ref> Thus, the variable named 'Car' can have subscripts "Door", "Steering Wheel", and "Engine", each of which can contain a value and have subscripts of their own.  The variable {{code|^Car("Door")}} could have a nested variable subscript of "Color" for example. Thus, you could say

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

to modify a nested child node of {{code|^Car}}. In MUMPS terms, "Color" is the 2nd subscript of the variable {{code|^Car}} (both the names of the child-nodes and the child-nodes themselves are likewise called subscripts). Hierarchical variables are similar to objects with properties in many [[object-oriented programming|object-oriented]] languages. Additionally, the MUMPS language design requires that all subscripts of variables are automatically kept in sorted order. Numeric subscripts (including floating-point numbers) are stored from lowest to highest. All non-numeric subscripts are stored in alphabetical order following the numbers. In MUMPS terminology, this is ''canonical order''. By using only non-negative integer subscripts, the MUMPS programmer can emulate the [[array data type|arrays]] data type from other languages. Although MUMPS does not natively offer a full set of [[database management system|DBMS]] features such as mandatory schemas, several DBMS systems have been built on top of it that provide application developers with flat-file, relational, and [[network database]] features.

Additionally, there are built-in operators which treat a delimited string (e.g., [[comma-separated values]]) as an array. Early MUMPS programmers would often store a structure of related information as a delimited string, parsing it after it was read in; this saved disk access time and offered considerable speed advantages on some hardware.

MUMPS has no data types. Numbers can be treated as strings of digits, or strings can be treated as numbers by numeric operators (''coerced'', in MUMPS terminology). Coercion can have some odd side effects, however. For example, when a string is coerced, the parser turns as much of the string (starting from the left) into a number as it can, then discards the rest.  Thus the statement <code>IF 20<"30 DUCKS"</code> is evaluated as <code>TRUE</code> in MUMPS.

Other features of the language are intended to help MUMPS applications interact with each other in a multi-user environment. Database locks, process identifiers, and [[atomicity (database systems)|atomicity]] of database update transactions are all required of standard MUMPS implementations.

In contrast to languages in the C or [[Niklaus Wirth#Programming languages|Wirth]] traditions, some space characters between MUMPS statements are significant. A single space separates a command from its argument, and a space, or newline, separates each argument from the next MUMPS token. Commands which take no arguments (e.g., <code>ELSE</code>) require two following spaces. The concept is that one space separates the command from the (nonexistent) argument, the next separates the "argument" from the next command. Newlines are also significant; an <code>IF</code>, <code>ELSE</code> or <code>FOR</code> command processes (or skips) everything else till the end-of-line. To make those statements control multiple lines, you must use the <code>DO</code> command to create a code block.

=== Hello, World! example ===

A simple [["Hello, World!" program]] in MUMPS might be:

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

and would be run with the command <code>do ^hello</code>  after it has been saved to disk. For direct execution of the code a kind of  "label" (any alphanumeric string) on the first position of the program line is needed to tell the mumps interpreter where to start execution. Since MUMPS allows commands to be strung together on the same line, and since commands can be abbreviated to a single letter, this routine could be made more compact:

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

The '<code>,!</code>' after the text generates a newline. This code would return to the prompt.

=== Features ===

ANSI X11.1-1995 gives a complete, formal description of the language; an annotated version of this standard is available online.<ref>{{cite web|url=http://71.174.62.16/Demo/AnnoStd|title=The Annotated M[UMPS] Standards|website=71.174.62.16|access-date=26 February 2018}}</ref>

Language features include:

; Data types : There is one universal [[data type]], which is implicitly [[type conversion|coerced]] to string, integer, or floating-point data types as context requires.

; Booleans {{nobold|(called ''truthvalues'' in MUMPS)}}: In IF commands and other syntax that has expressions evaluated as conditions, any string value is evaluated as a numeric value and, if that is a nonzero value, then it is interpreted as True. <code>a<b</code> yields 1 if a is less than b, 0 otherwise.

; Declarations : None. All variables are dynamically created at the first time a value is assigned.

; Lines : are important syntactic entities, unlike their status in languages patterned on C or Pascal. Multiple statements per line are allowed and are common. The scope of any {{mono|IF}}, {{mono|ELSE}}, and {{mono|FOR}} command is "the remainder of current line."

; Case sensitivity : Commands and intrinsic functions are case-insensitive. In contrast, variable names and labels are case-sensitive.  There is no special meaning for upper vs. lower-case and few widely followed conventions. The percent sign (%) is legal as first character of variables and labels.

; Postconditionals : execution of almost any command can be controlled by following it with a colon and a truthvalue expression. <code>SET:N<10 A="FOO"</code>  sets A to "FOO" if N is less than 10; <code>DO:N>100 PRINTERR,</code> performs PRINTERR if N is greater than 100. This construct provides a conditional whose scope is less than a full line.

; Abbreviation : You can abbreviate nearly all commands and native functions to one, two, or three characters.

; Reserved words : None.  Since MUMPS interprets source code by context, there is no need for reserved words. You may use the names of language commands as variables, so the following is perfectly legal MUMPS code:

:<syntaxhighlight lang="text">
GREPTHIS()
       NEW SET,NEW,THEN,IF,KILL,QUIT SET IF="KILL",SET="11",KILL="11",QUIT="RETURN",THEN="KILL"
       IF IF=THEN DO THEN
       QUIT:$QUIT QUIT QUIT ; (quit)
THEN  IF IF,SET&KILL SET SET=SET+KILL QUIT
</syntaxhighlight>

:MUMPS can be made more obfuscated by using the contracted operator syntax, as shown in this terse example derived from the example above:

:<syntaxhighlight lang="text">
GREPTHIS()
       N S,N,T,I,K,Q S I="K",S="11",K="11",Q="R",T="K"
       I I=T D T
       Q:$Q Q Q
T  I I,S&K S S=S+K Q
</syntaxhighlight>

; Arrays : are created dynamically, stored as [[B-tree]]s, are [[sparse matrix|sparse]] (i.e. use almost no space for missing nodes), can use any number of subscripts, and subscripts can be strings or numeric (including floating point). Arrays are always automatically stored in sorted order, so there is never any occasion to sort, pack, reorder, or otherwise reorganize the database. Built-in functions such as {{mono|$DATA}}, {{mono|$ORDER}}, {{mono|$NEXT}}(deprecated), and {{mono|$QUERY}} functions provide efficient examination and traversal of the fundamental array structure, on disk or in memory.

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

; Local arrays : variable names not beginning with caret (i.e. "^") are stored in memory by process, are private to the creating process, and expire when the creating process terminates. The available storage depends on implementation. For those implementations using partitions, it is limited to the partition size (a small partition might be 32K). For other implementations, it may be several megabytes.

; Global arrays : <code>^abc, ^def</code>. These are stored on disk, are available to all processes, and are persistent when the creating process terminates. Very large globals (for example, hundreds of gigabytes) are practical and efficient in most implementations. This is MUMPS' main "database" mechanism. It is used instead of calling on the operating system to create, write, and read files.

; Indirection : in many contexts, <code>@VBL</code> can be used, and effectively substitutes the contents of VBL into another MUMPS statement. <code>SET XYZ="ABC" SET @XYZ=123</code> sets the variable ABC to 123. <code>SET SUBROU="REPORT" DO @SUBROU</code> performs the subroutine named REPORT. This substitution allows for [[lazy evaluation]] and late binding as well as effectively the operational equivalent of "pointers" in other languages.

; Piece function : This breaks variables into segmented pieces guided by a user specified separator string (sometimes called a "delimiter"). Those who know [[awk]] will find this familiar. <code>$PIECE(STRINGVAR,"^",3)</code> means the "third caret-separated piece of {{mono|STRINGVAR}}." The piece function can also appear as an assignment (SET command) target.

:<code>$PIECE("world.std.com",".",2)</code> yields {{samp|std}}.

:After
:<syntaxhighlight lang="text">
SET X="dpbsmith@world.std.com"
</syntaxhighlight>

:<code>SET $P(X,"@",1)="office"</code> causes X to become "office@world.std.com" (note that {{mono|$P}} is equivalent to {{mono|$PIECE}} and could be written as such).

; Order function : This function treats its input as a structure, and finds the next index that exists which has the same structure except for the last subscript. It returns the sorted value that is ordered after the one given as input. (This treats the array reference as a content-addressable data rather than an address of a value.)

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

:<code>$Order(stuff(""))</code> yields {{samp|6}}, <code>$Order(stuff(6))</code> yields {{samp|10}}, <code>$Order(stuff(8))</code> yields {{samp|10}}, <code>$Order(stuff(10))</code> yields {{samp|15}}, <code>$Order(stuff(15))</code> yields {{samp|""}}.

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

:Here, the argument-less {{mono|For}} repeats until stopped by a terminating {{mono|Quit}}.  This line prints a table of {{mono|i}} and {{code|stuff(i)}} where {{mono|i}} is successively 6, 10, and 15.

:For iterating the database, the Order function returns the next key to use.

:<syntaxhighlight lang="text">
GTM>S n=""
GTM>S n=$order(^nodex(n))
GTM>zwr n
n=" building"
GTM>S n=$order(^nodex(n))
GTM>zwr n
n=" name:gd"
GTM>S n=$order(^nodex(n))
GTM>zwr n
n="%kml:guid"
</syntaxhighlight>

MUMPS supports multiple simultaneous users and processes even when the underlying operating system does not (e.g., [[MS-DOS]]).  Additionally, there is the ability to specify an environment for a variable, such as by specifying a machine name in a variable (as in <code>SET ^|"DENVER"|A(1000)="Foo"</code>), which can allow you to access data on remote machines.

=== Criticism ===
{{criticism section|date=February 2022}}

Some aspects of MUMPS syntax differ strongly from that of more modern languages, which can cause confusion, although those aspects vary between different versions of the language. On some versions, whitespace is not allowed within expressions, as it ends a statement: <code>2 + 3</code> is an error, and must be written <code>2+3</code>. All operators have the same precedence and are [[operator associativity|left-associative]] (<code>2+3*10</code> evaluates to 50). The operators for "less than or equal to" and "greater than or equal to" are <code>'></code> and <code>'<</code> (that is, the Boolean negation operator <code>'</code> plus a strict comparison operator in the opposite direction), although some versions allow the use of the more standard <code><=</code> and <code>>=</code> respectively. Periods (<code>.</code>) are used to indent the lines in a DO block, not whitespace. The ELSE command does not need a corresponding IF, as it operates by inspecting the value in the built-in system variable <code>$test</code>.

MUMPS [[scope (computer science)|scoping]] rules are more permissive than other modern languages. Declared local variables are scoped using the stack. A routine can normally see all declared locals of the routines below it on the call stack, and routines cannot prevent routines they call from modifying their declared locals, unless the caller manually creates a new stack level (<code>do</code>) and aliases each of the variables they wish to protect (<code>. new x,y</code>) before calling any child routines. By contrast, undeclared variables (variables created by using them, rather than declaration) are in scope for all routines running in the same process, and remain in scope until the program exits.

Because MUMPS database references differ from internal variable references only in the caret prefix, it is dangerously easy to unintentionally edit the database, or even to delete a database "table".{{r|Richmond_1984_Thesis}}

== Users ==

The US Department of Veterans Affairs (formerly the Veterans Administration) was one of the earliest major adopters of the MUMPS language. Their development work (and subsequent contributions to the free MUMPS application codebase) was an influence on many medical users worldwide. In 1995, the Veterans Affairs' patient Admission/Tracking/Discharge system, [[Decentralized Hospital Computer Program]] (DHCP), was the recipient of the Computerworld [[Smithsonian Award]] for best use of Information Technology in Medicine. In July 2006, the Department of Veterans Affairs (VA) / [[Veterans Health Administration]] (VHA) was the recipient of the Innovations in American Government Award presented by the Ash Institute of the [[John F. Kennedy School of Government]] at [[Harvard University]] for its extension of DHCP into the Veterans Health Information Systems and Technology Architecture ([[VistA]]). Nearly the entire VA hospital system in the United States, the [[Indian Health Service]], and major parts of the [[United States Department of Defense|Department of Defense]] [[Composite Health Care System|CHCS]] hospital system use MUMPS databases for clinical data tracking.

Other healthcare IT companies using MUMPS include:

* [[Epic Systems|Epic]]
* [[MEDITECH]]
* [[GE Healthcare]] (formerly [[IDX Systems]] and [[Centricity]])
* AmeriPath (part of Quest Diagnostics)
* Care Centric
* [[Allscripts]]
* [[Coventry Health Care]]
* [[EMIS Health]]
* [[Sunquest Information Systems]] (formerly Misys Healthcare<ref>{{cite web|url=https://www.healthcareitnews.com/news/sunquest-emerges-misys-shadow |title=SunQuest emerges from Misys' shadow |date=13 March 2008 |publisher=Healthcare IT News |access-date=2013-08-12}}</ref>).
* Netsmart

Many reference laboratories, such as DASA, [[Quest Diagnostics]],<ref>{{cite web |url=https://www.slideshare.net/george.james/missioncritical-ajaxmaking-test-ordering-easier-and-faster-at-quest-diagnostics |title=Mission-critical Ajax: Making Test Ordering Easier and Faster at Qu |date=5 April 2008 |publisher=Slideshare.net |access-date=2013-08-12}}</ref> and Dynacare, use MUMPS software written by or based on Antrim Corporation code. Antrim was purchased by Misys Healthcare (now [[Sunquest Information Systems]]) in 2001.<ref>{{cite web|url=http://www.thefreelibrary.com/Sunquest+acquires+Antrim+Corp.-a018916869 |title=Sunquest acquires Antrim Corp. - Free Online Library |publisher=Thefreelibrary.com |date=1996-11-26 |access-date=2013-08-12}}</ref>

MUMPS is also widely used in financial applications. MUMPS gained an early following in the financial sector and is in use at many banks and credit unions. It is used by the [[Bank of England]] and [[Barclays Bank]].<ref>{{cite web|url=http://www.m21.uk.com/newtom.php |title=Welcome to M21 -- the database for the 21st Century|publisher=M21.uk.com|access-date=2013-08-13}}</ref><ref>{{cite web|url=http://www.intersystems.com/industry/financial/intersystems-in-financial.html|title=Caché-based Financial Systems | website = [[InterSystems]] |access-date=2013-08-13 |archive-url=https://web.archive.org/web/20130602202951/http://www.intersystems.com/industry/financial/intersystems-in-financial.html |archive-date=2013-06-02 |url-status=dead}}</ref><ref>{{cite web|url=http://www.idea.cz/company/references|title=IDEA Turn-Key banking and ERP applications|publisher=Idea.cz|access-date=2013-08-13}}</ref>

== Implementations ==

Since 2005, the most popular implementations of MUMPS have been Greystone Technology MUMPS (GT.M) from Fidelity National Information Services, and Caché, from Intersystems Corporation. The European Space Agency announced on May 13, 2010, that it will use the [[InterSystems Caché]] database to support the [[Gaia (spacecraft)|''Gaia'']] mission. This mission aims to map the [[Milky Way]] with unprecedented precision.<ref>{{cite web |url=https://www.realwire.com/release_detail.asp?ReleaseID=18645 |title=European Space Agency Chooses InterSystems Caché Database For Gaia Mission to Map Milky Way |work=RealWire |date=13 May 2010 |publisher=Realwire.com |access-date=2013-08-13}}</ref> InterSystems is in the process of phasing out Caché in favor of Iris.<ref>{{cite web |url=https://www.intersystems.com/products/intersystems-iris/ |title=InterSystems Iris  | website = [[InterSystems]] |access-date=2021-03-18}}</ref>

Other current implementations include:

* M21
* YottaDB<ref>{{cite web |url=https://yottadb.com/ |title=YottaDB website |date=24 May 2024 |publisher=yottadb.com |access-date=2023-05-24}}</ref>
* MiniM
* [https://gitlab.com/Reference-Standard-M/rsm Reference Standard M (RSM)]
* [https://freem.coherent-logic.com/ FreeM]

== See also ==

* [[Profile Scripting Language]]
* [[Caché ObjectScript]]
* [[GT.M]]
* [[InterSystems Caché]]

== References ==
{{reflist|30em|refs=

<ref name="MUMPS1969">{{cite journal |last1=Greenes |first1=Robert |last2=Pappalardo |first2=A Neil |last3=Marble |first3=Curt W |last4=Barnett |first4=G Octo |title=Design and implementation of a clinical data management system. |journal=Comput Biomed Res |date=1969 |volume=5 |issue=Oct |pages=469–85 |doi=10.1016/0010-4809(69)90012-3 |pmid=11697375 }}</ref>

<ref name="Radiol1969">{{cite journal |last1=Pendergrass |first1=Henry P |last2=Greenes |first2=Robert A |last3=Barnett |first3=G Octo |last4=Poitras |first4=James W |last5=Pappalardo |first5=A Neil |last6=Marble |first6=Curt W |title=An on-line computer facility for systematized input of radiology reports |journal=Radiology |date=1969 |volume=92 |issue=4 |pages=709–13 |doi=10.1148/92.4.709 |pmid=5767748 }}</ref>

<ref name="ProgNote1969">{{cite journal |last1=Greenes |first1=Robert A |last2=Barnett |first2=G Octo |last3=Klein |first3=Stuart W |last4=Robbins |first4=Anthony |last5=Prior |first5=Roderick E |title=Recording, retrieval and review of medical data by physician-computer interaction |journal=N Engl J Med |date=1970 |volume=282 |issue=6 |pages=307–15 |doi=10.1056/NEJM197002052820605 |pmid=5410816 }}</ref>

<ref name="Tweed_2008">{{cite web | last1 = Tweed | first1 = Rob | last2 = James | first2 = George | url = https://www.slideshare.net/george.james/mumps-the-internet-scale-database-presentation | url-access = limited | title = MUMPS: the Internet scale database | date =  2008-08-02 | access-date = 2022-10-25 | via = [[SlideShare]] | archive-url = https://web.archive.org/web/20210927022608/https://www.slideshare.net/george.james/mumps-the-internet-scale-database-presentation | archive-date = 2021-09-27 | url-status = live | df = dmy-all }}</ref>

<ref name="FAQ">{{cite newsgroup | last1 = Trask | first1 = Gardner  | last2 = Diamond | first2 = Jon | date = 1999-04-06 | url = https://groups.google.com/g/comp.lang.mumps/c/-SKjCBmiHDg/m/7T1_ePl0rewJ | title = M Technology and MUMPS Language FAQ, Part 1/2 | message-id = FKu0LK.19p@world.std.com | newsgroup = comp.lang.mumps | access-date = 2022-10-25 | df = dmy-all }}</ref>

<ref name="Grabscheid_19950102">{{cite newsgroup | last1 = Grabscheid | first1 = Paul | last2 = Ragon | first2 = Terry | author-link2 = Phillip Ragon | date = 1995-01-02 | url = https://groups.google.com/g/comp.lang.mumps/c/x-slxmV6dFY/m/hwSTpyiTUNQJ | title = DSM Announcement | message-id = hwSTpyiTUNQJ@world.std.com | newsgroup = comp.lang.mumps | access-date = 2022-10-25 | df = dmy-all }}</ref>

<ref name="Sanchez_20001107">{{cite press release |url=http://www.sanchez.com/news_2000/nr_001107.asp | title = Sanchez Offers GT.M Database as Open Source Freeware to GNU/Linux Users | website = [[FIS (company)|Sanchez Computer Associates, Inc.]] | date = 2000-11-08 | access-date = 2013-08-12 |url-status=usurped | archive-url = https://web.archive.org/web/20040428215120/http://www.sanchez.com/news_2000/nr_001107.asp | archive-date = 2004-04-28 | df = dmy-all}}</ref>

<ref name="Richmond_1984_Thesis">{{cite thesis | type = PhD | last1 = Richmond | first1 = Joseph Robin | date = 1984 | title = Software maintainability metrics for MUMPS programs | publisher = [[University of Texas Southwestern Medical Center|The University of Texas Health Science Center at Dallas]] | oclc = 13285529 }}</ref>

}}

== Further reading ==
{{refbegin|20em}}
* {{cite book |last1 = Walters | first1 = Richard F. | date = 1989-01-15 | title = ABCs of MUMPS: An Introduction for Novice and Intermediate Programmers | language = en-us | edition = 2nd | publisher = Digital Press | isbn = 978-1555580179 | lccn = 88033522 | oclc = 18989618 | ol = OL2055247M | df = dmy-all}}
* {{cite book |last1 = Walters | first1 = Richard F. | date = 1997-06-19 | title = M Programming: A Comprehensive Guide | url = https://archive.org/details/mprogrammingcomp0000walt | url-access = registration | language = en-us | edition = 2nd | publisher = Digital Press | isbn = 978-1-55558-167-1 | lccn = 97006513 | oclc = 78593848 | ol = OL661091M | via = [[Internet Archive]] | df = dmy-all}}
* Lewkowicz, John. ''The Complete MUMPS: An Introduction and Reference Manual for the MUMPS Programming Language.'' {{ISBN|0-13-162125-4}}
* Kirsten, Wolfgang, et al. (2003) ''Object-Oriented Application Development Using the Caché Postrelational Database'' {{ISBN|3-540-00960-4}}
*{{cite book |last1 = Martinez de Carvajal | first1 = Ernesto | date = 1993 | title = El Lenguaje MUMPS | language = es-es | edition = 1st | location = Barcelona | publisher = PPU | isbn = 978-8447701254 | oclc = 435380102 | ol = OL40214570M | df = dmy-all}}
* O'Kane, K.C.; ''A language for implementing information retrieval software,'' Online Review, Vol 16, No 3, pp 127–137 (1992).
* O'Kane, K.C.; and McColligan, E. E., ''A case study of a Mumps intranet patient record,'' Journal of the Healthcare Information and Management Systems Society, Vol 11, No 3, pp 81–95 (1997).
* O'Kane, K.C.; and McColligan, E.E., ''A Web Based Mumps Virtual Machine,'' Proceedings of the American Medical Informatics Association 1997
* O'Kane, K.C., The Mumps Programming Language, Createspace, {{ISBN|1-4382-4338-3}}, 120 pages (2010).
{{refend}}

== External links ==

* {{cite newsgroup | last1 = Trask | first1 = Gardner  | last2 = Diamond | first2 = Jon | date = 1999-04-06 | url = https://groups.google.com/g/comp.lang.mumps/c/-SKjCBmiHDg/m/7T1_ePl0rewJ | title = M Technology and MUMPS Language FAQ, Part 1/2 | message-id = FKu0LK.19p@world.std.com | newsgroup = comp.lang.mumps | access-date = 2022-10-25 | df = dmy-all }}
* {{cite newsgroup | url = https://groups.google.com/g/comp.lang.mumps/ | title = comp.lang.mumps | newsgroup = comp.lang.mumps | access-date = 2022-10-25 | via = [[Google Groups]] | df = dmy-all }}
* [http://www.cs.uni.edu/~okane/ Mumps Programming Language Interpreter (GPL)] by Kevin O'Kane, University of Northern Iowa
* {{sourceforge|mumps|MUMPS}}
* [https://www.hardhats.org/links/Mlinks.html M Links at Hardhats.org]
* [https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2245220/ Development and Operation of a MUMPS Laboratory Information System: A Decade's Experience at Johns Hopkins Hospital]
* [http://www.idea.cz/technology IDEA Systems' technology solutions based on YottaDB (formerly FIS GT.M) and Caché]
* [http://www.mumps.cz/ MUMPS documentation, topics, and resources (mixed Czech and English)]

{{programming languages}}
{{Digital Equipment Corporation}}
{{authority control}}

[[Category:MUMPS programming language]]
[[Category:Data processing]]
[[Category:Data-centric programming languages]]
[[Category:Digital Equipment Corporation]]
[[Category:Dynamically typed programming languages]]
[[Category:Health informatics]]
[[Category:IEC standards]]
[[Category:ISO standards]]
[[Category:Massachusetts General Hospital]]
[[Category:PDP-11]]
[[Category:Persistent programming languages]]
[[Category:Programming languages with an ISO standard]]
[[Category:Scripting languages]]
[[Category:Programming languages created in 1966]]