Those unfamiliar with M/MUMPS are not aware of some of the built in features that have not been adopted by other platforms.
M allows one to code in a very terse language (an artifact of only 2K RAM/ transient temporary memory) with so many abbreviations and short forms for intrinsic/builtin functions, variables, commands, and other things. A large number of string manipulation, mathematical, and logical functions with a form of string recognition matching (from SNOBOL) and type coercion/interpretation round out the basic expression evaluation system. Allowing variable names as valid values for any variable gives a way to create dynamic expressions and symbolic manipulation.
A fixed point numeric value with over 18 digits of accuracy means math on values over the national debt can be stored in a single variable. Lossy floating point systems of other computer languages are not acceptable to customers. Limits on strings of characters depend on implementations and have been only increasing over the years beyond megabytes. All of these are managed without applications dealing with pointer arithmetic, allocation, deallocation, and such schemes such as Rust, C++, require.
The decision to separate out I/O into a subsystem was very common at the time, with various kinds of devices providing a high level model of channels & streams that are all managed below the language implementation level. Tight limits and timing for input I/O and output I/O means no buffer overflow exploits. Character set management also keeps control over contents of strings.
Generally, M has follows the model of high level capabilities under a very simple language interface. Each command has a highly focused syntax.
Which is why permanent storage uses a dynamic sparse variable indexed by strings whose stored values are strings and is indicated using the caret ^ as the prefix to the variable name.
This approach removed the need for user level applications to track disk latency, disk buffers, asynchronous processes, etc. which were common at that time.
Interprocess communication and control using a hierarchical Locking mechanism is very flexible. This means coordinating by locking a high level entry in the hierarchy and allow other worker processes to lock lower in the hierarchy.
The 1977 standard used a system that prevents deadlock from occurring. Later M Standards broadened the tools available with incremental & decremental locking and now deadlock can happen.
Transaction Processing allows one to separate data updates in a transparent way so competing control flows can more intelligently change the system.
Basically, this allows a try-retry-commit-stop backtracking command flow similar to Prolog and declarative code.
Control flow also uses the parallel invocation command (JOB) and normal subroutine calls (DO), with parameter passing and function return values. Looping is unified by the FOR command. Exception processing and control flow avoid undefined behavior.
Dynamic variable lifetimes using KILL and the NEW commands and associative memory access to values of variables. Typed controlled run time evaluation of commands adds discipline beyond "eval" in other languages.
The language allows implementations to specify unique abilities to increase unique commercial subsystems while still being backward compatible. There are ways to invoke external code
which can enhance capabilities as well as tieing to SQL and other languages.
While not part of the standard, high performance and reliable database management with ability to automatically recover from power loss using internal logging and rebuild tools, and compressed B*-trees is necessary for any M system to be viable in the market.