I am delighted to announce that I can finally talk about the feature our team has been building for the next version of Visual Studio. Yesterday at TechEd North America, we announced the new Head Up Display capability in Visual Studio. This feature provides developers with an augmented view of code in which we try and surface meaningful information about your code, on your code.

There are so many people involved in this work there is no way to recognize them all. This is a major investment for our product group and we look forward to refining the experience as we move toward a release date.

I will start blogging more on this topic now that the covers have come off the feature. In the meantime, here is the video of Peter Provost’s talk at TechEd yesterday, introducing the feature. The show and tell for the Head Up Display features begin at about 22 minutes into the talk.

Previous post

Jackson Data Binding Message Serialization

Next post

So Long and Thanks for all the Manifestos : Redux

11 Comments

  1. June 5, 2013 at 8:06 am

    Looking forward to VS2013! These “Head Up Display” features are very groovy (“cool” is so passe).

  2. June 5, 2013 at 11:55 am

    I’d love to see this include Mercurial and Git support in addition to TFS.

    • June 7, 2013 at 5:25 pm

      There is no question that Git is on the horizon. We care about Git. Git is love.

  3. June 8, 2013 at 5:14 am

    Very groovy (thanks B. Clay) — it does make it easier to track those references…could have used it yesterday in fact.

    What would be really useful would be the ability to “DEFINE” some of those references for others. For example, if I could identify that code X really mattered to Code Y (even though the reference was a few layers down), and made those visible in the references section (with an explanation). Maybe it’s based on some XML in the summary line – but that would be mucho useful as well

    • June 9, 2013 at 10:54 pm

      @Andrew, what is the relationship you are trying to navigate there?

      Inheritance relationships, extensions, implementations, etc?

      • June 10, 2013 at 3:16 am

        Probably relationships. I’m likely looking about it the wrong way – as it would almost be impossible to define this but if my “SavePage” method called a method named “RecalculateScore” and that method called “CalculateFormula”, it would be useful to see that tree when looking at the CalculateMethod.

        As one of the senior developers on a project, I’m trying to encourage the developers to think about where the code is REALLY being called from, instead of just the direct reference.

        Imagine that in a “cloud” or “web” graph, a method that is only called a few times but those methods are then called by a piece of code that calls LOTS of other methods, That could be a more important piece of code in terms of making changes affecting things, more than a piece of code that only has one access point.

        I realize in writing this that what I’m describing is definitely out of scope for the “heads up display” but the way it appears just seems like it’s calling out for a related add-in.

        It’s very awesome – and as always, awesomeness just pushes for more awesomeness.

        • June 10, 2013 at 11:06 am

          Actually, what I hear you asking for here is a new indicator that might be called “Call Hierarchy” which makes a lot of sense. Is that right?

          • June 10, 2013 at 11:08 am

            Yes – that sounds perfect.

  4. June 11, 2013 at 3:55 pm

    These features look great.
    Will the “Head Up Display” features be accessible from the keyboard?
    Will other test frameworks apart from MS test be supported?

    • June 16, 2013 at 10:33 am

      yes.
      yes.

      • June 16, 2013 at 11:10 am

        Fantastic.