Outcomes from Atlanta HL7 Meeting for FHIR

Well, I’m now nearly home from the long week that is the HL7 Working Group meeting. It now goes for 7 long days from Saturday morning through to Friday afternoon. This meeting was held in Atlanta – I’d like to make some comment about Atlanta but the only time I got out of the hotel was to go to Dave Shaver’s Corepoint Party (thanks Dave).

This post is a summary of the progress that occurred at the meeting for FHIR.

General

Two years ago, I conceived of something that has grown into FHIR. Since then, I’ve watched the ripples of our work expand – from just a narrow community in HL7, to include all of HL7 and the wider standards community, and then out into the middleware vendors. Now, the EMR vendors are starting to pay attention. The process is accelerating too – I never expected the EMR vendors to start paying attention to our work until at least after we had completed the DSTU phase (ballot for a “Draft Standard for Trial Use”). And as the ripples spread, the community of people working on FHIR or excited about it grows, and our growth accelerates. This creates it’s own firestorm.

(Oh, and yes, I’m now starting to come to terms with the never-ending FHIR jokes and puns).

Connectathon

For FHIR, this meeting commenced with the 3rd FHIR Connectathon. This Connectathon continued on the linear progress that we’ve been making, with more participants, more structure, and more success. We continue to have people turning up to do a cold start, where they have had their interest ignited, but have done no reading or code prior to the day. As usual, the participants are exchanging resources by the end of the first day.

Other participants have established code bases, and perhaps have attended Connectathons previously, and are honing the breadth of their implementations and working on their conformance.

Each Connectathon, we collect a list of issues – things that are broken in the specification, or where the decisions we’ve made make things harder than they should be. Also, each Connectathon, the list gets shorter and more about the corners of specification, which shows that the Connectathon process is really paying off.

The next Connectathon will (probably) be focused on PHR access to EMRs, and promises to be bigger and better (and some new participants are planning to bring physical devices that talk FHIR to the Connectathon, which should be cool).

Preparation

Our major focus right now is on preparing the specification for ballot. In order to be ready for ballot, there’s a bunch of things that we need to do around ensuring that the basic structures and quality assurance processes are in place that ensure that the resources really are useful. Like all such processes, the depth of detail that goes into this preparation is necessary but not of interest to the implementers. But it’s all going well, I think. And my particular thanks to the 30-40+ people from vendors, governments, consultants, and academics who are now working on the under-appreciated task of bringing the breadth of their experience to bear on the design of the resources.

Right now, out focus is on rounding out the resource definitions by mid-July so we can do quality assurance prior to opening the DSTU ballot in Mid-August.

There’s still some outstanding issues that we haven’t cracked yet. I’ll be making some blog posts on these in the future to solicit input from outside the community.

There’s been a little talk about FHIR having teething difficulties – and certainly there’s lots of heated discussion inside HL7 over design, approach, and so on. I’m not worried about this – these things need to happen and they bring value to the standard (see Establishing Compromise). It’s a dialectic thing.

Security

We made some real progress on the question of what the FHIR specification needs to say about security at this meeting. There’s a draft security page on this now – please look at this and comment.

Note that while the page says that it’s not really HL7′s business to develop the resources to administer the security engine, we’ve had a number of requests to do exactly that – given enough pressure from the users, it might happen, though if it does, we’ll have to find the right group of people to work on that.

Positioning & Marketing

One thing that we’re now going to have to start working on is how to position (and then market) the specification. As the specification has rounded out, it’s become quite fully featured, and a full fledged implementation is now quite a bit of work – not that simple. I’m not really concerned, though, because few systems will need to implement all the features that we’ve defined (this is a classic problem with standards).

But I’m starting to hear people express the belief that maybe FHIR isn’t quite as simple as they thought. Well, it’s never going to be simple – FHIR is going to be a standard for exchanging information about healthcare, not a simple cookbook for REST to be adapted to healthcare applications in a bespoke manner (why do that? there’s already plenty of advice and examples out there). The re-usability of FHIR, and the fact that it grapples with difficult things like patient linking/merging, for instance) means that it’s necessarily more complicated than a simple single application API, but also worth while. Still, I think that some people are thinking it’s more complicated than it is.

Part of the solution to this is to start working on a use-case based view of the specification: given a particular problem, how do I use FHIR to solve it? Some initial work is here. Contributions to this page are welcome. We’ll be doing other things as well, so watch this space. The FHIR Button is coming at you!

Using FHIR outside HL7

One big issue was resolved at this meeting. We’ve been having this running discussion about how to use FHIR outside the scope areas that HL7 plans to cover. I’ve blogged about this before. At this meeting we agreed that people will use the FHIR methodology to define their own resources, whether we want them to or not (and, indeed, we in the core team are all doing that ourselves).

So we’ve agreed that we’re going to define a process for people to do this, and work on enhancing the tooling and the public servers to support this process, and to work on ways to bring this work back towards HL7.

Partnerships

Finally, our partnerships outside HL7 are going well. We’re going to be balloting resources in partnership with DICOM, IHE and the ISO Healthcare Devices Community. There’s still some open process issues around quite how these are going to work, but the actual design is coming along well.

A commonly asked question is whether ONC is going to start using FHIR. ONC have been interested in FHIR from the start, but they are driven by their requirements to deliver working standards in very short time frames. ONC won’t be able to use FHIR in their work until it’s a DSTU, and even then they will have to take things on a case by case basis. Pretty much the same applies to other national programs – some things they need to do will lend themselves to FHIR, and they’re looking hard at what it might become, but you don’t lightly change direction of such a big and expensive ship.

IP Rules & the HL7 community

HL7 is starting to wrestle with a number of difficulties caused by the decision to make it’s IP freely available for implementation. The community is still trying to figure out exactly how free free is, how unencumbered free actually is, and what the consequences are for HL7 structure, revenue and expenditure. Maybe revenue will go up, maybe it will go down – we don’t know yet.

FHIR, on the other hand, remains truly free, open and unencumbered, and will continue to do so. FHIR is already driving new participation at HL7 – people who haven’t been able to take part before (or haven’t been interested). I’d like to think that this will make a significant contribution, but whether it does or not, FHIR is starting to really take off.

Securing your REST API

Over the weekend, I spent several days working on integrating OAuth authentication and authorization into my FHIR server. Really, I’m primarily interested in authentication – if the user authenticates to the server, they get open access. So the functionality I implemented was that I will accept logins from any Facebook or Google user.

Integrating with Google and Facebook was almost ridiculously easy – The only thing that slowed me down was the documentation for the Google call to get a user’s profile details – I needed to provide an Application Key for charging purposes (not applicable at my volume though), and the documentation for the login process didn’t mention that (I found the solution on stack overflow).

But doing this generated some interesting discussion between the FHIR implementers preparing for the upcoming connectathon about the usefulness or otherwise of OAuth as a authentication protocol for a FHIR RESTful API. To illustrate the problem, consider this architecture, which seems like a pretty common architecture for the kind of  FHIR deployments involving OAuth:

Example fhir architecture

 

In this case, the user logs into the healthcare application – which is likely to be either a mobile or a web application, and authenticates to it using OAuth via something like Facebook, Google, etc as the OAuth server. For the user, this is convenient and observationally we know that this is really important. But, then, on their behalf, the application wants to use one or more FHIR services. How does this work? It’s pretty hard to find good information about this on the web, and the standard advice – such as this one here – really just doesn’t address this question well (at least, not that I could find).

As far as I can see, you have several options to handle this case:

  • The FHIR services – which offer the FHIR RESTful API – don’t authenticate the user. They authenticate the healthcare application, and the user is invisible to FHIR service, and vice versa
  • The FHIR services use OAuth themselves. The healthcare application asks the user to log in to each FHIR service provider independently using OAuth. 
  • The FHIR Services provide a custom login which allows the healthcare application to pass the OAuth access_token to the FHIR services – they can use this to authenticate the end-user

I find each of these unsatisfactory for different reasons.

The first option can work just fine, but the user (patient, for example) has no visibility of the data storage, and there’s no really any capacity for the user to share their own data in their own way. Whether that’s good or not depends on the context. If it’s good, then the first option is for you. And so in this case, OAuth is not appropriate on the RESTful server – just some kind of application secret

The second option has the advantage that the user is explicitly aware of the data storage, and manages that directly. They can have multiple data stores, and explicitly grant access to a particular application. That’s a different kind of use case that would work well for a few users, but would simply bamboozle the majority of users, especially those who most need healthcare and to share their data. I think that this would be a problem for the healthcare application offering. But this is the consequence of the RESTful API offering OAuth based authentication. (btw, There’s a supplementary technical problem for a web based healthcare application in this case – at the end of the authentication process, the user will get redirected away from the healthcare application to the RESTful API provider. There’s a variety of options to deal with this, but they all have problems).

The third option works well in practice, but does mean that the FHIR service provider gets the same level of access to the user as the healthcare application – and the healthcare application has to trust the FHIR service provider to impersonate it.

Tim Bray pointed out (thanks!) that there’s a 4th option if you login through Google – as part of the OAuth process, Google returns an OpenID connect JWT token, and rather than sharing the access token, the healthcare application could just pass the id_token to the FHIR Service. The FHIR service could use the id_token to verify the user identity, and that access has been granted to the application by the user. This would mean that the FHIR service has no access to any Google services associated with the user (including getting basic descriptions of the user) – it would need the access token for that. Another problem with this approach is that Facebook doesn’t generate a token like this (or any functional equivalent, so far as I could see anywhere).

Choosing to secure your RESTful api using OAuth isn’t as straightforward as it seems, then.

p.s. My server supports all 3 options from the top list – see the documentation.

 Update: Related Links

Question: Does HL7 free IP mean open?

Question

Now that the HL7 IP is free, can I just send someone I am working with a copy of the specification?

Answer

No. While the IP is now licensed as free for use, it’s not actually open. In particular, only HL7 is allowed to distribute the specifications themselves. So you’ll have to direct your trading partners to the HL7 website to get a copy for themselves.

This is really to drive membership. HL7 has a real legitimate case for driving membership – developing the standard isn’t cheap, and has to be paid for somehow. In the absence of selling the standard, rent has to be extracted from somewhere.

There is an unfortunate corollary of this though: under the current rules, no one is allowed to offer a web site or a mobile app that offers enhanced additional views of the HL7 standard (like this, this, or this, though my read of the fine print is that this is allowed. However I’m not sure about this, or this). But a mobile application that provided good views of this stuff would be greatly prized by many implementers. As you can see, there’s going to be some developments in this space, so I’ll revisit this post when that happens.

Note: the FHIR specification is not affected by all this – it remains open, and redistribution is not under any restrictions at all.

FHIR – what is interoperability?

Well, FHIR is starting to really make progress. There’s been quite a few blog posts about it recently:

Not everyone is convinced yet, but the proof of this pudding is in the eating, not academic evaluation of the source of the ingredients.

Not only is the full breadth of the specification coming together (http://hl7.org/implement/standards/fhir/resourcelist.htm), the HL7 governance & development processes are settling down, the load on my test server is going up (I can tell, I get the amazon bill!), and implementation experience is growing, with some projects going into production this year.

Which means, yes, prior to the finalization of the specification itself. In fact, that’s always been a feature of the FHIR experience: the advantages of FHIR are sufficiently compelling that projects are choosing to adopt it now, in spite of the fact that it’s not final – it’s already the best option (or is that, the least worst option?). When people talk to me about the features of FHIR that drive this, they consistently mention the following things:

  • Simplicity
  • Current technology (REST, JSON..)
  • The tooling stack that’s part of FHIR
  • Extensibility

The really intriguing item in this list is the tooling stack – one of the things people really like about FHIR is that they can (potentially) leverage the existing approaches, resources, and technology to create functionality of their own in a new space.

That actually presents a challenge to HL7. One of the goals for HL7, which is an essential part of the goals for FHIR, is “Out of the Box” interoperability. It’s a widely shared experience of HL7 implementers – two different products have made different choices about how to implement v2, so when you try to connect them up, they can’t talk to each other. Typically, rectifying this costs >$50,000 all up (including project management, vendor costs, total life cycle etc). So the HL7 community really wants different implementations to simply work together. Note that by “the HL7 community” I am describing one part of it – the part where implementers buy software from vendors to meet their business requirements.

Meeting this goal means locking down FHIR so that only HL7 can publish the engineering constructs, so that everyone can just work together. On top of this, it means good definitions, careful induction of new use cases, etc. To me, this is the classic HL7 context.

But there’s a different group of implementers at the table too. Mostly, these are institutions that perform a substantial amount of in-house development. For these developers, the ability to naturally and seamlessly leverage FHIR in other directions is very much an attraction. The fact that the solutions they develop doing this won’t interoperate with other implementations “out of the box” is completely irrelevant since they’ll never interoperate with them at all anyway.

The problem with this is that we all actually live in a continuum between the two extremes – all implementers have a mix of custom and OTS software. It’s just that the percentages differ between them, and across time as the bespoke vs commodity pendulum swings. There’s a new component to this in FHIR: external public-ish web sites (such as if, e.g. Facebook decided to put up a FHIR server linked to face book accounts for people’s own PHR – it’s not quite public, but it’s certainly not private). These will change the weighting – but not the overall picture.

I think that we are going to have to define some special conformance level. something like “Commodity FHIR”, where out of the box interoperability is an expectation, and an alternative one like “FHIR-leveraged” where interoperability out of the box isn’t assured. Is going to be messy, and it’s going to cause everyone trouble. But this mess isn’t of FHIR’s making – it’s a problem inherent in the real world.

 

Question: HL7 v2 case sensitivity

Question:

Are segments in an HL7 message case-sensitive….Example; if I change it from MSH to msh will the message still go through

Answer

Yes. Segments are case sensitive. most parsers will not accept a lowercase segment (in fact, none that i know of).

Generally, all other fixed values in the standard should also be treated as case sensitive unless you are specifically told otherwise.

Australian FHIR Connectathon and Tutorial

We’ll be holding a FHIR connectathon here in Australia as part of the IHIC 2013 – International HL7 Interoperability Conference in Sydney in late October 2013 (around 28-30).

This is an opportunity for Australasian implementers and vendors to get practical experience in FHIR. Here’s why you should consider attending:

  • Find out what all the excitement is about
  • Get a head start building FHIR into your products
  • Get a real sense of what FHIR is good for, and what it isn’t
  • Help ensure that FHIR meets real-world Australasian requirements
  • Be a recognised part of the FHIR community
  • Connectathons are real fun

Realistically, this is likely to be the only connectathon held here in Australia (at least, the only one prior to the publishing of FHIR as a DSTU). The connectathon is focused around actual exchange of content, not theory (there is a place for theory, but the connectathon is not part of it). So it’s really suitable for technical staff, though we have had a few non-technical staff brushing off the cobwebs on their development skills just so that they can participate in the HL7 connectathons.

FHIR connectathons are always start with exchanging patient information, and then we build on that depending on the interests of the actual participants. We’ll be putting out an call for expressions of interest in a few months time, after which we’ll start clarifying what our actual scenarios will be. However I expect that MHD (mobile friendly version of XDS) is likely to be in scope.

In about July/August I’ll hold a 1 or 2 day tutorial here in Melbourne looking at FHIR in depth, with a focus on implementation issues. This tutorial will start with a general review of FHIR, and then look at depth at the FHIR reference platforms, how to use http tools to exercise and debug interfaces, how to convert from v2 to FHIR and vice versa, and look in detail at various models for implementing a server.

If you might be interested in attending this tutorial, drop me a line at grahame@healthintersections.com.au – I’m trying to get a feel for event hosting issues such as facility and cost.

Question: FHIR and un-semantic interoperability

Question:

 I did not understand the blog post about un-semantic interoperability.  Can you elaborate?  Will FHIR provide any of this un-semantic interoperability?

Answer:

Well, the original post on unsemantic interoperability is just pointing out that many people mis-understand the nature of what semantic interoperability is trying to achieve:

We’ve had semantic interoperability in healthcare since we started having healthcare. Since the beginning of healthcare (by whatever definition you can use), healthcare practitioners have exchanged data using spoken and written words, and the semantic meaning has been clear (well, as clear as it can be given that human knowledge is limited).

So whatever it is that we are doing, it’s not introducing semantic interoperability. In fact, what we are doing is introducing a new player into the mix: computers. And not, in actual fact, computers, but the notion that there is something to be gained by processing healthcare information by persons or devices who don’t properly understand it. So, in fact, what we are actually doing is seeking for unsemantic interoperability.

It’s a matter of perspective. Perhaps, one day, we’ll really be working on true semantic inteoperability. But right now, we can afford to chase a lesser goal, which is exchanging data that can be used usefully in some limited pre-ordained ways.

And FHIR provides lots of this – that’s what it’s good at – getting data that is passably well self-described to be exchanged as easily as possible.

For systems that is really working towards genuine semantic interoperability, FHIR is actually a step backwards (though I’d argue that the easy availability of information that is passably well described is a huge improvement over the non-availability of information that is well described).

Question: Diagnostic reports in CCDA documents

Questions:

  1. What is the maximum number of clinical lab tests  that can be included in any C-CDA summary?
  2. Is the HL7 2.5.1 (or higher) messaging standard used to transfer the lab test results data?
  3. Can the C-CDA currently transfer the results of imaging or other kinds of diagnostic tests?
  4. How are the C-CDA test results displayed in the style sheet for viewing and sharing by physicians and patients?

Answers:

1. What is the maximum number of clinical lab tests  that can be included in any C-CDA summary?

There’s no theoretical limit, but there are practical considerations around how big the CDA document can get. The principle limit relates to how long the document takes to render.

2. Is the HL7 2.5.1 (or higher) messaging standard used to transfer the lab test results data?

Not in CDA. A different form is used, using CDA observations and battery organizers. Converting from v2 to CDA is relatively straightforward in theory, if the v2 messages are well constructed, but the variation in source messages is always a challenge.

3. Can the C-CDA currently transfer the results of imaging or other kinds of diagnostic tests?

Yes – see template 2.16.840.1.113883.10.20.22.1.5. This is the report (the interpretation) but it can include images as required using ObservationMedia

4. How are the C-CDA test results displayed in the style sheet for viewing and sharing by physicians and patients?

Well, that depends on what the source system puts in the narrative (assuming that the document narrative is displayed. If it’s not, then it’s entirely up to the receiving system to decide how it’s displayed, like with a v2 message).

 

 

Guest Post: HL7 Language Codes

This guest post is written by Lloyd McKenzie.  I’ve been meaning to get to it since the January WGM, but I’ve been wrapped up in other things (most recently HIMSS).  However, I agree with what Lloyd says.

Question: I have a need to communicate a wide variety of language codes in HL7 v3 instances, but the ISO Data Type 21090 specification declares that ED.language (and thus ST.language) are constrained to IETF 3066.  This is missing many of the languages found in ISO 639-3 – which I need.  Also, IETF 3066 is deprecated.  It’s been replaced twice.  Can I just use ISO 639-3 instead?

Answer:

The language in the 21090 specification was poorly chosen.  It explicitly says “Valid codes are taken from the IETF RFC 3066”.  What it should have said is “Valid codes are taken from IETF language tags, the most recent version of which at the time of this publication is IETF RFC 3066”.  (Actually, by the time ISO 21090 actually got approved, the most recent RFC was 4646, but we’ll ignore that for now.)  This should be handled as a technical correction, though that’s not terribly easy to do.  However, implementers are certainly welcome to point to this blog as an authoritative source of guidance on ISO 21090 implementation and make use of any language codes supported in subsequent versions of the IETF Language Tags code system – including RFC 4646 and RFC 5646 as well as any subsequent version there-of.

The RFC 5646 version incorporates all of the languages found in ISO 639-3 and 639-5.  However, be aware that while all languages are covered, there are constraints on the codes that can be used for a given language.  Specifically, if a language is represented in ISO 639-1 (2-character codes), that form must be used.  The 3-character variants found in ISO 639-2 cannot be used.  For example, you must send “en” for English, not “eng”.

Question: But I want to send the 3-character codes.  That’s what my system stores.  Can’t I use ISO 639-2 directly?

Answer:

No.  In the ISO 21090 specification, the “language” property is defined as a CS.  That means the data type is fixed to a single code system.  The code system used is IETF Language Tags, which is consistent with what the w3c uses for language in all of their specifications and encompasses all languages in all of the ISO 639 specifications plus many others (for example, country-specific dialects as well as additional language tags maintained by IANA.)

Question: Well, ok, but what about in the RIM for LanguageCommunication.code.  Can I send ISO 639-2 codes there?

Answer:

Yes, though with a caveat.  LanguageCommunication.code is defined as a CD, meaning you can send multiple codes – one primary code and as many translations as you see fit.  You are free to send ISO 639-2 codes (the 3-character ones) or any other codes as a translation.  However, LanguageCommunication.code has a vocabulary assertion of the HumanLanguage concept domain, which is universally bound to a value set defined as “all codes from the ietf3066 code system”.  That means the primary code within the CD must be an IETF code.  So that gives you two options:

  1. Fill the root code with the appropriate IETF code – copying the ISO code most of the time and translating the 3-character code to the correct 2-character code for those 84 language codes found in ISO 639-1; or
  2. Omit the root code property and set the null flavor to “UNC” (unencoded), essentially declaring that you haven’t bothered to try translating the code you captured into the required code sytem.

And before you mention it, yes, the reference to IETF 3066 is a problem.  The actual code system name in the HL7 specification is “Tags for the Identification of Languages”, which is the correct name.  However the short name assigned was “ietf3066” and the description in the OID registry refers explicitly to the 3066 version.  This is an error, as IETF 3066 is a version of the IETF “Tags for the Identification of Language” code system and the OID is for the code system, not a particular version of it.  (There have actually been 4 versions so far – 1766, 3066, 4646 and 5646.)  We’ll try to get the short name and description corrected via the HL7 harmonization process

Question: But I don’t want to translate to 2-character codes and I don’t want to use a null flavor.  Can’t we just relax the universal binding?

Answer:

We can’t relax the binding because the HumanLanguage concept domain is shared by both the ED.language property in the abstract data types specification (which ISO 21090 is based on) and the LanguageCommunication.code attribute.  The ED.language is a CS and so must remain universally bound.

In theory, we could split into two separate domains – one for data types and one for LanguageCommunication.code.  The second one could have a looser binding.  However, it’s hard to make a case for doing that.  There are several issues:

First, having two different bindings for essentially the same sort of information is just going to cause grief for implementers.  You could be faced with declaring what language the patient reads in one code system, but identifying the language of the documentation the patient’s supposed to read in a second code system.

Second, the IETF code system fully encompasses all languages covered by all the ISO 639-x code systems, plus thousands of others expressible using various sub-tags such as identifying country-specific dialects.  In the unlikely situation that you need a language that can’t be expressed using any of those, there’s even a syntax for sending local codes (and a mechanism for registering supplemental codes with IANA if you want to be more official).  So there should never be a situation where you can’t express your desired language using the IETF Language Tags code system.

Question: I don’t really care that I can express my languages in IETF.  I’ve already pre-adopted using ISO 639-2 and -3 in my v3 implementation and I don’t want to change.  Why are you putting constraints in place that prevent implementers from doing what they want to do?

Answer:

Well, technically your implementation right now is non-conformant.  And implementers always have the right to be non-conformant.  HL7 doesn’t require anyone to follow any of its specifications.  So long as your communication partners are willing to do what you want to do, anything goes by site-specific agreement.

However, the standards process is about giving up a degree of implementation flexibility in exchange for greater interoperability.  By standardizing on a single set of codes for human language, we’re able to ensure interoperability across all systems.  Natively, those systems may use other code systems, but for communication purposes, they translate to the common code system so everyone can safely exchange information.

If the premise for loosening a standard was “we won’t require any system to translate data from their native syntax”, there’d be no standards at all.  Yes, translation and mapping requires extra effort (though a look-up table for 84 codes with direct 1..1 correspondence is pretty easy compared to a lot of the mapping effort needed in other areas.)  But that’s the price of interoperability.

HIMSS 13 – New Orleans

I am at HIMSS 13 in New Orleans for the next few days.

I’ll be at the HL7 Booth (4325) on

  • Monday 4:30 – 6:00 (FHIR Presentation at 4:30)
  • Tues  3:30 – 4:30
  • Wednesday 11:00 – 12:30 (FHIR Presentation at 11:00)

The rest of the time, I’ll hanging out Booth 4219 (Dynamic Health IT).

Feel free to look me up