I'm interested in getting involved/up to speed on VistA, the Veterans' Administrations open source medical records system. To that effect, I understand I should learn the MUMPS (M) language upon which the software is based. Does anyone have any getting started tips or book recommendations on this language and environment? Any tips on getting up to speed on VistA is appreciated as well. Audience: experienced developer/consultant.
Thanx in adv.
Intersystems ships some good tutorials with Cache, they can be found in their documentation. On the net there isn't really good learning material except that provided from Intersystems.
But be warned! Take a look here.
The MUMPS entry in Wikipedia has a few links, and is itself a concise introduction to the language. The comp.lang.mumps newsgroup also looks active (last entry October 29).
Here's where I first heard about MUMPS
Quite a funny intro to the language, although far from positive :)
Wow... someone actively looking to be involved in mumps work. The first post is funny and true. It was my first real programming language and job, and it did pay my way through college, but it has a real small set of followers. Most people realized that it has become a dying language since the early 90's. To InterSystems credit they did a good job of consolidating the various vendors and repackaging it all as Cache. If you want an up to date book, search for Kevin OKane at http://www.cs.uni.edu/~okane/. He actaully published a basic book in 2008 on the language.
I laugh now ... buy last month I did some maintenance on an old system to correct HCFA forms. The best thing about Mumps is that once it is debugged, it runs and runs and runs!
Check out the Cachetastic blog -- 25 posts on "How I Learned To Stop Worrying And ... er ... Accept Caché ObjectScript "
As of December, the author is no longer a MUMPS programmer, so I don't know if it will receive any more updates.
Mumps is worth learning if you're interested in programming languages in general. But may drive you crazy.
What's truly frighteningly, scarily horrific about Mumps : Dynamic Scope! Be very afraid. You will not believe how hurt you will be by this.
The problem of dynamic scope is not that you'll create bugs. You can probably avoid that. The problem is that you'll NEVER be able to refactor old code with confidence because you'll never know whether your refactoring breaks an existing implicit dependency.
My advice. NEVER rely on dynamic scope side effects in your own code. Always pass arguments. Use C-style call-by-reference for arrays. (And all your other complex data-structures will be made of arrays.) Then at least you won't do too much harm.
Every other problem in Mumps pales in comparison with that.
Probably the two most comprehensive books on Mumps would be
Mumps Programming, a comprehensive guide
and
They will have everything you will need to know to get started, and enough advanced topics to use as a reference down the road. I am a programmer for a large healthcare organization using a Mumps/Cache based product, and there are several copies of these two books floating around the shop.
Yes, me too, I want to switch to MUMPS. Go ahead and laugh but I know 14 other languages and just as many databases. MUMPS is the fastest, most powerful and cheapest solution on the planet. Go ahead CIO's continue to pay millions year after year for support and maintenance and the extra hardware needed to run those resource hogs.
InterSystems
Deep within the InterSystems site are archives of older MUMPS language definitions that pre-date Cache' (somewhere in their FTP sections) search through the news group below for an answer to its location).
Single user ISC Cache' is free to download (but requires specific INTEL processor for the windows based version). I recommend the free Apache web server to handle CSP (Cache' Server Pages) or you can look into WINFO (http://www.winfo.be/en/home.htm) for a Delphi UI.
Intersystems Cache' documentation is extensive and will take months to read just one time through. Cache' is the next generation of MUMPS with the good features preserved and the bad features replaced with modern constructs.
news.intersystems.com -> intersystems.public.cache and .ensemble are active forums.
Vista
Link: www.hardhats.org
Books
The Complete MUMPS book is a great starter and everthing is there for understanding traditional MUMPS. It is just not easy to find specific details afterwards, so take notes. List of all the (non ISC Cache') MUMPS books ever printed ->
http://www.geocities.com/SiliconValley/7041/M/books.html#Top (This is a BIG list)
Annotated MUMPS: http://71.174.62.16/Demo/AnnoStd (online)
More companies that support MUMPS -> GT, VISTA (VA) just keep searching you'll find them.
Classroom training is available at InterSystems (for M/Cache') and here: http://www.connectionsgroupltd.com/ (Standard MUMPS only)
The single best place to learn about VA VistA is at VistApedia If you are just beginning I recommend that you read WHat is VistA Really (I am the original author of that article)
I recommend that you use Astronaut VistA (by my friend Dr. Valdes) which is an rpm installer for VistA. That will get you using VistA in five minutes, as opposed to spending weeks learning merely about installation... configuration is hard enough.
However, the most meticulous documentation on VistA is the Intracare implementation log. Go to [Hardhats][3] and search for the term "Intracare", you will find dozens of posts that specifically document -every- stage of setting up a private hospital with VistA.
It is only now, after 1. Getting VistA up and 2. Learned to configure VistA that you should even consider learning MUMPS. This is just the same as learning C for the purposes of Linux Kernel programming. First get and install Linux and get some notion of what you might want to do and why. Then learn to program in that context.
At that point I recommend that you attend one of the WorldVistA education conferences, look carefully, sometimes they also offer a 1-2 day course in MUMPS programming as part of a pre-conference. I took this and learned a tremendous amount.
After that you should start studying Timsons FileMan, which is at the core of the VA VistA programming stack.
Further you might consider not learning MUMPS at all! Instead you might learn Delphi, which is what CPRS is currently written in. There is a good chance that an change you might want to make to VistA might simply be "Wow... thats great, but I sure wish I had a GUI for this", and to do that (for the time being) you probably should take a look at CPRS or Kevin Toppenburgs various tools, which illustrate what can be done with the current windowing platform.
You should also be aware of Medsphere's OVID project, which seeks to create a means of programming in Java but still accessing VistA. OVID is installed by default with Astronaut.
I know I have not helped to much with your question directly, but I hope this provides some context.
I became acquainted with MUMPS (MUMPS may also be called M, and its arguably most popular implementation is Intersystems’s Cache) in 1985, by writing a partial implementation of it for the DOS-based PCs of that period, then began working in MUMPS and MUMPS-like language (one such language is MIIS – possibly a truly extinct language now) app development shops. I’ve done such development work and system admin on and off ever since.
Re the title question “tips for learning MUMPS/M/Cache”...
I recommend simply learning its keyword, most of which can and typically are abbreviated by single letters, and the rest by 2-letters. M has about 26 commands and 26 intrinsic functions (about a dozen or so are most used) so learning them all is about equivalent to learning the alphabet. Install an implementation of it – the free, no-external-IP-connections-allowed Cache for Windows downloadable from Intersystem is a nice one – connect to it with a terminal (one comes packaged an pre-configured for than with Cache), and play with the language at the command line (also called programming or direct mode). Unless you manage a fairly exotic sequence of commands involving O[PEN] and U[SE], you can’t hurt any of your underlying files besides the ones it uses, so it’s a fairly safe playground.
Cache’s documentation (a website hosted locally by the language server itself) is adequate, but somewhat confusing, as it doesn’t distinguish between ANSI standard M and its implementation, called “Cache object script”, which has many non-standard extensions. Intersystems systematically avoids even acknowledging that it’s an implementation of M – when last I checked, a search of its documentation for “MUMPS” finds references only to the disease!
If you’re a language formalist, the M language standard is available as a print ANSI document, ANSI/MDC X11.1-1995 (1995 is the year of its last revision), which fully describes the language in EBNF (contextless grammer). I’ve googled phrases from it, and am pretty sure from the lack of hits that it can only be had in paper library stacks or ordering the pricey print document from ANSI.
As for “what’s it good for” …
Obviously, it’s good for getting a job supporting and developing enhancements and rereleases of old MUMPS applications.
It’s good for accessing and modifying huge text databases really fast – though you can get this performance and functionality via the layered classes and other language bindings offered by Cache and other vendors without needing to learn more than a smidgen of the M language.
Oddly – and I’m the only person I know who does much of this – it can be a very handy science and math prototyping language. Like most truly interpreted languages, it’s pure number-crunching performance is poor compared to a binary executable compiled from any of the many compiled languages (C, etc), but I find it unequalled as a “brainstorming” language, and on a machine with lots of CPU, it can solve significant problems in reasonable times.
It’s main weakness, IMHO, is a lack of intrinsic binding to anything except a text terminal. Although the 1990’s MDC (M development committee) put considerable effort into the “M Windows API” and bindings with window systems (mostly X), it didn’t make it into a language standard, and is very rarely implemented. In short, graphics in M are a PITA.
One of the more popular implementations of MUMPS is Cache by Intersystems. Here's their online documentation. I work with a GE health care system, and it's been a great help to me:
http://docs.intersystems.com/cache50/csp/docbook/DocBook.UI.Page.cls
http://www.hardhats.org/ is a excellent source for VISTA and Mumps (M) / Cache information.
Very interesting. IMHO, I would go with the old APL as a science prototyping language over MUMPS, but that's just my opinion.
My question is: I have installed the free Cache implementation of MUMPS. There is a web server that allows all sorts of admin tasks, but I don't see anywhere to start a terminal, and no information on the simplest of starting tasks, e.g. How do I create a new "function", call it HW or ^HW or something like that that does "Hello World". I would call it by typing d ^%HW ?
Real question is how to create a new function, add lines to it, then execute it?