A view from inside the HealthVault

Cover It Live event for HIMSS Conference:

Connectivity of Care Document (CCD) is a collaborative standard driven by HL7 & ASTM for exchanging summary format clinical information.

For ease of understanding one can think of CCD standard comprising of several elements in an hierarchical fashion:

1. HL7 V3 Data Types and Reference Information Model (RIM) : At the base of CCD standard are the HL7 Data types and Reference Information Model.  HL7 V3 data types define the structural format of the data carried. The HL7 RIM expresses the information content of work done by HL7 working committee to define data types, relationships between them, and a state transition model for some entities.
2. Clinical Document Architecture (CDA): The HL7 CDA defines the specific structure and semantics for any clinical document for purposes of exchange. CDA document can be encoded in XML. A CDA document if encoded in XML must comply to the schema. NIST has a good CDA validation tool.
3. CCD Implementation Guide: The CCD implementation guide describes the constraints on the HL7 Clinical Document Architecture R2 specification in accordance with requirements set forward by ASTM (the governing body behind CCR).

Fig 1. Components of CCD Standard

Related articles in this series :

1. Understanding Vocabularies. Wait! What did you say?
2. Understanding Vocabularies #2 – HealthVault Recommendations
3. Understanding SNOMED CT
4. Understanding CCR

Happy new year!! I’m summarizing the Best of 2009 on Reviving the Health Revolution blog -

Understanding Health IT Standards
In April I started a series which aims at helping a programmer understand Health IT standards. I aim to develop this series further in 2010 and I’m also working on a compilation of essays on Health IT, you are encouraged to provide feedback here.

The series so far talks about Vocabularies, HealthVault Data Types in context of various Health IT Standards, SNOMED-CT, CCR.

WalkMe
I started the year with posting about WalkMe, and followed in July with a detailed post about data syncing architecture of this application. This simple walking application is now tracking over 2 million steps! If you want to add a live pedometer signature to your outlook e-mail follow this post. Future features and development of this application is primarily driven by user feedback.

HealthVault Applications using ASP.NET MVC and on Windows Azure
In July I did a post showing how one use ASP.NET MVC framework for developing HealthVault applications. The HealthVault .NET SDK is primarily geared towards ASP.NET Webforms.

In October I wrote about how one can deploy HealthVault applications on Windows Azure! This is has been a very popular article, check out some live samples running on Windows Azure here.

Flu Management
In April I post about Ushahidi’s Crisis management application for Swine Flu. In October I blogged in detailed about Microsoft’s Flu Management center and my little Flu widget.

HealthVault XML APIs
The HealthVault .NET SDK serves majority of HealthVault partners but last year we saw increase in adoption of our XML APIs consuming it through the Java SDK, Python SDK , Ruby Wrapper or the raw XML layers. The series on working with XML layer is a good starting point.

Connected Health Conference
For those of you who missed this conference in June, you can catch up here.

Programming Techniques & Data Analysis
Functional Programming, Memoization .. ring a bell? Well I plan on dwelling more on programming techniques and data analysis in 2010.

Feel free to let me know you top post for 2009, in comments.

The first release (R1.0) of HealthVault Java Library has been very successful and is being extensively used by HealthVault partners. This library provides basic capabilities to authenticate and exchange XML with HealthVault platform.

Over last few months, thanks to Rob, Siddhartha & Ali we have gained some momentum in developing this library. The current beta release (JAXB integration) includes beginnings of an object model for HealthVault methods and types.  Kudos to Rob for some great work here.

If you are already using the community supported HealthVault Java Library, I would encourage you to try  the new JAXB Integration release. It will be great to get your feedback before we make this work as our core development codebase. If you are new to working with HealthVault from Java please follow the getting started guide.

Looking forward to comments, feedback and contributions!

Functional programming is becoming more and more mainstream these days. C# 3.0, Python & Ruby have embodied many of the functional approaches. Microsoft even is releasing F# as first class language in Visual Studio 2010. F# is complaint in syntax with OCaml. Back in the day (at UC Santa Cruz) I wrote a language translator using OCaml and loved the symbolic computation capability a functional language provides.

In this version of interesting programming concepts, I would like to highlight type system based pattern matching available in F#/OCAML, its very unique and extremely useful if you are parsing a structured list or working on a symbol table:

type Expr =
  | Num of int
  | Add of Expr * Expr
  | Mul of Expr * Expr
  | Var of string

let rec Evaluate (env:Map<string,int>) exp =
    match exp with
    | Num n -> n
    | Add (x,y) -> Evaluate env x + Evaluate env y
    | Mul (x,y) -> Evaluate env x * Evaluate env y
    | Var id    -> env.[id]

In fact listed below is most of the code for code-generator main loop from my tool translating Berkeley Logic Interchange format (BLIF) to Reactive Modules :

let emit_atoms() =
  let vemit_atom a b = begin
    match b with
      Symb(Input,_,None) -> ()
    | Symb(_,_,None) -> emit_unmarked_atom a
    | Symb(_,_,TableAtom
         (Controls(p),Awaits(q),Relations(r))) ->
           begin
         emit_atom_start ();
         emit_table_io_stmts p q;
         emit_init_update ();
         emit_relations p q r;
         emit_atom_end ();
           end
    | Symb(_,_,ResetAtom
         (Controls(p),Awaits(q),Relations(r))) ->
           begin
         emit_atom_start ();
         emit_reset_io_stmts p q;
         emit_init_update ();
         emit_relations p q r;
         emit_atom_end ();
           end
...
    | Symb(_,_,SameAs(t)) -> ()
    | _ -> raise (Failure("Unknown Error"))
  end
  in
  Hashtbl.iter vemit_atom symTab;

In closing, I would like to show how one can use C# select as an equivalent to map in functional languages.

// Get elements in the store where filenames are GUIDs
public IEnumerable<Guid> GetKeys()
{
    string[] files = Directory.GetFiles(_StorePath);
    // functional equivalent: return files.map(|t| new Guid(t))
    return (files.Select( p => new Guid(
            Path.GetFileName(p))));
}

Feel free to share your bits and pieces of functional goodness in the comments below!