{
  "id": "enwiki-001370059139",
  "slug": "mumps",
  "title": "MUMPS",
  "qid": "",
  "lead": "Mumps is a highly contagious, vaccine-preventable viral disease caused by the mumps virus. Initial symptoms of mumps are non-specific and include fever, headache, malaise, muscle pain, and loss of appetite. These symptoms are usually followed by painful swelling around the side of the face (the parotid glands, called parotitis), which is the most common symptom of a mumps infection. Symptoms typically occur 16 to 18 days after exposure to the virus. About one-third of people with a mumps infection do not have any symptoms (asymptomatic). Complications are rare but include deafness and a wide range of inflammatory conditions, of which inflammation of the testes, breasts, ovaries, pancreas, meninges, and brain are the most common. Testicular inflammation may result in reduced fertility and, rarely, sterility. Humans are the only natural hosts of the mumps virus. The mumps virus is an RNA virus in the family Paramyxoviridae. The virus is primarily transmitted by respiratory secretions such as droplets and saliva, as well as via direct contact with an infected person. Mumps is highly contagious and spreads easily in densely populated environments. Transmission can occur from one week before the onset of symptoms to eight days after. During infection, the virus first infects the upper respiratory tract. From there, it spreads to the salivary glands and lymph nodes.…",
  "body": "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 records 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. A unique feature of the MUMPS technology is its integrated database language, allowing direct, high-speed read-write access to permanent disk storage. 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. (exit program) as , = function, = command, = 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 made up of persistent sparse arrays, which is implicitly \"opened\" for every MUMPS application. All variable names prefixed with the caret character ( ) 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 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. All variable names which are not prefixed with caret character ( ) 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. 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 could have a nested variable subscript of \"Color\" for example. Thus, you could say SET ^Car(\"Door\",\"Color\")=\"BLUE\" to modify a nested child node of . In MUMPS terms, \"Color\" is the 2nd subscript of the variable (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 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 arrays data type from other languages. Although MUMPS does not natively offer a full set of 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 IF 20 is evaluated as TRUE 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 of database update transactions are all required of standard MUMPS implementations. In contrast to languages in the C or 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., ELSE ) 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 IF , ELSE or FOR command processes (or skips) everything else till the end-of-line. To make those statements control multiple lines, you must use the DO command to create a code block. write \"Hello, World!\",! and would be run with the command do ^hello 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: w \"Hello, World!\",! The ' ,! ' after the text generates a newline. This code would return to the prompt. 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 MUMPS can be made more obfuscated by using the contracted operator syntax, as shown in this terse example derived from the example above: 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 Arrays : are created dynamically, stored as B-trees, are 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 , , (deprecated), and functions provide efficient examination and traversal of the fundamental array structure, on disk or in memory. for i=10000:1:12345 set sqtable(i)=i*i set address(\"Smith\",\"Daniel\")=\"dpbsmith@world.std.com\" 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 : ^abc, ^def . 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, @VBL can be used, and effectively substitutes the contents of VBL into another MUMPS statement. sets the variable ABC to 123. 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. $PIECE(STRINGVAR,\"^\",3) means the \"third caret-separated piece of .\" The piece function can also appear as an assignment (SET command) target. $PIECE(\"world.std.com\",\".\",2) yields . After SET X=\"dpbsmith@world.std.com\" , SET $P(X,\"@\",1)=\"office\" causes X to become \"office@world.std.com\" (note that is equivalent to 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.) Set stuff(6)=\"xyz\",stuff(10)=26,stuff(15)=\"\" $Order(stuff(\"\")) yields , $Order(stuff(6)) yields , $Order(stuff(8)) yields , $Order(stuff(10)) yields , $Order(stuff(15)) yields . Set i=\"\" For Set i=$O(stuff(i)) Quit:i=\"\" Write !,i,10,stuff(i) Here, the argument-less repeats until stopped by a terminating . This line prints a table of and where is successively 6, 10, and 15. For iterating the database, the Order function returns the next key to use. 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\" 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 SET ^|\"DENVER\"|A(1000)=\"Foo\" ) , which can allow you to access data on remote machines. 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: 2 + 3 is an error, and must be written 2+3 . All operators have the same precedence and are left-associative ( 2+3*10 evaluates to 50). The operators for \"less than or equal to\" and \"greater than or equal to\" are '> and ' (that is, the Boolean negation operator ' plus a strict comparison operator in the opposite direction), although some versions allow the use of the more standard and >= respectively. Periods ( . ) 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 $test . MUMPS 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 ( do ) and aliases each of the variables they wish to protect ( . new x,y ) 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\".",
  "categories": [
    "102876480",
    "106447263",
    "108862086",
    "108862124",
    "11060667",
    "22904391",
    "22906923",
    "22931866",
    "23059730",
    "23086790",
    "23603337",
    "24043274",
    "24745122",
    "24769763",
    "26069931",
    "26220375",
    "26955930",
    "27515961",
    "28493675",
    "3469171",
    "39178665",
    "41941517",
    "48128966",
    "55378886",
    "72914707",
    "72914716",
    "90989646"
  ],
  "license": "CC BY-SA 4.0",
  "source_uri": "https://en.wikipedia.org/w/index.php?oldid=1373529412",
  "content_hash": "",
  "created_at": null,
  "updated_at": 1788695639.0,
  "claims": [],
  "contradictions": [],
  "confidence": 0.6,
  "csl": {
    "id": "enwiki-001370059139",
    "type": "webpage",
    "title": "MUMPS",
    "author": [
      {
        "family": "Anticloud FZ LLE",
        "literal": "Anticloud FZ LLE"
      }
    ],
    "container-title": "encyclopegia.org",
    "publisher": "Anticloud FZ LLE",
    "publisher-place": "Dubai, United Arab Emirates",
    "URL": "https://encyclopegia.org/a/mumps",
    "issued": {
      "date-parts": [
        [
          2026,
          11,
          20
        ]
      ]
    },
    "accessed": {
      "date-parts": [
        [
          2026,
          11,
          20
        ]
      ]
    },
    "license": "CC BY-SA 4.0",
    "DOI": "eo1:enwiki-001370059139",
    "isBasedOn": "https://en.wikipedia.org/w/index.php?oldid=1373529412",
    "note": "Immutable snapshot enwiki-001370059139"
  }
}