PAPERAS

MUMPS ("Massachusetts General Hospital Utility Multi-Programming System"), o M, es un lenguaje de programación imperativo de alto nivel con un base de datos integrada de clave-valor de procesamiento de transacciones. Originalmente fue desarrollado en el Hospital General de Massachusetts para administrar los sistemas de información de laboratorios hospitalarios.

Desde entonces, la tecnología MUMPS se ha expandido como la base de datos predominante para los sistemas de información de salud y los registros electrónicos de salud en los Estados Unidos. Los sistemas de información basados en MUMPS se ejecutan en más del 40 % de los hospitales de los EE. UU., se ejecutan en todos los hospitales y clínicas federales de los EE. UU. y brindan servicios de información de salud a más del 54 % de los pacientes en los EE. UU.

Una característica única de la tecnología MUMPS es su lenguaje de base de datos integrado, que permite el acceso directo de lectura y escritura de alta velocidad al almacenamiento en disco permanente. Esto proporciona una estrecha integración de aplicaciones ilimitadas dentro de una única base de datos y proporciona un rendimiento y una fiabilidad extremadamente altos como sistema de procesamiento de transacciones en línea.

Historia

Décadas de 1960 y 1970 - Génesis

PAPERAS fue desarrollado por Neil Pappalardo, Robert Greenes y Curt Marble en el laboratorio del Dr. Octo Barnett en el Hospital General de Massachusetts (MGH) en Boston durante 1966 y 1967. Surgió de la frustración, durante una Los Institutos de Salud (NIH) respaldan el proyecto de sistemas de información hospitalaria en el MGH, con el desarrollo en lenguaje ensamblador en un PDP-1 de tiempo compartido por parte del contratista principal Bolt Beranek & Newman, Inc. (BBN). PAPERAS surgió de un "skunkworks" proyecto en MGH por Pappalardo, Marble y Greenes para crear un entorno de desarrollo alternativo. Como resultado de la demostración inicial de las capacidades, la propuesta del Dr. Barnett al NIH en 1967 para la renovación de la subvención del proyecto informático del hospital dio el paso audaz de proponer que el sistema se construya en MUMPS en el futuro, en lugar de confiar en el enfoque BBN. El proyecto fue financiado y comenzó la implementación seria del sistema en MUMPS.

El sistema MUMPS original fue, como Unix unos años más tarde, construido sobre un DEC PDP-7. Octo Barnett y Neil Pappalardo obtuvieron un PDP-9 compatible con versiones anteriores y comenzaron a usar MUMPS en el ciclo de admisión y en el informe de pruebas de laboratorio. MUMPS era entonces un lenguaje interpretado, pero incluso entonces, incorporó un sistema de archivo de base de datos jerárquico para estandarizar la interacción con los datos y las operaciones de disco abstractas para que solo las hiciera el propio lenguaje MUMPS. MUMPS también se usó en sus primeros días en un sistema experimental de entrada de notas de progreso clínico y un sistema de entrada de informes de radiología.

Algunos aspectos de las paperas se pueden rastrear desde JOSS de RAND Corporation hasta TELCOMP y STRINGCOMP de BBN. El equipo de MUMPS optó por incluir la portabilidad entre máquinas como objetivo de diseño.

Una característica avanzada del lenguaje MUMPS que no era ampliamente compatible con los sistemas operativos o el hardware informático de la época era la multitarea. Aunque el tiempo compartido en las computadoras centrales era cada vez más común en sistemas como Multics, la mayoría de las minicomputadoras no ejecutaban programas paralelos y los subprocesos no estaban disponibles en absoluto. Incluso en Mainframes, la variante de procesamiento por lotes donde un programa se ejecutaba hasta su finalización era la implementación más común para un sistema operativo de programación múltiple.

Pasaron algunos años hasta que se desarrolló Unix. La falta de hardware de administración de memoria también significaba que todo el procesamiento múltiple estaba plagado de la posibilidad de que un puntero de memoria pudiera cambiar algún otro proceso. Los programas MUMPS no tienen una forma estándar de referirse directamente a la memoria, en contraste con el lenguaje C, por lo que dado que la multitarea fue impuesta por el lenguaje, no por ningún programa escrito en el lenguaje, era imposible correr el riesgo que existía para otros sistemas

El sistema DEC MUMPS-15 de Dan Brevik se adaptó a un DEC PDP-15, donde vivió durante algún tiempo. Se instaló por primera vez en Health Data Management Systems de Denver en mayo de 1971. La portabilidad demostró ser útil y MUMPS recibió una subvención de investigación del gobierno, por lo que MUMPS se lanzó al dominio público, lo cual era un requisito para las subvenciones. MUMPS pronto se trasladó a una serie de otros sistemas, incluidos el popular DEC PDP-8, Data General Nova y en DEC PDP-11 y la minicomputadora Artronix PC12. La noticia sobre las PAPERAS se difundió principalmente a través de la comunidad médica y fue de uso generalizado, y a menudo se modificó localmente para sus propias necesidades.

Las versiones del sistema MUMPS fueron reescritas por los líderes técnicos Dennis "Dan" Brevik y Paul Stylos de DEC en 1970 y 1971. A principios de la década de 1970, había muchas y variadas implementaciones de MUMPS en una variedad de plataformas de hardware. Otra plataforma digna de mención fue Paul Stylos' DEC PAPERAS-11 en el PDP-11 y MIIS de MEDITECH. En el otoño de 1972, muchos usuarios de MUMPS asistieron a una conferencia en Boston que estandarizó el lenguaje entonces fragmentado y creó el Grupo de Usuarios de MUMPS y el Comité de Desarrollo de MUMPS (MDC) para hazlo Estos esfuerzos resultaron exitosos; un estándar se completó en 1974 y fue aprobado, el 15 de septiembre de 1977, como estándar ANSI, X11.1-1977. Casi al mismo tiempo, DEC lanzó el DSM-11 (Paperas Estándar Digital) para el PDP-11. Esta rápidamente dominó el mercado, y se convirtió en la implementación de referencia de la época. Además, InterSystems vendió ISM-11 para el PDP-11 (que era idéntico al DSM-11).

Década de 1980

A principios de la década de 1980, varios proveedores lanzaron al mercado plataformas basadas en MUMPS que cumplían con el estándar ANSI. Los más significativos fueron:

• Digital Equipment Corporation con DSM (MuMPS estándar digital). DSM-11 fue superada por VAX-11 DSM para el sistema operativo VMS, y que fue portado al Alfa en dos variantes: DSM for OpenVMS, y como DSM for Ultrix.
• InterSystems con ISM (InterSystems M) on VMS (M/VX), ISM-11 later M/11+ on the PDP-11 platform, 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 con una versión compilada llamada GT.M para AIX, HP-UX, UNIX y OpenVMS
• DataTree Inc. con un producto basado en PC Intel llamado DTM.
• Micronetics Design Corporation con una línea de productos llamada MSM. MSM-PC, MSM/386, MS-UNIX, MSM-NT, MSM/VM fo IBM, VAX/VMS platforms and OpenVMS Plataformas alfa.
• Consultores informáticos (más tarde renombrado MGlobal), una empresa con sede en Houston creada originalmente CCSM el 6800, luego 6809, y eventualmente un puerto a los 68000, que más tarde se convirtió en MacMUMPS, un producto basado en Mac OS. También trabajaban en el MGM Ejecución de MUMPS. MGlobal también portó su aplicación a la plataforma DOS. MGlobal MUMPS fue el primer MUMPS comercial para el PC IBM y la única implementación para el sistema Mac clásico.
• Tandem Computers desarrolló una implementación para sus ordenadores tolerantes a la falla.
• IBM vendió brevemente una implementación MUMPS llamada MUMPS/VM que funcionó como una máquina virtual en la parte superior de VM/370.

Este período también vio una actividad considerable de MDC. La segunda revisión de la norma ANSI para PAPERAS (X11.1-1984) fue aprobada el 15 de noviembre de 1984.

Década de 1990

• El 11 de noviembre de 1990 se aprobó la tercera revisión de la norma ANSI (X11.1-1990).
• En 1992 se adoptó la misma norma que la norma ISO 11756-1992. Utilización M como un nombre alternativo para el idioma fue aprobado alrededor del mismo tiempo.
• El 8 de diciembre de 1995, la cuarta revisión de la norma (X11.1-1995) fue aprobada por ANSI, y por ISO en 1999 como ISO 11756:1999, que también fue publicada por ANSI. El MDC finalizó una nueva revisión de la norma en 1998, pero esto no se ha presentado a ANSI para su aprobación.
• En 1999 se aprobó la última norma M (ISO-IEC 11756-1999). ISO volvió a confirmar esto en 2020. Junto con ISO/IEC 15851:1999, Open MUMPS Interconnect e ISO/IEC 15852:1999, MUMPS Windowing Application Programmers Interface.

Nombre

Años 2000

• Para el año 2000, el proveedor de middleware InterSystems se había convertido en el jugador dominante en el mercado de MUMPS con la compra de varios otros proveedores. Inicialmente adquirieron DataTree Inc. en 1993. El 30 de diciembre de 1994, InterSystems adquirió la línea de productos DSM de DEC. InterSystems consolidó estos productos en una sola línea de productos, marcando, en varias plataformas de hardware, como OpenM. En 1997, InterSystems lanzó un nuevo producto llamado Caché. Esto se basó en su producto ISM, pero con influencias de las otras implementaciones. Micronetics Design Corporation, en este momento #2 en el mercado, fue adquirida por InterSystems el 21 de junio de 1998. InterSystems sigue siendo el "Vendedor MSM dominante, DSM, ISM, DTM y la venta de desarrolladores Caché a M que escriben aplicaciones para una variedad de sistemas operativos. También Intersystems ya no usó el término M, ni siguió el estándar M.
• La implementación de GT.M de Greystone Corporation se vendió a Sanchez Computer Associates (ahora parte de FIS) a mediados de los 90. El 7 de noviembre de 2000, Sánchez hizo GT. M para Linux disponible bajo la licencia GPL y el 28 de octubre de 2005, GT. M for OpenVMS and Tru64 UNIX were also made available under the AGPL license. GT.M sigue estando disponible en otras plataformas UNIX bajo una licencia tradicional.
• Durante 2000, Ray Newman y otros lanzaron MUMPS V1, una implementación de MUMPS (inicialmente en FreeBSD) similar a DSM-11. MUMPS V1 ha sido portado a Linux, Mac OS X y Windows (usando Cygwin). Inicialmente sólo para la CPU x86, MUMPS V1 ahora ha sido portado a la Raspberry Pi.
• Publicado en abril de 2002 MSM derivado llamado M21 es ofrecido por la Real Compañía de Software de Rugby, Reino Unido.
• También hay varias implementaciones de código abierto de MUMPS, incluyendo algunos proyectos de investigación. El más notable es Mumps/II, por el Dr. Kevin O'Kane (Profesor Emeritus, Universidad del Norte de Iowa) y el proyecto de estudiantes. El Dr. O'Kane también ha portado el intérprete a Mac OS X.
• Uno de los creadores originales del lenguaje MUMPS, Neil Pappalardo, fundó una empresa llamada MEDITECHo en 1969. Extendieron y construyeron en el lenguaje MUMPS, nombrando el nuevo lenguaje MIIS (y más tarde, otro idioma llamado MAGIC). A diferencia de InterSystems, MEDITECH ya no vende middleware, por lo que MIIS y MAGIC ahora sólo se utilizan internamente en MEDITECH.
• Nuevo en el mercado desde 2022 es MiniM de Eugene Karataev

Al director ejecutivo de InterSystems no le gustó el nombre MUMPS y sintió que representaba un serio obstáculo de marketing. Por lo tanto, favorecer a M hasta cierto punto se identificó como una alineación con InterSystems. La disputa también reflejó la rivalidad entre organizaciones (la Asociación de Tecnología M, el Comité de Desarrollo de MUMPS, los Comités de Normas ANSI e ISO) en cuanto a quién determina el "oficial" nombre del idioma.

Una autoridad líder y autor de una implementación de MUMPS de código abierto, el profesor Kevin O'Kane, usa solo 'MUMPS'.

El estándar más reciente (ISO/IEC 11756:1999, reafirmado el 25 de junio de 2010), todavía menciona M y MUMPS como nombres oficialmente aceptados.

El Hospital General de Massachusetts registró "PAPERAS" como marca registrada en la USPTO el 28 de noviembre de 1971 y la renovó el 16 de noviembre de 1992, pero dejó que expirara el 30 de agosto de 2003.

Diseño

Resumen

MUMPS es un lenguaje destinado y diseñado para crear aplicaciones de bases de datos. Se incluyeron funciones de lenguaje secundario para ayudar a los programadores a crear aplicaciones utilizando recursos informáticos mínimos. Se interpretaron las implementaciones originales, aunque las implementaciones modernas pueden compilarse total o parcialmente. "programas" individuales se ejecuta en "particiones" de memoria. Las primeras particiones de memoria MUMPS estaban limitadas a 2048 bytes, por lo que la abreviatura agresiva ayudó en gran medida a la programación múltiple en hardware con recursos severamente limitados, porque más de un trabajo MUMPS podía caber en las memorias muy pequeñas existentes en el hardware en ese momento. La capacidad de proporcionar sistemas multiusuario fue otra característica del diseño del lenguaje. La palabra "Multi-Programming" en las siglas apunta a esto. Incluso las primeras máquinas que ejecutaban MUMPS admitían múltiples trabajos que se ejecutaban al mismo tiempo. Con el cambio de minicomputadoras a microcomputadoras unos años más tarde, incluso una "PC de un solo usuario" con una sola CPU de 8 bits y 16K o 64K de memoria podría admitir múltiples usuarios, quienes podrían conectarse desde terminales de visualización de video (no gráficos).

Dado que la memoria era limitada originalmente, el diseño del lenguaje para MUMPS valoraba un código muy conciso. Por lo tanto, cada comando o nombre de función de MUMPS podría abreviarse de una a tres letras de longitud, p. Quit (salir del programa) como Q, $P = $Piece, R = comando Read, $TR = función $Translate. Los espacios y los marcadores de final de línea son significativos en MUMPS porque el alcance de la línea promovió el mismo diseño de lenguaje conciso. Así, una sola línea de código de programa podría expresar, con pocos caracteres, una idea para la que otros lenguajes de programación podrían requerir de 5 a 10 veces más caracteres. La abreviatura era una característica común de los lenguajes diseñados en este período (por ejemplo, FOCAL-69, los primeros BASIC como Tiny BASIC, etc.). Un efecto secundario desafortunado de esto, junto con la necesidad inicial de escribir código minimalista, fue que los programadores de MUMPS habitualmente no comentaban el código y usaban muchas abreviaturas. Esto significaba que incluso un programador experto en MUMPS no podía simplemente hojear una página de código para ver su función, sino que tenía que analizarla línea por línea.

La interacción con la base de datos está integrada de forma transparente en el lenguaje. El lenguaje MUMPS proporciona una base de datos jerárquica formada por matrices dispersas persistentes, que implícitamente se "abre" para cada aplicación de PAPERAS. Todos los nombres de variables con el prefijo del carácter de intercalación (^) usarán almacenamiento permanente (en lugar de RAM), mantendrán sus valores después de que la aplicación salga y serán visibles (y modificables por) otras aplicaciones en ejecución. Las variables que utilizan este almacenamiento compartido y permanente se denominan Globales en MUMPS, porque el alcance de estas variables está "disponible globalmente" a todos los trabajos del sistema. El uso más reciente y más común del nombre "variables globales" en otros idiomas es un alcance más limitado de los nombres, debido al hecho de que las variables sin alcance son "globalmente" disponible para cualquier programa que se ejecute en el mismo proceso, pero no compartido entre múltiples procesos. El modo de almacenamiento MUMPS (es decir, globales almacenados como arreglos dispersos persistentes), le da a la base de datos MUMPS las características de una base de datos orientada a documentos.

Todos los nombres de variables que no tienen el prefijo del carácter de intercalación (^ ) son temporales y privados. Al igual que las variables globales, también tienen un modelo de almacenamiento jerárquico, pero solo están "disponibles localmente" a un solo trabajo, por eso se les llama "locales". Ambos "globales" y "locales" puede tener nodos secundarios (llamados subíndices en la terminología MUMPS). Los subíndices no se limitan a números: cualquier carácter ASCII o grupo de caracteres puede ser un identificador de subíndice. Si bien esto no es poco común para los lenguajes modernos como Perl o JavaScript, era una característica muy inusual a fines de la década de 1970. Esta capacidad no se implementó universalmente en los sistemas MUMPS antes del estándar ANSI de 1984, ya que el estándar solo requería subíndices canónicamente numéricos para ser permitidos. Por lo tanto, la variable denominada 'Coche' puede tener subíndices "Puerta", "Volante" y "Motor", cada uno de los cuales puede contener un valor y tener sus propios subíndices. La variable ^Car("Puerta")< /code> podría tener un subíndice de variable anidado de "Color" por ejemplo. Así, se podría decir

SET ^Car("Door", "Color")="BLUE"

para modificar un nodo secundario anidado de ^Car. En términos de PAPERAS, "Color" es el segundo subíndice de la variable ^Car (ambos los nombres de los nodos secundarios y los propios nodos secundarios también se denominan subíndices). Las variables jerárquicas son similares a los objetos con propiedades en muchos lenguajes orientados a objetos. Además, el diseño del lenguaje MUMPS requiere que todos los subíndices de las variables se mantengan automáticamente ordenados. Los subíndices numéricos (incluidos los números de coma flotante) se almacenan de menor a mayor. Todos los subíndices no numéricos se almacenan en orden alfabético después de los números. En la terminología de PAPERAS, esto es orden canónico. Al usar solo subíndices enteros no negativos, el programador de MUMPS puede emular el tipo de datos de matrices de otros lenguajes. Aunque MUMPS no ofrece de forma nativa un conjunto completo de funciones de DBMS, como esquemas obligatorios, se han creado varios sistemas de DBMS que brindan a los desarrolladores de aplicaciones funciones de base de datos de red, relacionales y de archivo sin formato.

Además, hay operadores incorporados que tratan una cadena delimitada (por ejemplo, valores separados por comas) como una matriz. Los primeros programadores de MUMPS a menudo almacenaban una estructura de información relacionada como una cadena delimitada, analizándola después de leerla; esto ahorró tiempo de acceso al disco y ofreció considerables ventajas de velocidad en algunos hardware.

MUMPS no tiene tipos de datos. Los números se pueden tratar como cadenas de dígitos, o las cadenas se pueden tratar como números mediante operadores numéricos (forzado, en la terminología MUMPS). Sin embargo, la coerción puede tener algunos efectos secundarios extraños. Por ejemplo, cuando se coacciona una cadena, el analizador convierte la mayor parte posible de la cadena (comenzando desde la izquierda) en un número y luego descarta el resto. Por lo tanto, la afirmación IF 20<"30 DUCKS" se evalúa como TRUE en MUMPS.

Otras funciones del lenguaje están destinadas a ayudar a las aplicaciones MUMPS a interactuar entre sí en un entorno multiusuario. Los bloqueos de bases de datos, los identificadores de procesos y la atomicidad de las transacciones de actualización de bases de datos son requisitos de las implementaciones estándar de MUMPS.

A diferencia de los lenguajes en las tradiciones C o Wirth, algunos caracteres de espacio entre declaraciones MUMPS son significativos. Un solo espacio separa un comando de su argumento, y un espacio, o nueva línea, separa cada argumento del siguiente token MUMPS. Los comandos que no toman argumentos (por ejemplo, ELSE) requieren dos espacios a continuación. El concepto es que un espacio separa el comando del argumento (inexistente), el siguiente separa el "argumento" del siguiente comando. Los saltos de línea también son significativos; un comando IF, ELSE o FOR procesa (u omite) todo lo demás hasta el final de la línea. Para hacer que esas declaraciones controlen varias líneas, debe usar el comando DO para crear un bloque de código.

¡Hola, mundo! ejemplo

Un simple "¡Hola, mundo!" programa en PAPERAS podría ser:

 ¡Hola, Mundo!

y se ejecutaría con el comando do ^hello después de haberlo guardado en el disco. Para la ejecución directa del código, una especie de "etiqueta" (cualquier cadena alfanumérica) en la primera posición de la línea del programa es necesaria para decirle al intérprete de paperas dónde comenzar la ejecución. Dado que MUMPS permite que los comandos se encadenen en la misma línea, y dado que los comandos se pueden abreviar en una sola letra, esta rutina podría hacerse más compacta:

¡Hola, Mundo!

El ',!' después de que el texto genera una nueva línea. Este código volvería a la indicación.

Características

ANSI X11.1-1995 brinda una descripción formal y completa del lenguaje; una versión comentada de este estándar está disponible en línea.

Las características del lenguaje incluyen:

Tipos de datos

Hay un tipo de datos universal, que se coacciona implícitamente a los tipos de datos de cadenas, enteros o de puntos flotantes como requiere el contexto.

Booleans (llamado Valores de la verdad en MUMPS)

En comandos IF y otra sintaxis que tiene expresiones evaluadas como condiciones, cualquier valor de cadena se evalúa como un valor numérico y, si eso es un valor no cero, entonces se interpreta como Verdadero. a cede 1 si a es menos que b, 0 de otro modo.

Declaraciones

Ninguno. Todas las variables se crean dinámicamente por primera vez un valor se asigna.

Líneas

son importantes entidades sintácticas, a diferencia de su estatus en los idiomas patrón en C o Pascal. Se admiten múltiples declaraciones por línea y son comunes. El alcance de cualquier IF, ELSE, y PARA El comando es "el resto de la línea actual".

Sensibilidad de caso

Comandos y funciones intrínsecas son insensibles. En cambio, los nombres y etiquetas variables son sensibles a los casos. No hay un significado especial para los convenios superiores vs. minúsculas y pocos seguidos ampliamente. El signo por ciento (%) es legal como primer carácter de variables y etiquetas.

Condiciones posteriores

la ejecución de casi cualquier comando se puede controlar siguiendo con un colon y una expresión de valor de verdad. SET:N<10 A="FOO" establece A a "FOO" si N es inferior a 10; DO:N>100 PRINTERR, realiza PRINTERR si N es mayor de 100. Esta construcción proporciona un condicional cuyo alcance es inferior a una línea completa.

Abreviatura

Puede abreviar casi todos los comandos y funciones nativas a uno, dos o tres caracteres.

Palabras reservadas

Ninguno. Como MUMPS interpreta el código fuente por contexto, no hay necesidad de palabras reservadas. Puede utilizar los nombres de los comandos de idiomas como variables, por lo que el siguiente es el código MUMPS perfectamente legal:

GREPTHIS()
NEW SET,NEW,THEN,IF,KILL,QUIT SET IF="KILL",SET="11",KILL="l1",QUIT="RETURN",THEN="KILL"
IF IF=THEN DO THEN
QUIT: $QUIT QUIT QUIT; (quit)
Entonces, si IF,SET divideKILL SET=SET+KILL QUIT

MUMPS se puede hacer más obfuscated utilizando la sintaxis del operador contratado, como se muestra en este ejemplo de terse derivado del ejemplo anterior:

GREPTHIS()
N S,N,T,I,K,Q S I="K",S="11",K="l1",Q="R",T="K"
I=T D T
Q:$Q Q Q
T I,S sensibleK S=S+K Q

Arrays

se crean dinámicamente, almacenados como árboles B, son escasas (es decir, utilizar casi ningún espacio para nodos desaparecidos), pueden utilizar cualquier número de subscriptos, y subscriptos pueden ser cadenas o numéricas (incluyendo punto flotante). Los rayos siempre se almacenan automáticamente en orden ordenado, por lo que nunca hay ninguna ocasión para ordenar, empacar, reordenar o reorganizar la base de datos. Funciones incorporadas como $DATA, $ORDER, $NEXT(deprecido) y $QUERY funciones proporcionan un examen y traversal eficientes de la estructura de matriz fundamental, en disco o en memoria.

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

arrays locales

los nombres variables que no comienzan con caret (es decir, "^") se almacenan en memoria por proceso, son privados al proceso de creación, y expiran cuando el proceso de creación termina. El almacenamiento disponible depende de la aplicación. Para aquellas implementaciones utilizando particiones, se limita al tamaño de partición (una pequeña partición podría ser de 32K). Para otras implementaciones, puede ser varios megabytes.

Global arrays

^abc, ^def. Estos se almacenan en disco, están disponibles para todos los procesos, y son persistentes cuando el proceso de creación termina. Los globales muy grandes (por ejemplo, cientos de gigabytes) son prácticos y eficientes en la mayoría de las implementaciones. Este es el principal mecanismo de base de datos de MUMPS. Se utiliza en lugar de llamar al sistema operativo para crear, escribir y leer archivos.

Indirection

en muchos contextos, @VBL puede ser utilizado, y sustituye eficazmente el contenido de VBL en otra declaración de MUMPS. SET XYZ="ABC" SET @XYZ=123 establece la variable ABC a 123. SET SUBROU="REPORT" DO @SUBROU realiza la subrutina llamada REPORT. Esta sustitución permite la evaluación perezosa y la obligatoriedad tardía, así como el equivalente operacional de "puntos" en otros idiomas.

Función de la pieza

Esto rompe variables en piezas segmentadas guiadas por una cadena de separador especificada por el usuario (a veces llamada "delimitador"). Aquellos que conocen a Awk encontrarán esto familiar. $PIECE(STRINGVAR,"^",3) significa la "tercera pieza separada de cuidado STRINGVAR." La función de la pieza también puede aparecer como un objetivo de asignación (comando SET).

$PIECE("world.std.com",".",2) rendimientos std.

Después

SET X="dpbsmith@world.std.com"

SET $P(X,"@",1)="office" hace que X se convierta en "office@world.std.com" (nota que $P equivale a $PIECE y podría ser escrito como tal).

Función de orden

Esta función trata su entrada como estructura, y encuentra el siguiente índice que existe que tiene la misma estructura excepto el último subscript. Devuelve el valor clasificado que se ordena después del que se da como entrada. (Esto trata la referencia del array como datos accesibles a los contenidos en lugar de una dirección de un valor.)

Set things(6)="xyz",stuff(10)=26,stuff(15)="

$Order(stuff("")) rendimientos 6, $Order(stuff(6)) rendimientos 10, $Order(stuff(8)) rendimientos 10, $Order(stuff(10)) rendimientos 15, $Order(stuff(15)) rendimientos ".

Set i="" Para Set i=$O(stuff(i)) Quit:i="" Escribir !,i,10,stuff(i)

Aquí, sin argumentos Para repeticiones hasta que se detuvo Qui. Esta línea imprime una tabla de i y stuff(i) Donde i es sucesivamente 6, 10 y 15.

Para iterar la base de datos, la función Order devuelve la siguiente clave para usar.

GTM contactos n="
(^nodex(n))
GTM confíazwr n
Edificio N=
(^nodex(n))
GTM confíazwr n
n="nombre:gd"
(^nodex(n))
GTM confíazwr n
################################################################################################################################################################################################################################################################

MUMPS admite múltiples usuarios y procesos simultáneos incluso cuando el sistema operativo subyacente no lo hace (por ejemplo, MS-DOS). Además, existe la posibilidad de especificar un entorno para una variable, como especificar un nombre de máquina en una variable (como en SET ^|"DENVER"|A(1000)="Foo"), que puede permitirle acceder a datos en máquinas remotas.

Crítica

Algunos aspectos de la sintaxis de MUMPS difieren mucho de la de los idiomas más modernos, lo que puede causar confusión, aunque esos aspectos varían entre las diferentes versiones del idioma. En algunas versiones, no se permiten espacios en blanco dentro de las expresiones, ya que finaliza una declaración: 2 + 3 es un error y debe escribirse 2+3. Todos los operadores tienen la misma precedencia y son asociativos a la izquierda (2+3*10 se evalúa como 50). Los operadores para "menor o igual que" y "mayor o igual que" son '> y '< (es decir, el operador de negación booleano ' más un estricto operador de comparación en la dirección opuesta), aunque algunas versiones permiten el uso de los más estándar <= y >= respectivamente. Los puntos (.) se usan para sangrar las líneas en un bloque DO, no espacios en blanco. El comando ELSE no necesita un IF correspondiente, ya que opera inspeccionando el valor en la variable de sistema integrada $test.

Las reglas de alcance de MUMPS son más permisivas que otros lenguajes modernos. Las variables locales declaradas tienen un alcance utilizando la pila. Una rutina normalmente puede ver todos los locales declarados de las rutinas debajo de ella en la pila de llamadas, y las rutinas no pueden evitar que las rutinas a las que llaman modifiquen sus locales declarados, a menos que la persona que llama cree manualmente un nuevo nivel de pila (do) y crea un alias para cada una de las variables que desea proteger (. new x,y) antes de llamar a cualquier rutina secundaria. Por el contrario, las variables no declaradas (variables creadas al usarlas, en lugar de la declaración) están en el alcance de todas las rutinas que se ejecutan en el mismo proceso y permanecen en el alcance hasta que el programa finaliza.

Debido a que las referencias de la base de datos MUMPS difieren de las referencias de variables internas solo en el prefijo de intercalación, es peligrosamente fácil editar la base de datos sin querer, o incluso eliminar una "tabla" de la base de datos.

Usuarios

El Departamento de Asuntos de Veteranos de EE. UU. (anteriormente, la Administración de Veteranos) fue uno de los primeros en adoptar el lenguaje MUMPS. Su trabajo de desarrollo (y las contribuciones posteriores al código base de la aplicación MUMPS gratuita) fue una influencia para muchos usuarios médicos en todo el mundo. En 1995, Asuntos de Veteranos' el sistema de admisión/seguimiento/alta de pacientes, el programa informático hospitalario descentralizado (DHCP) recibió el premio Computerworld Smithsonian al mejor uso de la tecnología de la información en medicina. En julio de 2006, el Departamento de Asuntos de Veteranos (VA)/Administración de Salud de Veteranos (VHA) recibió el Premio a las Innovaciones en el Gobierno Estadounidense presentado por el Instituto Ash de la Escuela de Gobierno John F. Kennedy de la Universidad de Harvard por su extensión de DHCP en la Arquitectura de tecnología y sistemas de información de salud para veteranos (VistA). Casi todo el sistema hospitalario VA en los Estados Unidos, el Servicio de Salud Indígena y partes importantes del sistema hospitalario CHCS del Departamento de Defensa utilizan bases de datos MUMPS para el seguimiento de datos clínicos.

Otras empresas de TI de atención médica que utilizan MUMPS incluyen:

• épica
• MEDITECH
• GE Healthcare (anteriormente IDX Systems y Centricity)
• AmeriPath (parte de Diagnósticos de Búsqueda)
• Care Centric
• Allscripts
• Coventry Health Atención
• EMIS Salud
• Sunquest Information Systems (antes Misys Healthcare).
• Netsmart

Muchos laboratorios de referencia, como DASA, Quest Diagnostics y Dynacare, utilizan el software MUMPS escrito o basado en el código de Antrim Corporation. Antrim fue comprado por Misys Healthcare (ahora Sunquest Information Systems) en 2001.

MUMPS también se usa ampliamente en aplicaciones financieras. MUMPS obtuvo un seguimiento temprano en el sector financiero y está en uso en muchos bancos y cooperativas de crédito. Es utilizado por TD Ameritrade, así como por el Banco de Inglaterra y el Banco Barclays.

Implementaciones

Desde 2005, las implementaciones más populares de MUMPS han sido Greystone Technology MUMPS (GT.M) de Fidelity National Information Services y Caché, de Intersystems Corporation. La Agencia Espacial Europea anunció el 13 de mayo de 2010 que utilizará la base de datos InterSystems Caché para apoyar la misión Gaia. Esta misión tiene como objetivo cartografiar la Vía Láctea con una precisión sin precedentes. InterSystems está en proceso de eliminar Caché a favor de Iris.

Otras implementaciones actuales incluyen:

• M21
• YottaDB
• MiniM
• Referencia Standard M
• FreeM