MUMPS

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
MUMPS
Paradigma Programação procedural
Surgido em 1966
Última versão ANSI X11.1-1995 (08 de dezembro de 1995 (19 anos))
Criado por Neil Pappalardo
Estilo de tipagem: typeless
Influenciada por JOSS
Influenciou PSL, Caché ObjectScript

MUMPS, sigla para Massachusetts General Hospital Utility Multi-Programming System (Sistema de multiprogramação do Hospital Geral de Massachusetts) é uma linguagem de programação procedural e normalmente interpretada criada no final da década de 1960, originalmente para uso na área da saúde. Ela foi projetada para a produção de aplicações multiusuário com orientação ao banco de dados. Foi criada antes da linguagem C e antes da maior parte das linguagens populares que estão em uso hoje, além de ter uma sintaxe bastante incomum. Sua característica mais singular e diferenciadora é o "built-in" de banco de dados, permitindo acesso de alto nível de armazenamento em disco utilizando variáveis simples e simbólicas ​​do programa, semelhantes às variáveis ​​utilizadas pela maioria das linguagens para acessar a memória principal.

Ela foi amplamente adotada na década de 1970 e no início da década de 1980 nos bancos de dados/sistemas clínico e financeiro, continuando a ser usada por muitos dos mesmos clientes hoje. Atualmente é usada em sistemas de registos de saúde eletrônicos, assim como por várias redes bancárias e comércio online/serviços de investimento.

A linguagem oferece uma ampla gama de recursos a baixo custo, incluindo funções típicas de SGBDs. Muitos de seus recursos (como matrizes esparsas e o único tipo de dado ser strings) vem de sua criação original para tratar de dados clínicos.

MUMPS deu origem ao banco de dados Caché.

História[editar | editar código-fonte]

MUMPS foi desenvolvido por Neil Pappalardo e alguns colegas no laboratório de animais de Dr. Octo Barnett, em Boston, no Massachusetts General Hospital (MGH) em 1966 e 1967. Originalmente, o sistema MUMPS foi, como o Unix seria alguns anos depois, construído em um DEC PDP-7 de reposição.

Octo Barnett e Neil Pappalardo também estavam envolvidos com o planejamento do MGH para um Hospital Information System (Sistema de Informações Hospitalares), em que obtiveram um PDP-9 compatível e começaram a utilizar o MUMPS no ciclo de admissões e em relatórios de exames de laboratório. MUMPS era então uma linguagem interpretada mas, mesmo assim, incorporou um sistema de arquivos de banco de dados hierárquico para padronizar a interação com os dados. Alguns aspectos de MUMPS podem ser traçados a partir de JOSS Rand Corporation, através de Telcomp BBN e STRINGCOMP. A equipe MUMPS deliberadamente optou por incluir a portabilidade entre máquinas como um objetivo do projeto. Outro aspecto, pouco suportado para as máquinas da época, em sistemas operacionais ou em equipamentos de informática, foi o multitasking (multitarefa), que também foi construído na própria linguagem.

A portabilidade logo foi útil, uma vez que o MUMPS foi logo adaptado para um DEC PDP-15, onde viveu durante algum tempo. MUMPS foi desenvolvido com o apoio de uma bolsa de pesquisa do governo e, assim, MUMPS foi liberado para o domínio público (não sendo mais um requisito para bolsas), sendo rapidamente portado para uma série de outros sistemas, incluindo o popular DEC PDP-8, o Data General Nova, o DEC PDP-11 e o Artronix PC12 minicomputer. O MUMPS encontrava-se espalhado principalmente na comunidade médica, em que, no início da década de 1970, estava difundido, sendo muitas vezes modificado localmente para suas próprias necessidades.

No início dos anos 1970, havia muitas implementações variadas de MUMPS em uma variedade de plataformas de hardware. O mais comum era DEC's MUMPS-11 sobre o PDP-11, e MIIS da MEDITECH. Em 1972, muitos usuários MUMPS participaram de uma conferência que padronizou a então fraturada linguagem, criando, para isso, o MUMPS Users Group (Grupo de usuários MUMPS) e MUMPS Development Committee (MDC) (Comissão de Desenvolvimento MUMPS). Estes esforços foram bem sucedidos, sendo que um padrão foi criado em 1974 e aprovado em 1977, assim como o padrão ANSI, X11.1-1977. Por volta da mesma época, DEC lançou DSM-11 (Digital Standard MUMPS) para o PDP-11. Isso dominou rapidamente o mercado e tornou-se uma referência de implementação.

Durante o início dos anos 1980, vários fornecedores trouxeram plataformas baseadas em MUMPS que atendiam o padrão ANSI para o mercado. Os mais significativos foram Digital Equipment Corporation com DSM (Digital Standard MUMPS), InterSystems Com ISM (InterSystems M) no VMS e UNIX, e M/11+ na plataforma PDP-11. Outras empresas fizeram implementações importantes para o MUMPS:

  • Greystone Technology Corporation com uma versão compilada chamada GT.M;
  • Datatree Inc. com um produto de PC baseado em Intel chamado DTM;
  • Micronetics Design Corporation com uma linha de produtos chamada MSM para plataformas UNIX e PC Intel (mais tarde portado para o sistema operacional VM da IBM, para as plataformas VAX/VMS e para Alpha-VMS)
  • Comp Consultants (Mais tarde, renomeada MGlobal), uma empresa com sede em Houston em que foi originalmente criado o CCSM em 6800, depois 6809 processadores e, eventualmente, uma porta para o 68000, que mais tarde tornou-se MacMUMPS, um produto baseado em Mac OS.

O MUMPS MGlobal foi o primeiro MUMPS comercial para o IBM PC e a única implementação para o Mac. DSM-11 foi substituído pelo VAX/DSM para a plataforma VAX/VMS, sendo portado para o Alpha em duas variantes: DSM para OpenVMS e DSM para Ultrix.

Neste período também houve uma considerável atividade MDC. A segunda revisão do padrão ANSI para MUMPS (X11.1-1984) foi aprovada em 15 de novembro de 1984. Em 11 de novembro de 1990, o terceira revisão do padrão ANSI (X11.1-1990) foi aprovada e em 1992, o mesmo padrão também foi adotado como padrão ISO 11756-1992. O uso de M como um nome alternativo para a linguagem foi aprovado na mesma época, devido a associação de MUMPS com a parotidite infecciosa, doença popularmente denominada caxumba, sendo a tecnologia MUMPS nomeada Tecnologia M. Em 8 de dezembro de 1995, a quarta revisão da norma (X11.1-1995) foi aprovada pela ANSI e pela ISO em 1999 como ISO 11756-1999. O MDC finalizou uma nova revisão da norma em 1998, mas isso não foi apresentado ao ANSI para aprovação. Em 6 de janeiro de 2005 e depois novamente em 25 de junho de 2010, a ISO reafirmou seus padrões MUMPS relacionados: ISO/IEC 11756:1999, language standard, ISO/IEC 15851:1999, Open MUMPS Interconnect and ISO/IEC 15852:1999, MUMPS Windowing Application Programmers Interface.

Em 2000, o InterSystems, fornecedor de middleware, tornou-se a empresa dominante no mercado MUMPS com a compra de vários outros fornecedores. Inicialmente, eles adquiriram o DataTree Inc. no início da década de 1990. Em 30 de dezembro de 1995, a InterSystems adquiriu a linha de produtos da DSM da DEC. A InterSystems consolidou esses produtos em uma única linha de produtos, marcando-os em diversas plataformas de hardware, como OpenM. Em 1997, a InterSystems se consolidou como empresa dominante no mercado ao lançar um sucessor unificado chamado Caché. Isto foi baseado em seu produto ISM, porém com influências de outras implementações. Assim, a InterSystems permanece até hoje como o fornecedor MUMPS dominante, vendendo o Caché para desenvolvedores MUMPS que implementam aplicativos para uma variedade de sistemas operacionais.

Também em 2000, Ray Newman e outros mais lançaram o MUMPS V1, uma implementação de MUMPS (inicialmente no FreeBSD) semelhante ao DSM-11. O MUMPS V1 já havia sido portado para o Linux, OS X e Windows (através do Cygwin) desde então. Feito inicialmente para uma CPU x86, o MUMPS V1 agora já foi portado até para o Raspberry Pi.

A mais recente implementação de MUMPS foi lançada em abril de 2002. Trata-se de um derivado do MSM, chamado M21, da Real Software Company of Rugby, UK.

Existem também várias implementações open source (código aberto) de MUMPS, incluindo alguns projetos de pesquisa. A mais notável delas é a MUMPS/II do Professor Kevin O'Kane (agora na Universidade de Iowa), o qual também portou o projeto para o Mac OS X.

Um dos criadores originais da linguagem MUMPS, Neil Pappalardo, logo fundaram uma empresa chamada MEDITECH. A linguagem foi estendida melhorada, nomeando uma nova linguagem MIIS (e logo mais, uma outra chamada MAGIC). Ao contrário da InterSystems, MEDITECH não vende middleware, sendo que essas duas linguagens são apenas usadas internamente na MEDITECH.

Usuários Atuais de aplicações de MUMPS[editar | editar código-fonte]

O U.S. Department of Veterans Affairs (Departamento de Assuntos de Veteranos dos EUA e antes chamado de Administração de Veteranos) foi um dos principais entre os primeiros que adotaram a linguagem MUMPS. Seu trabalho de desenvolvimento (e contribuições subsequentes para a livre aplicação de código base MUMPS) foi uma influência em muitos usuários médicos em todo o mundo. Em 1995, o sistema de admissão/rastreamento/descarregamento do paciente do Veterans Affairs, o Decentralized Hospital Computer Program (DHCP) foi o vencedor do prêmio Computerworld Smithsonian pelo melhor uso da Tecnologia da Informação na medicina. Em julho de 2006, o Department of Veterans Affairs foi o ganhador do Prêmio de Inovações em Governo Americano apresentado pelo Ash Institute da John F. Kennedy School of Government da Universidade de Harvard por sua extensão de DHCP para os Sistemas de Informação de Saúde dos Veteranos e Arquitetura Tecnologia (VistA). Quase todo o sistema hospitalar VA dos Estados Unidos, do Serviço de Saúde Indiana e da maior parte do Sistema Hospitalar do Departamento de Defesa CHCS usam banco de dados MUMPS para o rastreamento de dados clínicos. Coventry Healthcare e Massachusetts Hospital também foram relatados por usar MUMPS.

Entre as grandes empresas que hoje usam MUMPS, estão a AmeriPath, Centric Care, Sistemas Epic, EMIS, Partners HealthCare, MEDITECH, e GE Healthcare (originalmente chamado de IDX Systems e Centricity). Vários laboratórios de referência, como a DASA, Quest Diagnostics e Dynacare, utilizam softwares escritos em MUMPS.

MUMPS também é muito utilizado em aplicações financeiras. As aplicações em MUMPS estão em uso em vários bancos e cooperativas de crédito. Também é usado na Ameritrade, o maior serviço online de comércio dos EUA, com mais de 12 bilhões de transações por dia, assim como o Banco da Inglaterra, Banco Barclays e outros.

Desde 2005, o uso de MUMPS é realizado através da GT.M ou InterSystems Caché. Este último obteve sucesso ao ingressar em novos mercados, como o de telecomunicações, além de mercados já existentes. Além disso, A Agência Espacial Européia anunciou dia 13 de maio de 2010 que irá utilizar MUMPS para apoiar a Missão Espacial Gaia.

Visão Geral[editar | editar código-fonte]

MUMPS é uma linguagem destinada e projetada para construir aplicações de banco de dados. Foram incluídos recursos de linguagem secundários para ajudar os programadores a criar aplicações utilizando recursos de computação mínimos. No MUMPS, programas individuais são executados em partições de memória. As primeiras partições de memória do MUMPS foram limitadas a 2048 bytes, uma vez que essa severa abreviação facilitou o multiprocessamento apesar dos recursos de hardware limitados, permitindo que ao menos mais de um trabalho em MUMPS pudesse caber nas pequenas memórias existentes no hardware da época, além de permitir também a capacidade de fornecer sistemas multiusuário. Até mesmo as primeiras máquinas que executaram MUMPS suportaram múltiplas tarefas executando simultaneamente. Com a mudança de minicomputadores para microcomputadores alguns anos depois, até mesmo um PC de um único usuário com uma CPU de 8-bits com 16KB ou 64KB de memória poderia suportar múltiplos usuários, porém rodando no modo em linha de comando (sem qualquer interface gráfica de usuário).

Como a memória era originalmente pequena, o projeto da linguagem do código MUMPS foi muito valorizada. Assim, todos os comandos e funções da linguagem poderiam ser abreviados, como o comando QUIT (sair), podendo ser utilizado como Q, função $PIECE como $P, READ como R ou função $TRANSLATE como $TR. Os espaços e os marcadores de fim de linha são significativos em MUMPS pelo fato do escopo da linha promover um design conciso da linguagem. Desta forma, apenas uma linha inteira de código poderia expressar uma ideia que outras linguagens poderiam facilmente precisar de 5 ou até 10 vezes mais caracteres para expressar essa mesma ideia. Essa abreviatura foi uma característica muito comum entre as linguagens projetadas nessa época (como FOCAL-69, as primeiras versões de BASICs, etc). Um dos principais problemas disso era que, com a necessidade de escrever um código minimalista, os programadores não formavam o hábito de utilizar comentários no código, sendo que mesmo um programador MUMPS experiente não conseguiria ver a função de um código sem ter que analisá-lo linha por linha.

A interação com o banco de dados é bastante transparente dentro da construção da linguagem. A linguagem MUMPS fornece uma base de dados hierárquica composta de arrays persistentes e esparsas, semelhante a uma estrutura em árvore. Todos os nomes de variáveis com prefixo do caractere circunflexo ("^") são armazenados no banco de dados ao invés de ficarem na memória RAM, mantendo seus valores após saídas de aplicações e sendo visível e modificável por outras aplicações em execução. Essas variáveis que utilizam esse armazenamento compartilhado e permanente são chamadas de Globais no MUMPS, uma vez que o escopo dessas variáveis é "globalmente disponível" para todas as aplicações do sistema. O uso mais recente e mais comum do nome "variáveis ​​globais" em outras linguagens é um escopo mais limitado de nomes, vindo do fato de que variáveis sem escopo são "globalmente" disponíveis para qualquer programa em execução no mesmo processo, porém não compartilhadas entre os múltiplos processos. O modo de armazenamento do MUMPS (Globais armazenadas como arrays) dá ao banco de dados MUMPS as características de uma base de dados orientada a documentos.

Todos os nomes de variáveis que não prefixam com o caractere de acento circunflexo ("^") pertencem a variáveis temporárias e privadas. Assim como as variáveis globais, elas também tem um modelo de armazenamento hierárquico, porém são apenas "localmente disponíveis" para uma única aplicação, sendo chamadas de "locais". Tanto as globais como as locais podem ter nós filhas (chamados de "Subscripts" ou "índices" no MUMPS), em que não são limitadas apenas a números: qualquer caractere ou grupo de [[|caractere|caracteres]] da tabela ASCII pode ser um identificador de índice. Apesar disso não ser incomum para linguagens mais modernas como Perl ou JavaScript, essa foi uma característica bastante incomum no final da década de 1970. Porém, esse recurso foi apenas universalmente implementado nos sistemas MUMPS depois do padrão ANSI de 1984, em que apenas valores numéricos para índices eram exigidos pela norma. Citando um exemplo, uma variável chamada "Carro" pode ter os índices "Porta", "Volante" e "Motor", sendo que cada um dos quais podem conter mais índices próprios. O ^Carro("Porta") poderia ter um índice para uma variável "Cor", como no exemplo:

Set ^Carro("Porta","Cor")="AZUL"
S ^Carro("Porta","Motor")="2.0"

Em termos do MUMPS, "Cor" é o 2º índice (ou nível) da variável global ^Carro (ambos os nomes das nós-filhas e as nós-filhas próprias também são chamados de índices). As variáveis hierárquicas do MUMPS são similares aos objetos das linguagens orientadas a objetos. Além disso, o MUMPS exige que todos os índices das variáveis sejam mantidos em ordem de classificação. Índices númericos, por exemplo, são armazenados do menor para o maior (mesmo utilizando números de ponto flutuante), já os índices não-numéricos são armazenados em ordem alfabética, após os números. Usando apenas números inteiros não-negativos, o programador MUMPS pode emular os [[|array|arrays]] de dados de outras linguagens.

Além disso, existem operadores internos que tratam uma string delimitada (por exemplo, valores separados por vírgula) como um array. Os primeiros programadores de MUMPS, muitas vezes, armazenavam uma estrutura de informações relacionadas como uma string relacionada, analisando-a depois de ela ser lida, o que poupou tempo de acesso em disco e ofereceu uma considerável vantagem em termos de velocidade em relação ao hardware.

O MUMPS não possui nenhum tipo de dados. Números podem ser tratados como uma string de dígitos ou strings podem ser tratadas como números e operadores numéricos. Porém, isso pode causar alguns efeitos colaterais um tanto estranhos. Por exemplo: quando uma string é comparada em um comando IF, por exemplo, com um número inteiro, são considerados para a análise apenas os caracteres numéricos do início (do lado esquerdo) da string, sendo descartado o resto.

IF 20<"30 COISAS"

O resultado desta declaração de IF é avaliada como VERDADEIRA (True), uma vez que a string "30 COISAS" é convertida para "30". Deve-se notar que o mesmo não aconteceria se o valor numérico ficasse no meio ou no final (à direita) da string como "COISAS 30", sendo que esta seria convertida para o valor zero (0).

Outros recursos da linguagem são destinados a ajudar as aplicações de MUMPS interagirem entre elas mesmas em um ambiente multiusuário. Bloqueios de banco de dados, identificadores de processo e índice das transações de atualização de banco de dados são todos necessários para o padrão de implementações de MUMPS.

Em contraste com outras linguagens tradicionais como C ou Pascal, os caracteres de espaço entre as declarações de MUMPS são bastante significantes. Um único espaço deve separar um comando de seu argumento e um novo espaço, ou uma nova linha, deve separar o argumento escrito de um novo comando MUMPS. Existem comandos quem não devem receber argumentos (como o comando ELSE), logo, estes exigem exatamente dois espaços para o próximo comando. O conceito é que um espaço separa um comando de seu argumento (não-existente) e o outro espaço separa este "argumento" do próximo comando. As novas linhas também são bastante significantes: comandos como IF, ELSE ou FOR apenas processam comandos que estiverem até o fim da mesma linha. Porém, para se poder controlar várias linhas através desses comandos citados, deve-se usar o comando DO para criar um bloco de código.

Exemplo "Hello World!"[editar | editar código-fonte]

Um simples programa Hello World em MUMPS pode ser escrito deste modo:

Hello()                      ; Nome da label 
    Write "Hello, World!",!  ; Comando Write
    Quit                     ; Comando Quit

Este programa simples pode ser executado de uma linha de comando MUMPS com o comando: 'Do ^Hello()'. Como o MUMPS permite a escrita de vários comandos em uma mesma linha, permitindo também abreviar o nome dos comandos, o mesmo programa poderia ser escrito desta forma:

Hello() W "Hello, World!",! Q

O ',!' depois do texto serve para gerar uma nova linha. O 'QUIT' não é estritamente necessário no fim de uma Label (funciona como uma função, porém não há retorno de valores) como essa, porém é de boa prática de programação caso outras labels abaixo de 'Hello()' sejam acrescentadas no código. Além disso, o caractere "ponto e vírgula" (";") tem a utilidade de descrever comentários durante o código, como no primeiro exemplo do programa "Hello World!".

Características Diferenciais[editar | editar código-fonte]

O objetivo deste sumário é dar aos programadores familiarizados com outras linguagens uma ideia de como MUMPS funciona, explicando suas principais diferenças em relação a outras linguagens.

Tipos de Dados: Há apenas um tipo de dados universal, o qual funciona com uma conversão implícita para string, número inteiro e número de ponto flutuante, realizando a conversão de acordo com o contexto do código.

Valor Booleano: Nos comandos IF e outra sintaxe que expressa valores de condição, as strings são convertidas para valores numéricos e o único valor numérico que representa a condição FALSA é o zero (0), sendo que qualquer outro representa a condição VERDADEIRA.

Declarações: Nenhuma declaração de variáveis é necessária. Todas elas são dinamicamente criadas no momento que lhe são atribuídas algum valor.

Linhas: São entidades sintáticas importantes, diferentemente de linguagens como C ou Pascal. São permitidos múltiplos comandos em uma mesma linha e o escopo dos comandos IF, ELSE e FOR são limitados ao seu uso em apenas uma linha.

Case Sensitive: Comandos e funções intrínsecas não possuem sensibilidade de letras maiúsculas ou minúsculas. Porém, os nomes de variáveis e labels a possuem.

Pós-Condicionais: A execução de quase todos os comandos podem ser controlados quando seguidos do caractere "dois pontos" (":") seguido também de uma condição para a execução do comando. Por exemplo, no código SET:N<10 X="Foo", a variável X receberá a string "Foo" caso a condição N<10 seja verdadeira.

Abreviação: É possível abreviar praticamente todos os comandos e funções nativas para até 3 caracteres.

Palavras Reservadas: Não há nenhuma. O MUMPS interpreta o código fonte pelo contexto, logo não há necessidade para o uso de palavras reservadas.

Arrays: São criadas dinamicamente, classificadas como Árvores B, podem ter qualquer número de níveis ou subscripts, sendo que os índices podem ser strings ou valores numéricos, números inteiros ou pontos flutuantes. Os arrays são automaticamente armazenados em ordem numérica seguida da ordem alfabética. A manipulação dos arrays podem ser dadas através de funções nativas como $DATA, $ORDER, $NEXT (obsoleta) e $QUERY.

Arrays Locais: São todas as variáveis as quais o nome não começa com o caractere acento circunflexo ("^"). Elas são armazenadas na memória, são privadas a uma determinada aplicação e são excluídas automaticamente quando o processo da aplicação finaliza.

Arrays Globais: São todas as variáveis as quais o nome começa com o caractere acento circunflexo ("^"). Elas são armazenadas no disco, estão disponíveis para todos os processos e aplicações e continuam existindo após o processo ser encerrado. Grandes globais (de até centenas de GBytes são práticas e bastante eficientes na maior parte das implementações.

Indireção: A indireção é realizada através do caractere "arroba" ("@") posicionado no início do nome de uma variável. A indireção pode ser usada de forma a atribuir o conteúdo de uma variável com algum valor, de forma ao conteúdo dessa variável se tornar outra variável. Segue um exemplo:

Set XYZ="ABC"
Set @XYZ="123"

Este trecho código irá atribuir o valor "123" a uma nova variável nomeada "ABC".

Função 'Piece': Esta função nativa serve para quebrar o conteúdo de uma variável em pedaços, utilizando uma string ou caractere separador específico (chamado também de "delimitador"). Segue um exemplo:

Set DATA="15/11/1997"
Set DIA=$PIECE(DATA,"/",1)
Set MES=$P(DATA,"/",2)
Set ANO=$P(DATA,"/",3)

Neste trecho de código, uma data é atribuída à variável DATA com as informações separadas pelo caractere "/". Logo, o primeiro piece (ou pedaço) pode ser obtido para armazenar apenas o valor do dia, o segundo para o valor do mes e o terceiro para o ano.

Função 'Order': Esta função nativa trata a entrada da estrutura, encontrando o próximo índice existente o qual possui a mesma estrutura exceto pelo último subscript. A função retorna o próximo valor da classificação ordenada em relação ao valor de entrada. Segue um exemplo:

Set EXEMPLO(1)=A
Set EXEMPLO(2)=B
Set EXEMPLO(3)=C
Write $O(EXEMPLO("")) ; Imprime: 1
Write $O(EXEMPLO(2)) ; Imprime: 3
Write $O(EXEMPLO(3)) ; Imprime: "" (vazio)

Na função $ORDER, uma string nula ("") tem a função de identificar o início e o fim de uma ordenação ou classificação.

Multiusuário/Multiprocessamento: O MUMPS suporta processos e usuários múltiplos e simultâneos mesmo quando o sistema operacional não os suporta (como no caso do MS-DOS). Além disso, existe a possibilidade de especificar o ambiente para uma variável, especificando assim o nome da máquina em uma variável (como em Set ^|"DENVER"|A(1000)="Foo"), permitindo o acesso aos dados de máquinas remotas.

Para uma lista do restante dos comandos, funções nativas, operadores e variáveis especiais, veja outros links:

  • Documentação MUMPS, com descrição e exemplos de comandos, funções, variáveis especiais e operadores.

Determinação de Hora/Data Padrão[editar | editar código-fonte]

No MUMPS, a data e hora atual é contida em uma variável especial do sistema, o $H (abreviação para $HOROLOG). Trata-se de um par de números inteiros separados por uma vírgula (54321,12345). Os números à esquerda da vírgula representam o número de dias corridos desde o dia 31 de dezembro de 1840, sendo que, por exemplo, o dia número 1 seria então o dia 1 de janeiro de 1841. Já os números à direita da vírgula correspondem ao número de segundos corridos desde à meia-noite.

Exemplo de Programa[editar | editar código-fonte]

Este primeiro exemplo tem por objetivo simplesmente formar um triângulo de tamanho N (número digitado pelo usuário) utilizando vários caracteres asteriscos ("*").

Exemplo01()
    Read "Digite um número inteiro positivo: ",N
    For I=1:1:N Do
    . Write !
    . For J=1:1:I Do
    .. Write "*"
    Quit
    ;

Este segundo exemplo recebe do usuário um número inteiro positivo N, o qual é mostrado o N-ésimo termo da sequência Fibonacci.

Exemplo02()
    Set I=1
    Set J=0
    Read "Digite um termo da sequência Fibonacci: ",N
    For K=1:1:N Do
    . Set T=I+J
    . Set I=J
    . Set J=T
    Write "O termo ",N," da sequência Fibonacci é: ",!,J
    Quit
    ;

MUMPS no Brasil[editar | editar código-fonte]

Implementações da linguagem MUMPS foram desenvolvidas no Brasil, durante a reservada de mercado de informática. Algumas empresas brasileiras que desenvolveram MUMPS:

  • Pensamento Processamento de Dados Ltda.
  1. Desenvolveu o MUMPS/M (Micros de 8 bits – Z80).
  2. Desenvolveu o MPC (Para computadores PC - 8086).
  3. Desenvolveu o MP7 e o MUMPS da COBRA Computadores (Escrito na linguagem C).
  • Biodata
  1. Desenvolveu o BioMumps (Minicomputadores SISCO, Micros de 8 bits – Z80, Micros de 16 bits - MSDOS).
  • Extensão
  1. Supermumps.

Ver também[editar | editar código-fonte]

Em português:

Ícone de esboço Este artigo sobre programação de computadores é um esboço. Você pode ajudar a Wikipédia expandindo-o.