Data liberation now, interoperability standards later

By Shawn Vincent

I'm a pragmatic person and I like to solve real-world problems. Waiting for a day when a single unified standard will solve my connectivity problems doesn’t appeal to me. I want these problems solved right now. In health care, the data that needs to be transferred is complex. A universal standard (a common understanding of specific data in a specific format for inter-vendor communication) is a complicated problem that many smart people have been working on for a very long time. We may solve this problem eventually; but we haven't solved it today.

Fortunately, getting everybody to agree on a standard isn’t the only way to solve the problem. If you look around a bit in the high-tech world, you find other approaches.

The issue of inter-vendor communication is not unique to healthcare IT. It comes up everywhere, from social media networks and forums to word processors and customer relationship management software. There are no universal standards in these realms, but people still move data around every day. How does this happen?

Let’s look at a simple example: blogs. These online social media tools are widely used by both amateur and professional writers. Blogs have been around long enough now that there is a growing need for authors to move their content from one vendor’s platform to another. In simple terms, they need to export data from one blog and import it into another.

Blogs have, compared with healthcare IT, very simple data requirements. They consist of posts, each with a title and a date. There are sometimes labels to categorize posts, comments, and a few other features. Surely somebody has built a universal standard for blogs, right?

Well, yes and no. There are a few standards – like RSS and Atom, among others – in wide use. Unfortunately, these standards don’t cover every blog feature, and blogs by different vendors have slightly different data models.

So how do people move their data? Let’s look at Blogger, a popular blog platform by Google. Google has a group called the Data Liberation Front that is dedicated to making product migration like this work. In their page about Blogger (http://www.dataliberation.org/google/blogger), they say that the export format for Blogger is the Atom standard. However, they add: “Presently, Blogger only allows the import of Blogger-generated export files – there are no options for syncing or importing from other blogging service[s].”

What could this mean? The data is in the Atom standard, right? Presumably, any data exported in the Atom standard should be importable by anybody using the standard, right?

Unfortunately, it’s not so simple. Atom is a generic standard, and services like Blogger use either vendor-specific extensions or stylized usage that doesn't translate well between systems. In other words, the data is just complex enough to make trivial interoperability complex. Sounds a lot like the problems we’re seeing in healthcare IT, doesn’t it?

However, the blog community is getting around it:

“To aid in this process [of importing from other blogging services], the Data Liberation team hosts the Google Blog Converters open source project. This project also powers a hosted conversion service with support for migrating from WordPress, MovableType and Livejournal [popular competing blog platforms].”

In other words, the blog community simply uses third-party tools to transform the data. It’s basic systems integration.

The point is that the blog community is getting stuff done. They’re solving problems. They’re transferring data.

Instead of waiting for the perfect standard, they’re simply (a) making their data available; and (b) letting people transform it as necessary. And it works. An active community, or ecosystem, has grown up around this issue, and if you want your data transferred from one platform to another, you can do it pretty easily.

Looking at healthcare IT in this context, I would like to propose an alternative to standards. Instead of standards, let’s talk about data liberation.

Google gets this right. Instead of striving to get every player to agree on a unified standard, it uses a popular, lowest-common-denominator standard (Atom) and extends it so you can get your data out. If you want to use the simple Atom data, you can use that. If you want to do something fancier, you need to do some systems integration work.

I argue that in addition to requiring vendors to send and receive data using standards, vendors should be encouraged to send and receive their proprietary data as well. Sure, it doesn’t conform to a standard and you need to do systems integration work to use it, but that’s far better than not having access to it at all.

With lowest-common-denominator standards that don’t export every piece of your data, your data is still locked inside the vendor’s system; only the subset that conforms to the standard is accessible.

Let’s liberate the data first, then develop standards. If we can get the data in and out, we can have real connectivity today (with a bit of third-party development effort), instead of when (or if) the standards finally solve the problem for us.

Shawn Vincent is Vice President, R&D, at MD Practice Software LP.

Posted February 14, 2013