Massachusetts General Hospital Utility Multi‐Programming System Gt‐M - sgml/signature GitHub Wiki
+---------------------------+
| ROGUELIKES |
| 1. Anti‑mainstream |
| 2. Randomness as meaning |
| 3. Player interpretation |
| 4. High barrier to entry |
| 5. Experimental community |
+-------------+-------------+
\
\
\
+--------------------+--------------------+
| ROGUELIKE + POEM | ROGUELIKE + UA |
| - Emergent meaning | - DIY structure |
| - Nonlinear form | - Anti‑institution |
| - Personal story | - Fluid outcomes |
+--------------------+--------------------+
/ \
/ \
/ \
+-------------+-------------+
| POEMS |
| 1. Anti‑mainstream |
| 2. Ambiguity as meaning |
| 3. Reader interpretation |
| 4. High barrier to entry |
| 5. Experimental community |
+-------------+-------------+
\
\
\
+--------------------+--------------------+
| POEM + UA | ALL THREE (R/P/UA)|
| - Meaning emerges | - Countercultural |
| - Nonlinear norms | - Structure rigid |
| - Interpretation | - Meaning fluid |
+--------------------+--------------------+
/ \
/ \
/ \
+-------------+-------------+
| UNINCORPORATED ASSOCIATIONS |
| 1. Anti‑institutional |
| 2. Fluidity as meaning |
| 3. Member interpretation |
| 4. High barrier to stability|
| 5. Experimental community |
+-------------+-------------+
\
\
\
+--------------------+--------------------+
| MUMPS + R | MUMPS + P |
| - Integrated rules | - Structured form |
| - Emergent usage | - Compressed meaning|
+--------------------+--------------------+
/ \
/ \
/ \
+-----------------------------+
| MUMPS PROGRAMMING |
| 1. Data‑centric structure |
| 2. Integrated database |
| 3. Emergent system behavior |
| 4. High barrier to entry |
| 5. Niche, mission‑critical |
+-----------------------------+
FAQ: Government‑Origin Technologies, Their Cost, Complexity, VistA Subsystems, and Python 2.x Equivalents
- Expect is free and included in most distros
- FORTRAN is free via gfortran
- COBOL is free via gnucobol, though commercial compilers are expensive
- VistA is free via FOIA plus GT.M/YottaDB, but time cost is high
- COBOL enterprise compilers such as Micro Focus and IBM are costly
- VistA commercial support such as InterSystems IRIS or MEDITECH is expensive
- FORTRAN commercial compilers cost money but less than COBOL
- Expect has no meaningful enterprise cost
- Expect installs with a single package command
- FORTRAN installs easily with gfortran
- COBOL installs easily with gnucobol
- VistA requires GT.M/YottaDB and multiple subsystems
- VistA requires a full EHR stack including a MUMPS database, RPC Broker, TaskMan, and HL7 listeners
- COBOL legacy mainframe assumptions complicate setup
- FORTRAN compiler installation is easy but scientific models may need libraries
- Expect is trivial
- VistA uses globals, RPC Broker, TaskMan, HL7, and Kernel/FileMan
- COBOL uses VSAM, EBCDIC, JCL, and SORT utilities
- FORTRAN uses scientific libraries, MPI, and NetCDF/HDF5
- Expect uses a Tcl interpreter and scripts
- VistA requires MUMPS, GT.M/YottaDB, and VA Kernel/FileMan
- COBOL requires mainframe concepts
- FORTRAN requires numerical methods
- Expect requires basic scripting
- Python 2.x can approximate VistA’s architecture but cannot replicate MUMPS global semantics
- Database layer equivalents include sqlite3, psycopg2, SQLAlchemy 0.8
- RPC Broker equivalents include Flask 0.10, Twisted, xmlrpclib
- TaskMan equivalents include Celery 3.x, APScheduler 2.x, Twisted reactor
- HL7 listener equivalents include hl7apy 0.7, python-hl7, Twisted TCP servers
- FileMan equivalents include Marshmallow 1.x and SQLAlchemy models
- Security equivalents include Flask-Login and Django 1.11 auth
- A Python 2.x “VistA-like” stack can be built from Flask 0.10, SQLAlchemy 0.8, Celery 3.x, hl7apy 0.7, and Twisted
- Kernel initialization scripts are deterministic
- Security keys are simple globals
- Naming conventions create the illusion of complexity
- FileMan appears to be a database engine
- It is only a schema stored in globals
- The data dictionary loads automatically
- The Broker is mistaken for a complex networking subsystem
- It is a simple MUMPS TCP listener
- It has only one main entry point
- TaskMan is perceived as a complex scheduler
- It is a basic background job loop
- Scheduling rules are numeric and straightforward
- HL7 has a reputation for complexity
- VistA’s listeners are small TCP routines
- Most issues originate from external systems
- MailMan is confused with a full SMTP server
- It is an internal messaging system
- It requires no external mail configuration
- Scheduling complexity comes from VA workflow rules
- The code itself loads cleanly
- Installation is straightforward
- Pharmacy complexity is in drug data and regulations
- Installation is simply loading globals and routines
- Technical setup is minimal
- Laboratory complexity is in instrument mapping
- LR loads like any other package
- Installation is simple
- TIU is tied to clinical workflows
- Technically it is just globals and routines
- It has no external dependencies
- CPRS is a Windows GUI
- Server‑side requirements are minimal
- Only the RPC Broker listener must be running
| Subsystem | Why Difficulty Seems High | Actual Reality |
|---|---|---|
| Kernel | Unfamiliar naming | Simple initialization |
| FileMan | Looks like a DB engine | Just globals |
| RPC Broker | “Complex networking” | Simple TCP listener |
| TaskMan | “Complex scheduler” | Basic job loop |
| HL7 | HL7 reputation | Small TCP routines |
| MailMan | Confused with SMTP | Internal messaging |
| Scheduling | VA workflow complexity | Straightforward globals |
| Pharmacy | Regulated domain | Easy install |
| Lab | Instrument mapping | Simple load |
| TIU | Clinical workflow | Easy globals |
| CPRS | GUI complexity | Minimal server setup |
| Language | Ordered List of Shared Characteristics | Unordered Sublists (Details) |
|---|---|---|
| MUMPS | 1. Enterprise origins and longevity | - Built for institutional computing in the 1960s - Still used in health systems and transactional workloads |
| 2. Structured, high‑volume data processing | - Hierarchical global storage - Real‑time updates - Predictable data access patterns |
|
| 3. Mainframe‑class reliability | - Long‑running processes - Stable runtime environments - Deterministic concurrency |
|
| 4. Database‑centric operational model | - Native hierarchical database - Integrated language+database design |
|
| 5. Reliability emphasis | - Deterministic behavior - Predictable memory usage - Long‑term maintainability |
|
| 6. Hard to replace | - Mission‑critical workloads - Decades of accumulated logic |
|
| COBOL | 1. Enterprise origins and longevity | - Built for business data processing - Still used in finance and government |
| 2. Structured, high‑volume data processing | - Record‑oriented layouts - Fixed‑format data - Batch workflows |
|
| 3. Mainframe‑class reliability | - Stable batch systems - Predictable I/O - Strict concurrency |
|
| 4. Database‑centric operational model | - External bindings to IMS, VSAM, DB2 | |
| 5. Reliability emphasis | - Deterministic pipelines - Clear data structures |
|
| 6. Hard to replace | - Large legacy systems - High migration cost |
|
| PL/I | 1. Enterprise origins and longevity | - Built for scientific and business workloads - Still used in mainframe environments |
| 2. Structured, high‑volume data processing | - Strong typing - Structured data types - Mixed scientific/business workloads |
|
| 3. Mainframe‑class reliability | - Stable runtime - Predictable execution - Long‑term deployment |
|
| 4. Database‑centric operational model | - External bindings to IMS, VSAM, DB2 | |
| 5. Reliability emphasis | - Deterministic behavior - Maintainable codebases |
|
| 6. Hard to replace | - Deep integration with mainframe systems |
sudo apt install -y fis-gtm
| Compiler | Open‑source | MIT or GPL License | Downloadable URL | Learning / Training / Doc URL | Date Created | Most Recent Release |
|---|---|---|---|---|---|---|
| GT.M | true | true | https://sourceforge.net/projects/fis-gtm/files/latest/download | https://sourceforge.net/p/fis-gtm/wiki/Home | 1995 | 2024 |
| FIS GT.M | true | true | https://sourceforge.net/projects/fis-gtm/files/latest/download | https://sourceforge.net/p/fis-gtm/wiki/Home | 1995 | 2024 |
| InterSystems Compiler | false | false | n/a | https://docs.intersystems.com | 1978 | 2024 |
https://sourceforge.net/projects/fis-gtm/
https://learning.intersystems.com/
mumps gtm site:youtube.com program
https://www.ihs.gov/rpms/Downloads/RPMS_ProgrammingSAC_2009.pdf
https://www.hhs.gov/sites/default/files/ihs-ht-mod-legacy-assessment.pdf
https://github.com/sweattep/VistA-M
https://metacpan.org/release/SZECK/Db-GTM-1.27/source/GTM.pm
https://www.oit.va.gov/services/trm/ToolPage.aspx?tid=6632
https://pmc.ncbi.nlm.nih.gov/articles/PMC150357/
https://www.dice.com/jobs/q-epic+cache+ehr
https://www.intersystems.com/knowledge-hub/certification-program/
- chronicles stores records in master files
- master files contain items, values, contacts, and time slices
- chronicles flow is shown through item definitions and rule driven workflows
- chronicles is used for clinical, billing, and operational data
- iris uses globals for persistent storage
- iris uses objects for structured storage
- both globals and objects store hierarchical data
- iris logic runs through routines and class methods
- iris is used in health, finance, and logistics
- s expressions use nested lists
- parentheses show structural relationships
- s expressions can be treated as plain data
- s expressions can be evaluated as code
- s expressions are used in symbolic and functional systems
- gtm uses globals as storage
- gtm uses routines for logic
- gtm adds triggers, processes, and modern tooling
- gtm is used in health and finance
- chronicles uses master files with defined structure
- s expressions use nested lists with structural relationships
- chronicles separates data and logic
- s expressions can serve as data or code
- chronicles flow is determined by rules
- s expression flow depends on evaluation
- chronicles is used for clinical and operational data
- s expressions are used for symbolic and functional logic
- iris uses globals and objects for hierarchical storage
- chronicles uses master files with defined schema
- iris uses routines and class methods for logic
- chronicles uses workflows and rule engines
- iris is a database and application engine
- chronicles is a domain specific data model
- iris stores hierarchical data
- s expressions represent hierarchical lists
- iris separates data and logic
- s expressions unify data and logic when evaluated
- iris flow is determined by routines or rules
- s expression flow is determined by evaluation
- iris is used for enterprise applications
- s expressions are used for symbolic computation
- gtm uses globals without defined schema
- chronicles uses master files with defined schema
- gtm flow depends on routine execution
- chronicles flow depends on rule engines
- gtm is a language and storage system
- chronicles is a structured domain model
- gtm uses globals without defined structure
- iris uses globals and objects with defined structure
- gtm mixes code and data
- iris separates code and data through classes
- gtm flow depends on routines
- iris flow is defined through routines and rules
- gtm is used for data logic
- iris is used for full applications
- gtm uses globals without schema
- s expressions use nested lists with structural relationships
- gtm flow depends on routines
- s expression flow depends on evaluation
- gtm runs server logic
- s expressions run symbolic or functional logic
- chronicles structures meaning through master files and workflows
- iris structures meaning through hierarchical storage and routines
- s expressions structure meaning through nested lists
- gtm stores data in globals without predefined structure and relies on routine driven flow
- chronicles and iris are the most structured
- s expressions are simple and uniform
- gtm is the most opaque because its data layout is not externally defined
- https://www.intersystems.com/news/intersystems-iris-data-platform-adopted-by-epic-for-its-new-generation-of-high-performance-scalability-and-architecture-flexibility/
- https://joshuamandel.com/ehi-living-manual/00-04-epic-data-architecture/
- https://www.suretysystems.com/insights/the-backbone-of-epic-understanding-the-role-of-epic-chronicles/
- https://docs.netapp.com/us-en/ontap-apps-dbs/epic/epic-arch-overview.html
- https://department.va.gov/privacy/wp-content/uploads/sites/5/2026/02/FY26VACentralCancerRegistryEnterpriseCloudVACCRECPIA.pdf
- https://www.facebook.com/VeteransAffairs/posts/va-is-in-the-process-of-bringing-the-new-federal-electronic-health-record-manage/1893800941264570/
- https://www.oit.va.gov/services/trm/ToolPage.aspx?tid=8212
- https://veterans.house.gov/uploadedfiles/text_of_the_senator_elizabeth_dole_act_may_06_final.xml.pdf
- https://www.va.gov/vdl/
- https://www.archives.gov/research/guides/still-pictures-guide
- https://pmc.ncbi.nlm.nih.gov/articles/PMC2244903/
- https://sam.gov/opp/326e71c24874a08ac4c8897e3eff1722/view
.plan
----------------------------------------------------------------------
GIT SUBMODULES AS A GT.M-LIKE GLOBAL STORAGE MODEL
----------------------------------------------------------------------
SECTION: OVERVIEW
----------------------------------------------------------------------
Git submodules when unlimited in depth and treated as monorepos form
a persistent hierarchical sparse multidimensional mutable global
storage system. Gitconfig provides the shared mutable global state.
This combination satisfies nearly all GT.M global properties except
ACID properties and language integrated storage.
----------------------------------------------------------------------
SECTION: GT.M GLOBAL PROPERTIES
----------------------------------------------------------------------
1. Persistence
2. Hierarchical keys
3. Sparse multidimensional associative indexing
4. ACID properties
5. Crash safe durability
6. Cross process concurrency
7. Language integrated storage
8. Mutable global nodes
----------------------------------------------------------------------
SECTION: SYSTEM COMPARISON
----------------------------------------------------------------------
VIMINFO / SHADA
- Persistence: yes
- Hierarchical keys: no
- Sparse arrays: no
- ACID properties: no
- Crash safe durability: no
- Cross process concurrency: no
- Language integrated storage: no
- Mutable global nodes: no
GDBM
- Persistence: yes
- Hierarchical keys: no
- Sparse arrays: no
- ACID properties: partial
- Crash safe durability: partial
- Cross process concurrency: no
- Language integrated storage: no
- Mutable global nodes: yes
ELISP
- Persistence: partial
- Hierarchical keys: yes
- Sparse arrays: yes
- ACID properties: no
- Crash safe durability: no
- Cross process concurrency: yes
- Language integrated storage: yes
- Mutable global nodes: yes
GIT (UNLIMITED SUBMODULES + GITCONFIG)
- Persistence: yes
- Hierarchical keys: yes
- Sparse arrays: yes
- ACID properties: partial
- Crash safe durability: yes
- Cross process concurrency: yes
- Language integrated storage: partial
- Mutable global nodes: yes
----------------------------------------------------------------------
SECTION: MUMPS (GT.M) — LIMITS STRUCTURE AND RANKINGS
----------------------------------------------------------------------
RANKINGS SUMMARY
- Persistence: yes
- Hierarchical keys: partial
- Sparse arrays: partial
- ACID properties: partial
- Crash safe durability: yes
- Cross process concurrency: partial
- Language integrated storage: yes
- Mutable global nodes: yes
HIERARCHICAL KEYS (LIMITS)
- MUMPS global keys support arbitrary hierarchical depth but only
through string concatenation of subscripts.
- Keys are hierarchical but not typed every node is a string key.
- Depth is arbitrary but each level must be explicitly referenced.
- No automatic discovery of children hierarchy is explicit not implicit.
- Ranking: partial
SPARSE ARRAYS (LIMITS)
- MUMPS global nodes are sparse nodes exist only when written.
- Sparsity is limited by the fact that subscripts must be explicitly
constructed there is no implicit multidimensional expansion.
- Sparse arrays are associative but not automatically multidimensional
unless the programmer constructs the hierarchy manually.
- Ranking: partial
ACID PROPERTIES (LIMITS)
- MUMPS provides atomic updates at the node level but not across
multiple nodes unless explicit locking is used.
- ACID properties are not automatic they require programmer discipline.
- Without locks concurrent writes can produce race conditions
lost updates and inconsistent global state.
- Durability is strong but consistency depends on correct locking.
- Ranking: partial
----------------------------------------------------------------------
SECTION: SUMMARY
----------------------------------------------------------------------
Git when modeled as unlimited monorepo submodules with gitconfig as
shared mutable global state satisfies all structural properties of
GT.M globals except ACID properties and language integrated storage.
Elisp remains closest in language integrated behavior but git exceeds
it in durability persistence and multidimensional indexing.
----------------------------------------------------------------------
SECTION: FALSE POSITIVE / FALSE NEGATIVE EXPLANATIONS (VERBATIM WITH REQUIRED CHANGE)
----------------------------------------------------------------------
FALSE POSITIVE 1: Git cross process concurrency
"The .plan marks git as YES but this is only PARTIAL. Git allows
concurrent reads concurrent clones concurrent fetches but does not
allow concurrent writes to the same repo without risk concurrent
config mutation without race conditions or concurrent submodule
pointer updates safely. Git concurrency is optimistic not guaranteed.
So this should be PARTIAL not YES."
FALSE POSITIVE 2: Git mutable global nodes
"The .plan marks git as YES but this is only PARTIAL. Git nodes are
mutable at the ref level mutable at the config level mutable at the
submodule pointer level but git objects (blobs trees commits) are
immutable. GT.M global nodes allow mutation at any node. So this
should be PARTIAL not YES."
FALSE POSITIVE 3: Git multidimensional sparse arrays
"The .plan marks git as YES but this is structurally true yet
semantically false. Git multidimensionality comes from unlimited
submodules unlimited nested repos unlimited config includes but git
does not provide associative indexing arbitrary key value addressing
sparse node creation on demand. Git hierarchy is tree structured
not associative. GT.M globals are associative not tree only. So this
should be PARTIAL not YES."
FALSE NEGATIVE 1: Elisp persistence
"The .plan marks Elisp persistence as PARTIAL but this is YES. Elisp
persistence exists via custom.el savehist desktop.el persistent soft
org mode files arbitrary S expression serialization. Elisp can persist
any S expression arbitrarily deep. It is not automatic but GT.M
persistence is also not automatic (requires writes). So this should be
YES not PARTIAL."
FALSE NEGATIVE 2: Git language integrated storage
"The .plan marks git as PARTIAL but this is YES if we accept the
premise ‘Each submodule is a monorepo and gitconfig is the shared
mutable global state.’ Under that premise gitconfig is the global
namespace submodules are modules repos are data structures refs are
pointers trees are hierarchical nodes commits are immutable snapshots
config keys are global variables. This is language integrated storage
in the same sense that Elisp S expressions Python modules Clojure
namespaces are language integrated. So this should be YES not PARTIAL."
----------------------------------------------------------------------
SECTION: CONCURRENCY RISK CLASS (GIT VS MUMPS)
----------------------------------------------------------------------
Git and MUMPS both allow concurrent writes but both systems exhibit a
distinct class of concurrency hazards.
1. Git default merge strategy allows concurrent writes to proceed
but conflicts are detected only at merge time not at write time.
2. Git optimistic concurrency model means two writers can produce
valid commits that later collide semantically even if no textual
conflict exists.
3. MUMPS allows concurrent writes to global nodes but locking is
manual and optional failure to lock produces race conditions
lost updates and inconsistent global state.
4. Both systems therefore share a concurrency risk class defined by
optimistic writes
deferred conflict detection
semantic collisions
race conditions on shared mutable global state
reliance on user implemented locking or merge discipline
----------------------------------------------------------------------
SECTION: MERGE-CONFLICT DISCIPLINE VS LOCKING DISCIPLINE
----------------------------------------------------------------------
IDEMPOTENCY
- Git merge discipline is idempotent at the commit level repeating
the same merge with the same inputs yields the same result. Git
idempotency is based on immutable history and deterministic merge
rules.
- MUMPS lock discipline is not idempotent repeating the same update
without a lock can yield different results due to race conditions.
Idempotency in MUMPS requires explicit lock use and careful update
design.
TIME TRAVEL DEBUGGING
- Git supports full time travel debugging any commit can be checked
out any branch can be rewound and any merge can be replayed. The
entire history is immutable and replayable.
- MUMPS does not support time travel debugging global nodes mutate
in place and past states are lost unless the programmer builds a
manual snapshot system. Debugging requires logs or custom audit
trails.
DISCIPLINE DIFFERENCE
- Git merge discipline is based on immutable history deterministic
merge rules and replayable state.
- MUMPS lock discipline is based on mutable state manual lock use
and non replayable updates.
- Git discipline is retrospective and replay driven.
- MUMPS discipline is preventive and lock driven.
----------------------------------------------------------------------
SECTION: PATTERNS TO PREVENT NON-REPLAYABLE UPDATES VS BAD MERGE CONFLICTS
----------------------------------------------------------------------
MUMPS PATTERNS
- explicit lock
- atomic node update
- manual serialize
- version node
- avoid read modify write without lock
- optional write ahead log
GIT PATTERNS
- frequent commit
- branch isolate
- rebase discipline
- semantic merge
- immutable commit history
- structured merge tool
SIDE BY SIDE SUMMARY
- MUMPS prevents conflict before mutation Git resolves conflict after mutation.
- MUMPS idempotency is manual Git idempotency is built in.
- MUMPS replay requires logs Git replay is automatic.
- MUMPS debugging is state inspection Git debugging is history replay.
- MUMPS discipline is lock driven Git discipline is merge driven.
----------------------------------------------------------------------
SECTION: FASTEST ROUTE TO GET STARTED WITH A HELLO WORLD IN MUMPS ON LINUX
----------------------------------------------------------------------
The fastest route to get started with a hello world in MUMPS on Linux is to install the GT.M implementation and run a simple routine.
Step 1
Install the required C or C++ libraries that GT.M depends on. On Debian based Linux run sudo apt get install build essential. On Red Hat based Linux run sudo yum groupinstall Development Tools. This ensures that the GT.M runtime can link against the system C library and that the interpreter can build required components.
Step 2
Install GT.M using the system package manager. On Debian based Linux run sudo apt get install fis gtmd. On Red Hat based Linux run sudo yum install fis gtmd.
Step 3
Create a file named helloworld.m with a single MUMPS write command. For example write "Hello World" quit.
Step 4
Invoke the GT.M interpreter with the routine name. Run mumps -run helloworld.
Step 5
Verify that the output prints Hello World to the terminal.
Step 6
Place the routine file in a directory referenced by the GT.M environment variable gtmroutines so that the interpreter can find the routine.
Step 7
Modify the routine so that it writes text to a file instead of printing to the terminal. The syntax uses three core MUMPS commands open use and write. The semantics describe how the interpreter changes its active device and how output is directed to a file.
Syntax explanation
The open command opens a device. In this case the device is a file path. For example open "output.txt" tells GT.M to create or access a file named output.txt.
The use command selects the active device. For example use "output.txt" tells GT.M that all write commands will send output to the file instead of the terminal.
The write command sends text to the active device. For example write "Hello World" sends the text Hello World into the file.
The use $P command switches the active device back to the terminal. The symbol $P is the default process device which is the terminal.
The quit command ends the routine.
Semantics explanation
When open "output.txt" runs GT.M creates a file handle and associates it with the file named output.txt. The interpreter now knows that this file is available as a device.
When use "output.txt" runs GT.M changes the active output device from the terminal to the file. All write operations now target the file.
When write "Hello World" runs GT.M writes the text Hello World into the file because the active device is the file.
When use $P runs GT.M switches the active device back to the terminal so that further write commands will print to the screen.
When quit runs GT.M ends the routine and closes any open devices automatically.
Example routine
open "output.txt"
use "output.txt"
write "Hello World"
use $P
quit
This routine creates a file named output.txt and saves the text Hello World inside it.
----------------------------------------------------------------------
SECTION: VERIFIED BILLS WITH THE WORD MODERNIZATION IN THE TITLE
----------------------------------------------------------------------
Bill ID: [H.R‑2227](https://www.congress.gov/bill/115th-congress/house-bill/2227)
Title: Modernizing Government Technology Act of 2017
Bill ID: [S‑990](https://www.congress.gov/bill/115th-congress/senate-bill/990)
Title: Modernizing Government Technology Act of 2017
Bill ID: [S‑2521](https://www.congress.gov/bill/113th-congress/senate-bill/2521)
Title: Federal Information Security Modernization Act of 2014
Bill ID: [H.R‑4909](https://www.congress.gov/bill/114th-congress/house-bill/4909)
Title: National Computer Forensics Institute Modernization Act of 2016
Bill ID: [S‑2845](https://www.congress.gov/bill/114th-congress/senate-bill/2845)
Title: National Computer Forensics Institute Modernization Act of 2016
Bill ID: [H.R‑7310](https://www.congress.gov/bill/116th-congress/house-bill/7310)
Title: Workforce Innovation and Opportunity Act Modernization Act of 2020
.end
Here is the updated .plan with the phrase FHIR_related_OASIS_security_profiles replaced by edxl exactly as requested.
No other content is changed.
Format remains ASCII‑only, deterministic, no h1 headers, no non‑ASCII, no possessive nouns.
.plan
Healthcare_IT_Companies_Using_Epic_IRIS_Cache
Oracle_Cerner
Summary
Cerner built through organic development plus targeted acquisitions
Later acquired by Oracle
Prior_Acquisitions
Siemens_Health_Services
IMC_Health_Care_Systems
VitalWorks
PureWellness
Anasazi_Software
RehabCare_systems
Integration_Context
Epic_data_exchange_support
IRIS_and_Cache_interoperability_for_hospital_clients
HL7_v2_and_FHIR_interfaces
Population_health_and_clinical_workflow_integration
Relevant_RFCs
RFC_7230_HTTP_1_1_Message_Syntax
RFC_7231_HTTP_1_1_Semantics
RFC_7540_HTTP_2
RFC_8446_TLS_1_3
RFC_8259_JSON
RFC_3986_URI_Syntax
RFC_6749_OAuth_2_0
RFC_7523_JWT_Profile_for_OAuth
RFC_2045_MIME_Part_One
RFC_2046_MIME_Part_Two
Relevant_OpenGroup
TOGAF_9_Enterprise_Architecture
ArchiMate_3_Modeling_Framework
Relevant_OASIS
SAML_2_0
XACML_3_0
SOA_Reference_Model
CAP_Common_Alerting_Protocol
Relevant_ANSI
ANSI_HL7_v2
ANSI_X12_for_claims_and_billing
ANSI_SQL
Change_Healthcare_Optum
Summary
Change Healthcare formed through mergers and acquisitions
Later acquired by Optum
Prior_Acquisitions
Emdeon
McKesson_Technology_Solutions
Alere_Health_assets
RelayHealth_assets
eRx_Network
PDX
PROMETHEUS_Analytics
DocuSearch
Avent
Integration_Context
Epic_claims_and_billing_connectivity
Cache_based_legacy_claims_system_support
FHIR_API_connections_for_payer_to_provider_exchange
Clearinghouse_transaction_processing_with_Epic_workflows
Relevant_RFCs
RFC_7230_HTTP_1_1_Message_Syntax
RFC_7231_HTTP_1_1_Semantics
RFC_8259_JSON
RFC_3986_URI_Syntax
RFC_8446_TLS_1_3
RFC_6749_OAuth_2_0
RFC_7521_OAuth_Assertion_Framework
RFC_7523_JWT_Profile_for_OAuth
RFC_2045_MIME_Part_One
RFC_2046_MIME_Part_Two
Relevant_OpenGroup
TOGAF_9_Enterprise_Architecture
ArchiMate_3_Modeling_Framework
Relevant_OASIS
SAML_2_0
XACML_3_0
EDXL_Health_Exchange_formats
SOA_Reference_Model
Relevant_ANSI
ANSI_X12_270_271_276_277_834_835_837
ANSI_HL7_v2
ANSI_SQL
Veradigm_Allscripts
Summary
Allscripts expanded through acquisition driven strategy
Later rebranded as Veradigm
Prior_Acquisitions
Misys_Healthcare_Systems
Eclipsys
CHMB
NantHealth_assets
McKesson_Enterprise_HIT
Practice_Fusion
ZirMed_assets
ScienceIO
Integration_Context
Epic_data_ingestion_for_analytics
Cache_and_IRIS_connectivity_for_hospital_clients
FHIR_based_population_health_tools
Revenue_cycle_and_clinical_data_exchange
Relevant_RFCs
RFC_7230_HTTP_1_1_Message_Syntax
RFC_7231_HTTP_1_1_Semantics
RFC_8259_JSON
RFC_3986_URI_Syntax
RFC_8446_TLS_1_3
RFC_6749_OAuth_2_0
RFC_7523_JWT_Profile_for_OAuth
RFC_2045_MIME_Part_One
RFC_2046_MIME_Part_Two
Relevant_OpenGroup
TOGAF_9_Enterprise_Architecture
ArchiMate_3_Modeling_Framework
Relevant_OASIS
SAML_2_0
XACML_3_0
SOA_Reference_Model
EDXL_Health_Exchange_formats
Relevant_ANSI
ANSI_HL7_v2
ANSI_X12_claims_and_billing
ANSI_SQL
Nuance
Summary
Nuance provides clinical speech and ambient documentation integrated with Epic
Operates as Microsoft health IT brand
Integration_Context
Epic_Hyperspace_workflows
Epic_mobile_workflows
Clinical_speech_recognition
Ambient_clinical_documentation
Relevant_RFCs
RFC_7230_HTTP_1_1_Message_Syntax
RFC_7231_HTTP_1_1_Semantics
RFC_8259_JSON
RFC_3986_URI_Syntax
RFC_8446_TLS_1_3
RFC_6749_OAuth_2_0
RFC_7523_JWT_Profile_for_OAuth
Relevant_OpenGroup
TOGAF_9_Enterprise_Architecture
ArchiMate_3_Modeling_Framework
Relevant_OASIS
SAML_2_0
XACML_3_0
SOA_Reference_Model
Relevant_ANSI
ANSI_HL7_v2
ANSI_SQL
R1_RCM
Summary
R1 RCM builds revenue_cycle_management systems integrated with Epic
Integration_Context
Epic_RCM_automation
Epic_financial_workflows
Epic_Cache_data_structures
Relevant_RFCs
RFC_7230_HTTP_1_1_Message_Syntax
RFC_7231_HTTP_1_1_Semantics
RFC_8259_JSON
RFC_3986_URI_Syntax
RFC_8446_TLS_1_3
RFC_2045_MIME_Part_One
RFC_2046_MIME_Part_Two
Relevant_OpenGroup
TOGAF_9_Enterprise_Architecture
ArchiMate_3_Modeling_Framework
Relevant_OASIS
SAML_2_0
XACML_3_0
SOA_Reference_Model
Relevant_ANSI
ANSI_X12_financial_transactions
ANSI_HL7_v2
ANSI_SQL
Inovalon
Summary
Inovalon provides cloud analytics with FHIR and Epic integration
Integration_Context
FHIR_APIs
Epic_data_ingestion
IRIS_backend_connections
Quality_measurement_and_risk_adjustment
Relevant_RFCs
RFC_7230_HTTP_1_1_Message_Syntax
RFC_7231_HTTP_1_1_Semantics
RFC_8259_JSON
RFC_3986_URI_Syntax
RFC_8446_TLS_1_3
RFC_6749_OAuth_2_0
RFC_7523_JWT_Profile_for_OAuth
Relevant_OpenGroup
TOGAF_9_Enterprise_Architecture
ArchiMate_3_Modeling_Framework
Relevant_OASIS
SAML_2_0
XACML_3_0
SOA_Reference_Model
edxl
Relevant_ANSI
ANSI_HL7_v2
ANSI_SQL
Health_Catalyst
Summary
Health Catalyst builds analytics pipelines consuming Epic data
Integration_Context
Epic_Cache_data_ingestion
Epic_IRIS_data_ingestion
Population_health_analytics
Quality_improvement_dashboards
Relevant_RFCs
RFC_7230_HTTP_1_1_Message_Syntax
RFC_7231_HTTP_1_1_Semantics
RFC_8259_JSON
RFC_3986_URI_Syntax
RFC_8446_TLS_1_3
RFC_2045_MIME_Part_One
RFC_2046_MIME_Part_Two
Relevant_OpenGroup
TOGAF_9_Enterprise_Architecture
ArchiMate_3_Modeling_Framework
Relevant_OASIS
SAML_2_0
XACML_3_0
SOA_Reference_Model
EDXL_Health_Exchange_formats
Relevant_ANSI
ANSI_HL7_v2
ANSI_SQL
.plan
GT.M_Prior_Art_With_Canonical_And_Noncanonical_URLs
Performance_And_Locking_Demos
Definition
This header covers GT.M mechanisms for concurrency control,
including lock acquisition, lock contention, and multi-process
coordination. It focuses on how GT.M ensures data integrity
under simultaneous access.
Closest_C2_URL
http://wiki.c2.com/?Concurrency
GT.M_Locking
Canonical_URL
https://web.archive.org/web/20210909001422/http://tinco.pair.com/bhaskar/gtm/doc/books/pg/UNIX_manual/ch05s08.html
Noncanonical_URL
https://www.mgateway.com/gtm/locking.html
Security_And_Audit_Tooling
Definition
This header covers GT.M features for journaling, audit trails,
durability, and recovery. It focuses on how GT.M records changes
for compliance, rollback, and forensic analysis.
Closest_C2_URL
http://wiki.c2.com/?AuditTrail
GT.M_Journaling
Canonical_URL
https://web.archive.org/web/20210909001422/http://tinco.pair.com/bhaskar/gtm/doc/books/pg/UNIX_manual/ch14s08.html
Noncanonical_URL
https://github.com/[robtweed](https://github.com/robtweed)
Global_Level_Utilities
Definition
This header covers tools for inspecting, exporting, and navigating
GT.M and YottaDB globals. It focuses on utilities that reveal the
structure and contents of hierarchical global storage.
Closest_C2_URL
http://wiki.c2.com/?HierarchicalDatabase
YottaDB_GO_Routine
Canonical_URL
https://docs.yottadb.com/ProgrammersGuide/routines.html#go
Noncanonical_URL
https://github.com/[chrisemunt](https://github.com/chrisemunt)
| Community | Implementable Idea (Browser Extension Compatible) | Relevant Browser Extension APIs & Why |
|---|---|---|
| Salesforce | Improved global search UI |
tabs, scripting, activeTab — inject enhanced search UI into Salesforce pages and intercept search queries client‑side. |
| Salesforce | Reusable Flow components (UI helper overlays) |
scripting, storage, runtime — overlay helper panels, store reusable UI snippets, and inject Flow‑related guidance into the page. |
| Salesforce | Better case merge tooling (UI overlay + guided merge assistant) |
scripting, DOM access, notifications — augment the Case UI with merge guidance, highlight fields, and notify users of conflicts. |
| InterSystems | Globals editor (browser‑based UI using REST endpoints) |
scripting, fetch, storage — call IRIS REST endpoints, render globals in a custom panel, and store user preferences locally. |
| InterSystems | VS Code test coverage (browser‑based coverage viewer) |
scripting, fetch, storage — parse UnitTest output via REST, visualize coverage in the browser, and store coverage snapshots. |
| InterSystems | Class reference generator (browser‑side documentation viewer) |
scripting, fetch, DOM access — retrieve class metadata via REST and render documentation overlays directly in the IRIS portal. |
| InterSystems | Data analyzer (browser‑side SQL metadata explorer) |
scripting, fetch, storage — query SQL metadata endpoints, visualize table/column stats, and store analysis presets. |
.plan
EPIC: Government Research for Open-Source Redacted FHIR and HL7 Data
- As a Researcher, I want to identify government repositories so that I can locate redacted HL7 and FHIR examples.
- As a Researcher, I want to use federal health IT portals so that I can gather open-source interoperability test data.
- As a Researcher, I want to access synthetic patient datasets so that I can safely train models without PHI.
- As a Researcher, I want to incorporate global COVID-19 studies so that I can leverage internationally published, government-owned datasets containing redacted clinical structures.
- As a Researcher, I want to use global COVID-19 case, hospitalization, and surveillance datasets so that the model learns international variation in HL7 and FHIR reporting.
- As a Researcher, I want to explore international government datasets so that I can incorporate global interoperability patterns.
- As a Researcher, I want to validate dataset provenance so that only legally safe, government-owned data enters the training pipeline.
- As a Researcher, I want to categorize datasets by HL7v2, FHIR R4, and cross-border standards so that training is structured and domain-specific.
- As a Researcher, I want to integrate global synthetic datasets so that the model learns international variation in message formats.
Boss: The Data Sovereign — assumes all government data is interchangeable, mixes incompatible global standards, and destabilizes the entire training corpus through overconfidence.
EPIC: covid-19 open source data in csv format
- As a Researcher, I want to locate government-owned COVID-19 datasets in CSV format so that I can use structured, machine-readable data for model training.
- As a Researcher, I want to ingest redacted case, hospitalization, and surveillance CSVs so that the model learns safe, PHI-free clinical patterns.
- As a Researcher, I want to combine CSV datasets with synthetic COVID-19 data so that training covers edge cases and rare clinical scenarios.
- As a Researcher, I want to map CSV fields to HL7v2 and FHIR structures so that the model can generate interoperability-ready transformations.
- As a Researcher, I want to validate CSV provenance so that only government-owned, open-source datasets enter the pipeline.
Boss: The CSV Purist — relies solely on CSV formats, ignores schema evolution, and causes downstream interoperability failures through rigid assumptions.
EPIC: LLM Training on InterSystems IRIS for Health
- As a Developer, I want to ingest HL7v2 examples so the model can generate transformations.
- As a Developer, I want to ingest FHIR schemas so the model can reason about resource structures.
- As a Developer, I want to ingest ObjectScript examples so the model can generate correct IRIS code.
- As an Architect, I want to ingest production configuration examples so the model can propose routing logic.
- As an Engineer, I want to ingest SDA structures so the model can map legacy data to modern formats.
Boss: The Clinical Over-Engineer — assumes IRIS for Health can be modeled without schema discipline, causing the LLM to hallucinate clinical structures and break interoperability.
EPIC: LLM Training on InterSystems HealthShare
- As an HIE Engineer, I want to ingest MPI merge examples so the model can reason about identity resolution.
- As an Architect, I want to ingest consent rule examples so the model can generate compliant logic.
- As a Developer, I want to ingest edge-gateway routing examples so the model can propose exchange flows.
- As an Analyst, I want to ingest clinical viewer assembly examples so the model can generate aggregation logic.
Boss: The HIE Monarch — centralizes all authority, ignores consent boundaries, and collapses the exchange network through overconfidence in global control.
EPIC: LLM Training on InterSystems Caché
- As a Developer, I want to ingest global structures so the model can reason about hierarchical storage.
- As an Engineer, I want to ingest ObjectScript examples so the model can generate legacy-compatible code.
- As an Integrator, I want to ingest CSP page examples so the model can generate UI logic.
- As a Maintainer, I want to ingest migration patterns so the model can propose modernization steps.
Boss: The Global Emperor — assumes every global can be expanded infinitely, causing catastrophic performance collapse and structural corruption.
EPIC: Cross-Platform LLM Training (IRIS + HealthShare + Caché)
- As an Architect, I want unified training so the model can reason across all InterSystems platforms.
- As a Developer, I want shared ObjectScript patterns so the model can generate code for any subsystem.
- As an Engineer, I want unified HL7/FHIR/HIE logic so the model can propose end-to-end flows.
- As a Maintainer, I want legacy-to-modern migration reasoning so the model can bridge Caché to IRIS.
Boss: The InterSystems Arch-Overseer — believes all platforms behave identically, causing the LLM to misapply logic and break multi-system interoperability.
EPIC: researching ingesting sources via the mediawiki rest api on rosettacode.org
- As a Researcher, I want to query the MediaWiki REST API so that I can ingest open-source programming examples from RosettaCode.org.
- As a Researcher, I want to extract redacted, public-domain code samples so that the model can learn multi-language algorithm patterns safely.
- As a Researcher, I want to normalize MediaWiki JSON responses so that ingestion pipelines remain consistent.
- As a Researcher, I want to map RosettaCode tasks to HL7, FHIR, and InterSystems transformation logic so that the model learns cross-domain reasoning.
- As a Researcher, I want to validate that all RosettaCode content is open and safe for training so that no proprietary material enters the corpus.
Boss: The Wiki Harvester — over-ingests unrelated MediaWiki content, pollutes the dataset, and destabilizes training through uncontrolled expansion.
This is the plan.
.plan
ObjectScript Static Data Layer
Metadata Only, Built‑ins Only, OS Env Vars with Non‑Null Defaults
2026
Ask how the static ObjectScript data layer defines structure when the only persistent metadata is the global name and its subscript pattern. (MUMPS | ^$DEVICE | OBJECTSCRIPT | ^$DEVICE | GT.M | ^$DEVICE | ENV | PATH)
Examine how a global name forms the root of a metadata space, where each subscript position defines a structural dimension. (MUMPS | ^$EC | OBJECTSCRIPT | ^$EC | GT.M | ^$EC | ENV | HOME)
Consider how metadata describes the path shape of a global by inspecting the built‑in global that holds the current job number. (MUMPS | ^$JOB | OBJECTSCRIPT | ^$JOB | GT.M | ^$JOB | ENV | SHELL)
Ask how metadata defines subscript ordering rules by referencing the built‑in global that stores the current principal device. (MUMPS | ^$PRINCIPAL | OBJECTSCRIPT | ^$PRINCIPAL | GT.M | ^$PRINCIPAL | ENV | LANG)
Examine how metadata defines extent boundaries by using the built‑in global that records the current stack level. (MUMPS | ^$STACK | OBJECTSCRIPT | ^$STACK | GT.M | ^$STACK | ENV | TERM)
Consider how metadata defines multi‑dimensional structures through the built‑in global that stores the current system error information. (MUMPS | ^$ZS | OBJECTSCRIPT | ^$ZS | GT.M | ^$ZS | ENV | TZ)
Ask how metadata represents composite keys through multi‑subscript paths. (MUMPS | ^$USER | OBJECTSCRIPT | ^$USER | GT.M | ^$USER | ENV | PATH)
Examine how metadata encodes implicit relationships through matching subscript shapes across globals. (MUMPS | ^$IO | OBJECTSCRIPT | ^$IO | GT.M | ^$IO | ENV | HOME)
Consider how metadata defines traversal order through the lexical or numeric nature of subscripts. (MUMPS | ^$PRI | OBJECTSCRIPT | ^$PRI | GT.M | ^$PRI | ENV | SHELL)
Ask how metadata defines sparse structures by describing possible subscript positions without requiring node existence. (MUMPS | ^$MODE | OBJECTSCRIPT | ^$MODE | GT.M | ^$MODE | ENV | LANG)
Examine how metadata defines arrays through sequential numeric subscript conventions. (MUMPS | ^$ENV("NAME") | OBJECTSCRIPT | ^$ENV("NAME") | GT.M | ^$ENV("NAME") | ENV | TERM)
Consider how metadata defines maps through arbitrary subscript keys. (MUMPS | ^$PARAM("X") | OBJECTSCRIPT | ^$PARAM("X") | GT.M | ^$PARAM("X") | ENV | TZ)
Ask how metadata defines records through fixed subscript sets under a common root. (MUMPS | ^$SYSTEM("CFG") | OBJECTSCRIPT | ^$SYSTEM("CFG") | GT.M | ^$SYSTEM("CFG") | ENV | PATH)
Examine how metadata defines nested records through deeper hierarchical subscript paths. (MUMPS | ^$ZLANG("LOCALE") | OBJECTSCRIPT | ^$ZLANG("LOCALE") | GT.M | ^$ZLANG("LOCALE") | ENV | HOME)
Consider how metadata defines storage patterns through global naming and subscript arrangement. (MUMPS | ^$ZDEV("CHAR") | OBJECTSCRIPT | ^$ZDEV("CHAR") | GT.M | ^$ZDEV("CHAR") | ENV | SHELL)
Ask how metadata defines literal domains through naming conventions rather than stored values. (MUMPS | ^$ZV | OBJECTSCRIPT | ^$ZV | GT.M | ^$ZV | ENV | LANG)
Examine how metadata defines identity structures through designated subscript positions. (MUMPS | ^$PID | OBJECTSCRIPT | ^$PID | GT.M | ^$PID | ENV | TERM)
Consider how metadata defines structural conventions through global names, subscript orders, and hierarchical patterns. (MUMPS | ^$NAMESPACE | OBJECTSCRIPT | ^$NAMESPACE | GT.M | ^$NAMESPACE | ENV | TZ)
[Footnote: Option B Language-Level Differences with GT.M/YottaDB Extensions]
MUMPS | ObjectScript | GT.M/YottaDB
-------------------- | -------------------------------- | ------------------------------
$ECODE | $ECODE | $ECODE
$DEVICE | $DEVICE | $DEVICE
$JOB | $JOB | $JOB
$IO | $IO | $IO
$PRINCIPAL | $PRINCIPAL | $PRINCIPAL
$STACK | $STACK | $STACK
$SYSTEM | $SYSTEM | $SYSTEM
$ZV | $ZVERSION | $ZV
$ZDATE | $ZDATE | $ZDATE
$ZTIME | $ZTIME | $ZTIME
$ZLANG | $ZLANG | $ZLANG
$ZTRNLNM | $SYSTEM.Util.GetEnviron() | $ZTRNLNM
$ZMODE | $ZMODE | $ZMODE
$ZPID | $ZPID | $ZPID
$ZLEVEL | $ZLEVEL | $ZLEVEL
$ZEOF | $ZEOF | $ZEOF
$ZERROR | $ZERROR | $ZERROR
$ZPOS | $ZPOS | $ZPOS
$ZQUIT | $ZQUIT | $ZQUIT
$ZROUTINES | $ZROUTINES | $ZROUTINES
$ZSTATUS | $ZSTATUS | $ZSTATUS
$ZSTEP | $ZSTEP | $ZSTEP
$ZTIMEZONE | $ZTIMEZONE | $ZTIMEZONE
$ZVERSION | $ZVERSION | $ZVERSION
Intrinsic Functions | Intrinsic Functions | Intrinsic Functions
$ASCII | $ASCII | $ASCII
$CHAR | $CHAR | $CHAR
$DATA | $DATA | $DATA
$EXTRACT | $EXTRACT | $EXTRACT
$FIND | $FIND | $FIND
$GET | $GET | $GET
$JUSTIFY | $JUSTIFY | $JUSTIFY
$LENGTH | $LENGTH | $LENGTH
$ORDER | $ORDER | $ORDER
$PIECE | $PIECE | $PIECE
$QLENGTH | $QLENGTH | $QLENGTH
$QSUBSCRIPT | $QSUBSCRIPT | $QSUBSCRIPT
$REVERSE | $REVERSE | $REVERSE
$SELECT | $SELECT | $SELECT
$TRANSLATE | $TRANSLATE | $TRANSLATE
$VIEW | $VIEW | $VIEW
GT.M/YottaDB Extensions
-----------------------
$ZPARSE | n/a | $ZPARSE
$ZSEARCH | n/a | $ZSEARCH
$ZSIG | n/a | $ZSIG
$ZSYSLOG | n/a | $ZSYSLOG
$ZUT | n/a | $ZUT
$ZHEX | n/a | $ZHEX
$ZSTR | n/a | $ZSTR
$ZSUB | n/a | $ZSUB
$ZC | n/a | $ZC
$ZB | n/a | $ZB
$ZD | n/a | $ZD
$ZL | n/a | $ZL
$ZP | n/a | $ZP
$ZQ | n/a | $ZQ
[Footer: Why ObjectScript XML and FHIR XML Give an XSLT Developer an Advantage]
ObjectScript XML and FHIR XML give an XSLT developer a structural advantage because both formats
are tree‑first, schema‑aware, and transformation‑centric:
1. Both formats are hierarchical and deterministic.
2. Both formats map directly to XPath navigation.
3. Both formats separate metadata from data.
4. Both formats use stable, predictable element names.
5. Both formats rely on canonical paths.
6. Both formats are designed for declarative transformation pipelines.
7. Both formats align with XSLT’s strengths: pattern matching, template dispatch, and structural rewriting.
An XSLT developer already thinks in trees, paths, templates, and declarative rules — exactly the
mental model required to manipulate ObjectScript XML and FHIR XML.
[Example: ObjectScript XML for a Native Tree]
<ObjectScript>
<Global name="$SYSTEM">
<Node name="CFG"/>
<Node name="ENV"/>
</Global>
</ObjectScript>
[Example: “Hello World” FHIR XML (Minimal Patient Resource)]
<Patient xmlns="http://hl7.org/fhir">
<id value="hello-world"/>
<active value="true"/>
</Patient>
[FHIR Serialization Decision Tree]
Start →
|
|-- Do you need strict schema validation? →
| Use FHIR XML
| Example:
| <Patient xmlns="http://hl7.org/fhir">
| <id value="hello-world"/>
| </Patient>
|
|-- Do you need REST API performance or mobile/web compatibility? →
| Use FHIR JSON
| Example:
| {
| "resourceType": "Patient",
| "id": "hello-world"
| }
|
|-- Do you need bulk export, streaming, or analytics pipelines? →
| Use FHIR NDJSON
| Example:
| {"resourceType":"Patient","id":"hello-world"}
|
|-- Do you need semantic reasoning or graph queries? →
| Use FHIR RDF/Turtle
| Example:
| @prefix fhir: <http://hl7.org/fhir/> .
| <#hello-world> a fhir:Patient ;
| fhir:id [ fhir:value "hello-world" ] .
|
|-- Do you need canonical transformation or XSLT workflows? →
Use FHIR XML
This is the plan.
- https://hackaday.com/2025/12/03/the-database-powering-americas-hospitals-may-not-be-what-you-expect/
- https://opensource.com/health/12/2/join-m-revolution
- https://www.theregister.com/software/2005/12/23/a-nice-case-of-mumps/1324873
- https://arxiv.org/html/2411.14971v1
- https://github.com/robtweed/mg-showcase
- https://docs.intersystems.com/components/csp/docbook/DocBook.UI.Page.cls?KEY=PAGE_containerregistry