Following is an example of method_missing in action :

class Roman
  def romanToInt(str)
    # ...
  end
  def method_missing(methId)
    str = methId.id2name
    romanToInt(str)
  end
end

Results:

r = Roman.new
r.iv
»
4
r.xxiii
»
23
r.mm

Following is a C# 4.0 equivalent using the dynamic keyword.

using System;
using System.Dynamic;
namespace Vitraag.MetaProgramming
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic Caesar = new Roman();
            Console.WriteLine(Caesar.IV);
            Console.ReadKey();
        }
    }

    class Roman: DynamicObject
    {
        int StringToRoman(string s)
        {
            // Simple logic needs a better function
            switch (s)
            {
                case "I" : return 1;
                case "IV": return 4;
                // Should add more cases
                default: return 0;
            }
        }

        public override bool TryGetMember(GetMemberBinder binder,
             out object result)
        {
            result = StringToRoman(binder.Name);
            // This logic could be improved
            if ((int)result != 0)
            {
                return true;
            }
            return false;
        }
    }
}

Running the above code gives us the result as: 4

I’ll be adding more thoughts in coming weeks around meta-programming and having an extensible type and formatting system. Please feel free to share your best reads or comments on the topic below!

For those new to the idea, Quantified Self is a forum for users and tool makers to interact and share knowledge, experiences, tips & tricks to enable better self discovery through tracking. The Seattle chapter of this forum is managed by great folks at Habitlabs (Buster & Amelia) and Limeade (David).

With over 20 people joining the conversation it was great to see energy in self-tracking and self-improvement. Most people seem to share the problem of not knowing what to do with the data they have. It was interesting to see Amelia to talk about positive effect of just tacking a 10-day running average of her weight. Robby gave a great presentation on his month long project to track transportation costs, and the conclusion to use a bicycle.

I’m looking forward to hear more this community. I have been trying to use HealthVault PowerShell and excel with power-pivot to track and visualize few properties of Health data.

I’ll try to keep this post short, give a general overview of International Statistical classification of Disease (ICD), talk a little about ICD-9 & ICD-10 and leave your folks will links to practical advise on converting from ICD-9 to ICD-10, and SNOMED-CT to ICD-10.

What is ICD?

Attempts to classify diseases started in 17th century. The prime driver of this classification was to gather statistics around cause of death could across countries. Over 19th century the list of international diseases rapidly versioned, the sixth version was published in 1946, ninth in 1975 and 10th in 1990! The revision 9th and 10th are most common and referred as ICD-9 and ICD-10 respectively.

Overtime many countries started using ICD codes for insurance re-imbursements with a slight modification (clinical modification – CM), and that is a prime reason why these code have become so prominent in the Health-IT industry.

The ICD code is an alpha-numeric code which tracks a diagnosis, symptoms and cause of death.

So what’s ICD-9-CM, ICD-10-CM?

ICD-9-CM stands for the 9th revision of ICD with clinical modifications. This is most prevalent code used in the US healthcare industry for insurance re-imbursements. Following are few examples of how this code looks -

Fig 1. ICD-9-CM codes

Note the format. AAA.BB. AAA stands for category and BB stands for etiology, anatomical site or manifestation.

ICD-10-CM is the 10th revision of ICD with clinical manifestation. All the US hospitals are mandated to use these code, starting 2013 only these codes will be re-imbursed by the payers / insurance providers. Following are few examples of how this code looks -

Fig 2. ICD-10-CM codes

Note ICD-10 is of the format – ZAA.BBBC

Z is supposed to Alphabetic. AA are numeric. Together ZAA make the category.
BBB is alpha-numeric and together they make etiology, anatomical site or manifestation
C is stands for code revision or extension

How do I convert from ICD-9 to ICD-10?

Shahid has a very good blog-post on practical advise for converting ICD-9 to ICD-10.

Following are interesting tools for the conversion -

1. ICD-9 data converter – http://www.icd10data.com/Convert
2. Who online training – http://apps.who.int/classifications/apps/icd/ICD10Training/

And what about mapping ICD-10 to SNOMED-CT?

As you have noticed ICD is more simplistic than SNOMED, rightfully since its original intent was to help with cause of death statistics. Overtime the ICD codes have been used in billing and increasing they have gotten specialized that they need to represent the diseases accurately. Naturally they have moving closer towards SNOMED-CT.

WHO has a preview release mapping some SNOMED-CT codes to ICD-10-CM.

Few notable incubators -

1. Healthbox – Chicago based incubator, powered by Sandbox industries.
2. Blueprint – NYC based incubator started by Brad Weinberg founder of Shapeup. Blueprint is focused more on enterprise startups
3. Rock health – A San Francisco based incubator. Most of the startups in the program are consumer focused.

Why are healthcare startups hard?
I’ll highlight few of very well known facts about the health industry that serve as a big barriers for the startups –

1. Regulations – There are a plethora of law’s regulating the industry – HIPAA, FDA etc.; and that in turn puts a lot of tax on a healthcare startup.
2. Long sale cycles – Enterprise sales in the industry have very long sales cycles.
3. Complicated economy – Someone has to give-up a dollar for startup to make one, its very hard to “generate” wealth in the Healthcare economy; it’s a very much a zero-sum economy. Additionally, the payer equation many times doesn’t align up well with other players in the system.

So what are the characteristics of the winners?
Lets take example of very of the well-established healthcare startups and see if there are themes for success.

1. Disruptors – Patients like me fundamentally challenges the current curing methodologies and introduces the social aspect to finding effective treatments using the power of social interaction.
2. Enablers – Zocdoc enables convenience for scheduling appointments and finding physicians. The service has seen a great uptake owing to fact that most folks like the ease of online scheduling.
3. Cost Savers – Given that the health care economy is zero-sum a lot of companies fit this bill. Most enterprise companies playing in the re-admission management, pre-registration, public health reporting, meaningful use etc. play in this realm.

Dear reader — anything else you as an obvious wining characteristics? Please comment below..

Most of the above incubators are still taking applications for their next set of companies, and if you have been pursuing a health care venture what better time to apply!! Act on your innovative ideas..

PS C:\Users\vaibhavb\Desktop> Import-Module HvPosh
PS C:\Users\vaibhavb\Desktop> Grant-HVaccess

Is auth done?
Is Auth done – (Y)?
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help
(default is “Y”):y

PS C:\Users\vaibhavb\Desktop> Get-Things weight | Format-Table

When        Value       Key         TypeId      TypeName    EffectiveDa       State       Flags  IsPersonal IsDownVersi
te                                                     oned
—-        —–       —         ——      ——–    ———–       —–       —–  ———- ———–
10/12/2011  175 pounds  f7931e43… 3d34d87e… Weight M… 10/12/20…      Active        None       False       False
10/12/2011  385         d4b2e3ab… 3d34d87e… Weight M… 10/12/20…      Active        None       False       False
8/5/2011… 160         382e9e1f… 3d34d87e… Weight M… 8/5/2011…      Active        None       False       False
7/7/2010… 250 pounds  1a76d859… 3d34d87e… Weight M… 7/7/2010…      Active        None       False       False
…

PS C:\Users\vaibhavb\Desktop> Add-Things weight 170
PS C:\Users\vaibhavb\Desktop> Get-Things weight | Format-Table

When        Value       Key         TypeId      TypeName    EffectiveDa       State       Flags  IsPersonal IsDownVersi
te                                                     oned
—-        —–       —         ——      ——–    ———–       —–       —–  ———- ———–
10/13/2011  170 pounds  45abc16d… 3d34d87e… Weight M… 10/13/20…      Active        None       False       False
10/12/2011  175 pounds  f7931e43… 3d34d87e… Weight M… 10/12/20…      Active        None       False       False
10/12/2011  385         d4b2e3ab… 3d34d87e… Weight M… 10/12/20…      Active        None       False       False
8/5/2011… 160         382e9e1f… 3d34d87e… Weight M… 8/5/2011…      Active        None       False       False

So what is the cool thing going on above? Well in five commands we are able to authenticate, get and put weight readings in to HealthVault!

This is all possible owing to the magic of powershell, and a powershell HealthVault module (HvPosh). This is just a start, there all kinds of nerd scenarios this HealthVault command line shell can do! Think about command line automation for getting in all that data in to HealthVault, working with test data, understanding the healthvault xml, and doing all sorts of quantization on your personal health data!! The possibilities are limit-less, well at least for the command line nerds .

So what is HvPosh?

HvPosh is a HealthVault powershell module currently running as a desktop client application. The source for this module is up on github and you are welcome to contribute more functions, cmdlets, test data or infact various analysis modules!

Take HvPosh for a spin, and yep! this is right out of oven so be gentle!

Fig 1. HvPosh On GitHub.

Last year I talked about Programming Healthcare Silos, the Direct project is an innovative way to bridge the silos in Healthcare and provide a secure provider to provider and provider to patient mode of data exchange.

If you are around stop by for the talk or come grab us of any relevant questions. We’ll post the slides online after the talk.

I’m looking forward to the conference, and particularly to the talk on personal data locker project and more. It has been a pet peeve of mine to build some akin to that, with the locker talk and more awesomeness hopefully I’ll get to hacking on it soon!

In the last post we enabled Mood Tracker to enter new data in to HealthVault.  Before I start this post in details of adding graphing layer let me motivate it by showing what the graph for Mood Tracker looks like -

Fig 1. Graphing Over the 7 days

The interesting aspect here is that we are tracking Mood, Stress and Wellbeing over a period of one week, and looking for patterns in terms of mood, stress and wellbeing correlations. There are better ways to do graphing for this data but this is a simplistic approach.

In order to be able to get data from HealthVault for a specific time period we will have to update the implementation of our GetThings method to allow for a filter for effective date max and min. Notice the interesting formatting we need to do to make DateTime serializable.

private static string EffDateMinXml(DateTime? effDateMin)
{
    if (effDateMin != null)
        return
            string.Format(@"<eff-date-min>{0}</eff-date-min>",
                effDateMin.Value.ToString("yyyy-MM-ddTHH:mm:ss.FFFZ",
                            CultureInfo.InvariantCulture)
                );
    else return "";
}

Once we are powered with a way to selectively get information from HealthVault we can simply make use of the awesome open-source amCharts library. Infact I added it to the project with one-click using NuGet Package manager (note to self: may be post a version of HealthVault Windows Phone library on NuGet). Here is a snippet of how I configured the SerialChart.

<amq:SerialChart x:Name="EmotionsChart"
                BorderThickness="1"
                DataSource="{Binding EmotionList}"
                CategoryValueMemberPath="FormattedWhen"
                AxisForeground="White"
                PlotAreaBackground="Black"
                GridStroke="DarkGray" Height="463" Width="450">
    <amq:SerialChart.Graphs>
        <amq:LineGraph ValueMemberPath="Mood"
                        Title="Mood" Brush="Blue"
                        StrokeThickness="6"
                        BorderBrush="Cornsilk"/>
        <amq:LineGraph ValueMemberPath="Stress"
                        Title="Stress" Brush="#8000FF00"
                        StrokeThickness="8" />
        <amq:LineGraph ValueMemberPath="Wellbeing"
                        Title="Wellbeing"
                        StrokeThickness="2"
                        Brush="#80FF0000"/>
    </amq:SerialChart.Graphs>
</amq:SerialChart>

 

Note that the formatting for the X-Axis is derived by a special property we added to the EmotionalStateModel, it probably is not the right place to add that property.

Over last few days I have implemented an interesting idea to make entering emotional state information easier similar in themes as the original mood tree but more focused on making data entry fun , I call it vMudi.

So next time w’ll look at vMudi.

I showed an interesting LINQ query which sort the HealthVault items returned from a getthings. Well actually turns out that we can do this more efficiently by using the max attribute on group filter in the getthings. The items returned by HealthVault are sorted by eff-date and if we get the first one it should be the latest item!

        public static void GetThings(string typeId, int maxItems,
            EventHandler<HealthVaultResponseEventArgs> responseCallback)
        {
            string thingXml = @"
            <info>
                <group max='{0}'>
                    <filter>
                        <type-id>{1}</type-id>
                        <thing-state>Active</thing-state>
                    </filter>
                    <format>
                        <section>core</section>

Before we get to the topic of this post and discuss how we can put new items in to HealthVault, here a screen shot of how the application looks like once we have enabled the put and prettied up the last reading a little bit –

Fig 1. MoodTracker with put enabled!

We can see that for each of the states i.e mood, stress and wellbeing we have a nice slider which lets the user capture their state and we can want this information uploaded with current time stamp once the user hits Save!

        // Save the reading to HealthVault
        private void button1_Click(object sender, RoutedEventArgs e)
        {
            EmotionalStateModel model = new EmotionalStateModel();
            model.Mood = (Mood)c_MoodSlider.Value;
            model.Stress = (Stress)c_StressSlider.Value;
            model.Wellbeing = (Wellbeing)c_WellbeingSlider.Value;
            model.When = DateTime.Now;
            HealthVaultMethods.PutThings(model, PutThingsCompleted);
            SetProgressBarVisibility(true);
        }

Lets get a bit deeper in how the PutThings call works. It fetches the relevant information from the base object and submits that to HealthVault. The design in this case might be a little wary since the put parameters are coming from the emotional state object as well.

        /// <summary>
        /// PutThings Method
        /// </summary>
        /// <param name="item">The health item to upload</param>
        /// <param name="responseCallback">Function to resolve callback</param>
        public static void PutThings(HealthRecordItemModel item,
            EventHandler<HealthVaultResponseEventArgs> responseCallback)
        {
            XElement info = XElement.Parse(item.GetXml());
            HealthVaultRequest request = new HealthVaultRequest("PutThings", "2", info, responseCallback);
            App.HealthVaultService.BeginSendRequest(request);
        }

Voila!! We have an application which can read and update information to HealthVault!

Next Time: We will focus on adding the History or Charting aspects of this application!

So the data type we settled on was EmotionalState, we can find a sample xml for this type on the HealthVault Developer Center.

Out first goal is to be able to display this type in our application. We need test data for emotional state so we add test information to our developer account from type samples.

Fig 1. Adding Emotional State sample to HealthVault record.

Please note: You need to be signed in to developer.healthvault.com to add the above sample.

We can verify that this sample is added to our record by using the HealthExplorer.

Fig 2. Emotional State Samples in developer account.

The easiest way to get-things from HealthVault is using the GetThings version 3 method. A Get on things can be performed using various filters for the purposes of this application which just retrieve all the active things of type Emotional State.

                HealthVaultMethods.GetThings(EmotionalStateModel.TypeId, GetThingsCompleted);

To make it easier to work with GetThings I implemented a simple abstraction on the method in HealthVaultMethods class.

Now once we can get thing emotional state things we need to perform two things on the client side.

1. Sort them in the date order and pick the latest one

For this item Linq to XML comes in very handy, just in three lines we can make this query work!

 // using linq to get the latest reading of emotional state
 XElement latestEmotion = (from thingNode in responseNode.Descendants("thing")
         orderby Convert.ToDateTime(thingNode.Element("eff-date").Value) descending
         select thingNode).FirstOrDefault<XElement>();

2. Parse them for the mood, stress and wellbeing data.

We can achieve this my creating a model for Emotional State. Have a good model makes if super easy to parse the XElement to the object we need –

 EmotionalStateModel emotionalState =
     new EmotionalStateModel();
     emotionalState.Parse(latestEmotion.Descendants("data-xml").Descendants("emotion").Single());

XElement and lazy evaluation makes our job super-simple, compared to XPathNavigator -

 public void Parse(XElement emotionalState)
 {

        this.Mood = (Mood) System.Enum.Parse(typeof(Mood),
           ((XElement)emotionalState.Element("mood")).Value, true);
        this.Stress = (Stress) System.Enum.Parse(typeof(Stress),
            ((XElement)emotionalState.Element("stress")).Value, true);
        this.Wellbeing = (Wellbeing) System.Enum.Parse(typeof(Wellbeing),
            ((XElement)emotionalState.Element("wellbeing")).Value, true);
 }

 

Now we are ready to show the latest emotional state reading!!

 

Fig 3. Latest Emotional State Reading in Mood Tracker!

Next Time: We will look at how we can enter new data with Mood Tracker!