Jump to navigation Jump to search
There are a number of things that need to be nailed down to define application expectations in terms of backwards and forwards interoperability:
- Search parameters can be defined by local implementations in the same namespace as the “official” search parameters. The result is that introducing new search parameters in the future could collide with existing local parameters
- Recommend requiring that local search parameters be required to have a specific prefix (e.g. ‘_’)
- CS coded elements are defined as fixed enumerations, including validation in the schemas. In the future, we may need to add additional codes to some of these enumerations. How do we expect old systems to respond?
- Require to accept and ignore?
- Require to reject?
- Case by case/system’s choice?
- We occasionally have min-Occurs 1 elements that have a choice of data types or resource types. In the future, we may introduce additional data types or resource types into the allowed set. How do we expect old receivers to handle receiving a new element they weren’t expecting (and didn’t get an element they were expecting)
- Same issue can occur where we have a required element that has a single type but in the future we choose to add an additional type. (Presume we can never drop a type?)
- At the moment, our schemas enforce that only the declared elements are specified. However, in the future, additional elements could be added. Are we going to promise to add them at the end or could they appear anywhere? How are systems expected to behave when they receive unexpected elements? (They won’t pass schema validation, and because the schemas have optional elements, there’s no way to make them pass.
- Are we allowed to loosen or tighten the minimum cardinality and if so, how do existing implementers cope?
- Can we deprecate an element? Do we still expect implementations to populate them? Forever? For a fixed time?
- Can conditions (constraints) be added or changed
- Can mustUnderstand or mustSupport be changed?
- Can vocabulary bindings be changed for non-“code” elements? What if it’s a Coding?
- Can the source resources or returned resources by an Event be changed?
- Profiles – even more questions about what can change in a Profile.
- Are implementations allowed to define their own extensions to the REST operation parameters (or are those considered to be independent services and not RESTful FHIR services?
- Given that we’re seeking *lots* of implementers for the DSTU(s), and we’re hoping that at least some of those implementations will be production systems, how are we going to manage interoperability with new DSTUs and eventual normative version, given that backward compatibility rules are looser and we don’t yet have a mechanism for identifying what version you’re seeing
- When we add new elements to “core” that happen to be “must understand”, how does that get communicated in the instance?
- When does this occur – only after normative, or between DSTU releases? Should we start doing it now?
- Should we consider declaring “mustSupport” on core elements?
Resolution (to date)
- Let people know that we are trialing inter-version compatibility during the DSTU process
- No guarantee of consistency between DSTU versions while we work this out
- expectation of breaking changes between DSTU and Normative edition
- we will clarify the methodology implications through the DSTU process
- FHIR project team will draft working guidelines to test through that process