So how did my talk go?
My talk went reasonably smooth, overall I was happy with what I could put together in limited time. According to the polls and some in person conversations people seemed to like the fact that I attempted to break it down with a technical deep dive, especially taking time to go deeper on on-the-wire protocols and standards.

The talk was recorded by Robert Wood Johnson foundation and I’ll post a link around when they make it available online.

OSCON Healthcare Track
I attended most of the talks at OSCON HealthCare track. This was the first Healthcare track at the conference, in my opinion it turned out splendid! Andy Oram has a good summary of the first, second & third day, and Fred Totter has links to interviews of some of the presenters. Over the three days of Healthcare track I learnt a lot about various NHIN and VistA projects.

Sessions
In addition, I attended a few session and a couple of tutorials. I’ll summarize some of them below with key take-away or interesting links :

• Cloud computing  – “Situation Normal, Everything Must change”: If nothing else I would highly recommend watching this key-note, no new content but the Simon Wardley is very effective in communicating his point about Cloud computing and managing technology in general.
• Asynchronous Programming – I learnt a lot about nginx web-server and the principles behind node.js. Ilya’s talk was specific to Ruby but learnt a lot about the perf gain PostRank has gotten owing to Asychcrony. He was gracious to have lunch with me and one of interesting things he mention was use of AMQP. AMQP is near real-time (low latency, high throughput) general purpose message standard used by most of the guys on Wall-street! An open source implementation of the same is RabbitMQ.
• Another Go at Language Design: Since I’m a compiler wonk and systems’ programmer, it was great to see Rob Pike’s presentation on Go language and specially see the fast Go compilers, most optimizations are owing to managing the dependencies for linking.
• jQuery – The presentation on jQuery was very detailed even for a novice. I particularly liked the show-casing of selectors to write succinct iavascript code.
• Graph Database – Neo4j : At fore front in the NoSQL camp Neo4j offers up to 1000x performance gain over relational database for implementing applications like a social network. Key different from RDBMS is that the Graph itself is the main index!
• Android: I learnt a quite a bit about Google Android and their development methodology. Android developers in general focus a lot on remove perceivable slowness from the application (called “Jank” in Google lingo).Anything which takes more than 200ms to process is considered bad. A good rule of thumb to prevent “Jank” is to never stall the event loop.  To spur further Android excitement Google gave away the soon to be de-commissioned Nexus one devices in one of their workshops. 
• Open stack:Open source system for creating Amazon EC2-like clouds. In fact this project is open sourcing of the RackSpace cloud system.
• An interesting project to cross-compile Android projects to iPhone.

Birds of feather session on Healthcare Standards
I participated in the BOF on Healthcare Standards.

The conversation started by highlighting the classic problem of how people who have been in the industry want semantic interoperability  and how the new entrants in the area want simple systems. I contribute to this conversation by pointing out that if standards get developed with industrial strength open implementations they are more tend to be more sane (read NHIN-D).

The conversation then drifted towards terminologies. Everyone in the room was outraged with CPT and AMA’s greed J. David Riley (head of NHIN project) added to the conversation saying that ICD-10 procedures are designed to replace CPT. I contributed to the conversation detailing how it’s difficult to develop a coherent system with all the different vocabularies with different licensing requirement and incomplete  mappings to each other. David was then gracious to detail a project done in the federal government where they attempted to come up with a common terminology service by inventing something akin to OIDs for each terminology. He is hoping that he can open source those terminologies sometime soon. Brian Bhelendorf then added to the conversation asking how can we enable or create open source terminologies. I was suggested that may be can do something like RxNorm to create a uniform mapping system which the terminology licensors can adopt. There was more discussion on this topic, no one felt that UMLS was adequate.

PS: I’ll update the this post with more links and thought-blocks as I remember .

If you are planning to attend the conference do drop me a note, and perhaps some check-out my talk. I’m also looking for audience for dry-runs of my talk..

• Windows Phone 7 Series Developer Studio – I love the free tools provided to develop for Windows Phone. Love the fact that Silverlight and XNA studio are very thoughtfully and seamlessly working with-in Visual Studio Express. The developer studio is lean and performant, its great to see the tool tips for Pixel widths right in the design surface. I was able to write a simple Health app in about 10 mins, the Phones are not out yet but the

• Open Data Protocol : Very interesting competition to GData . OData – http://www.odata.org/ is a combination of AtomPub with data-typing and querying conventions. OData is supported out of the box by Windows Azure services, and Netflix launch an API powered by OData – http://odata.netflix.com/Catalog/. It will be great to learn more about batching and syncing aspects of this protocol (Interestingly Microsoft Sync Platform also launched an asymmetric syncing capability).
• Data Relay : MySpace which is the largest .NET site open sourced their middle-tier GU – http://datarelay.codeplex.com/. DataRelay has a framework for message passing, transaction management on top of a performant caching system. Apparently it uses The CCR (Concurrency and Coordination Runtime) from Microsoft Robotic Studio .
• A very interesting presentation of building your own MVVM framework – I love the use of Continuations and a programming model where the framework takes care of concurrency and events! The presenter is author of Caliburn – http://www.codeplex.com/caliburn.
• Font-ing it out – For a font newbie like me, all i know about Fonts I learnt from Kevin Larsons presentation : http://live.visitmix.com/MIX10/Sessions/DS07 

Twitter hashtag for mix is #mix10 and session recordings are available at http://live.visitmix.com

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

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.

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!

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!