Skinner's Blog

Latest Videos and Info on VS11 Visualization Tooling

CameronS - MSFT — Sun, 11 Mar 2012 21:25:18 GMT

Wanted to make you folks aware of a few new videos that have been recently made showing the latest capabilities in the recently released beta for Visual Studio.

I just recently recorded a ~30 minute piece on the Visual Studio Toolbox site. Consider this video a refresher of the bits ( for those who weren’t familiar with the VS2010 capabilities ), as well as a quick summary of some of the latest features we’ve enabled.

For more in depth video, be sure to check out Chris Lovett’s recent video, which is much more comprehensive.

One of the more significant pieces of technology that we have created in support of the new Visualization and Dependency work in VS11 is known as the “Code Index”. Essentially, a LocalDB database where we house all the information of the assemblies you are trying to understand. Take a look at Jean-Marc’s recent post about the Code Index, and the SDK made available in the Visualization and Modeling SDK.

Debugger Canvas 1.1 Released

CameronS - MSFT — Tue, 31 Jan 2012 18:15:00 GMT

Since the initial release of the Debugger Canvas last summer, the team has been busy taking all the great feedback from you, acting on it, and preparing a new release. That release, Debugger Canvas 1.1, has just been released on DevLabs!

The teams has focused on fixing numerous bugs as well as addressing a number of performance issues, but has also poured a number of new features into this release:

Easily turn Debugger Canvas on or off, even in the middle of a debug session
Quickly navigate up and down the call stack in the canvas using the keyboard or the mouse
See Multiple threads together on the canvas, each thread identified by its color.
See recursive calls side by side
Edit code directly in the code bubbles ( this is now on by default ).

Please take this new release out for a test drive by going over to DevLabs and downloading this new version. And as always, the team welcomes and looks forward to your feedback. Please visit the DevLabs forum and let us hear about it!

Cheers!

Cameron

What do you think of Debugger Canvas?

CameronS - MSFT — Fri, 22 Jul 2011 15:14:02 GMT

The folks behind the Debugger Canvas project ( a few from my team, a few from MSR ) are very interested in picking your brain on what you like about it and what you don’t like about it. To that end, they are looking to get a one hour conference call together with a select group of folks who are willing to discuss their experiences to date and any ideas you may have to make the capability even better.

If you are interested, please send an email to debugcanvsignup@microsoft.com, and take a look at this forum post for more info.

Cheers,

Cameron

ALM vNext Announced at TechEd

CameronS - MSFT — Tue, 17 May 2011 15:10:09 GMT

We just finished announcing all the great new stuff that will be coming in the next version of Visual Studio, specifically talking about the Application Lifecycle Management features that you can expect in that release.

Please check out Jason Zander’s blog post about the announcements, and be sure to read this white paper. The white paper goes into quite a bit of information about many of the new features we announced yesterday, such as the new Unit Testing work, the new Storyboarding assistant designed to help manage lightweight requirements, Code Clone analysis, and so on.

It was a blast to demonstrate many of these features during the TechEd keynote with Jason, and it was even better to present at the ALM Futures foundational session immediately following the keynote, to go into a bit more detail and show a few other items we didn’t have time to get to in the keynote.

Exciting times!

MSDN Instant Answers

CameronS - MSFT — Fri, 13 May 2011 15:31:52 GMT

Wanted to point out a great new feature that the MSDN team has just made available when searching in the MSDN library. The feature is dubbed “Instant Answers”.

Try this out. Go to msdn.microsoft.com, then click the library tab ( or go directly there by clicking this link ). Now, type “Hashtable” in the search text box. You should see something like this as the first entry in the results:

The main thing I like about this is the quick access to the source code. Notice to the right of the C# and VB code, there is a little icon. Go ahead and click that. That will bring up a “text” window in the middle of your browser, allowing you to select that code, copy, and paste into your code. Very nice!

This is a new approach to search results within MSDN, and the amount of content that is ready for this new format is limited, but I think these folks are really doing a great job to make the content as accessible as possible.

What do you think? What do you like about it? Anything you’d change?

Cameron

New version of the Architecture Guidance

CameronS - MSFT — Sun, 01 May 2011 23:42:31 GMT

I’m a bit tardy in passing this information along, but the Rangers have recently ( April 18th ) released a new version of the Architecture Guidance.

Check out Willy’s post for more details, or go and download it directly here. A bunch of great prescriptive guidance on how to use the modeling and visualization capabilities present in Visual Studio 2010 Ultimate.

Cheers!

Cameron

Tech Ed North America 2011

CameronS - MSFT — Fri, 08 Apr 2011 15:19:14 GMT

Registration for this year’s Tech Ed North America is open. The convention is happening May 16-19 in Atlanta, GA this year.

This is going to be another great convention, with tons of new content, learnings, and simple collaboration guaranteed.

One of the things I’m very excited about at this years Tech Ed is the fact that we will be introducing many of the new Application Lifecycle Management ( ALM ) capabilities that will be in the *next* version of Visual Studio.

Jason Zander will be sharing the keynote message with CVP Robert Wahbe, and will be introducing the new capabilities. He and I will demo a few of them during that keynote, then I will continue the conversation in a Foundational session immediately after the keynote. All about the demos, with a few surprises along the way!

Hope you can make it out to Atlanta!

Cameron

Debugging Series: Symbols Server and Your Symbols

CameronS - MSFT — Wed, 06 Apr 2011 17:42:00 GMT

Last post, I gave you a simple introduction to Symbol Servers. I showed you how you can use the options in Visual Studio to quickly get access to Microsoft public symbols and how that could give you more information for your debugging sessions. However, I did not show you how you could add your owns symbols to the server, and more importantly, why that is a great thing to do.

Adding Your Symbols

Adding your symbols to the symbol server is a great practice, as it gives you a better chance of debugging one of your own executables or dlls without having to have that exact version of the image available. The typical use case here of course is support of a previously deployed app. You’re currently heads down working on V3 of your app but some customer out there is currently using V1 and reports some crashing or other bug with that version. How to maximize your chances of debugging the issue? Symbols server will certainly help, as long as you have added your PDBs to the server.

NOTE:

This is all predicated on the fact that you have indeed saved your PDBs. Even if you don’t plan to setup a symbol server, please please please save your PDBs!

How do you add your own symbols to the server? There’s an “easy” way, and then a “hard” way.

The Easy Way

The “easy” way is to use the support built into Team Foundation Server 2010’s Team Build. All you need to do is tell TFS where to drop your PDBs ( it must have permission to write to that directory ) and it will handle all the rest! You do that in your build definition file. Just set the “Path to Publish Symbols” to a public UNC share, and your golden. Here’s an example:

Behind the scenes, TFS is actually handling the steps you can manually do, which I’ll describe now.

NOTE:

I’ll be discussing the details of what the Source Server is all about in a future post. Stay tuned.

The Hard Way

You can manually add your PDBs to a symbol server by making use of the symstore.exe, which is part of the “Debugging Tools for Windows” package. Of course, since this is just a command line tool, you can incorporate the following steps into any MSBuild process.

Here’s an example of the command line options that I used to push my symbols to my store:

symstore add /f DebuggingSeries.* /s \\camerons4\Symbols\MySymbols /t "My Version 1" /v "1.0.0.0" /c "Manually adding"

This simply takes the exe and the PDB from my output directory ( the directory I ran symstore in ), and copied the symbols to the UNC folder specified.

Check out this page in the MSDN docs for more details, and here for all the details around the command line options.

If you take a look at the folder where the PDBs and exe get pushed, it should look something like this:

But what does this now do for me? Easiest to show through an example.

Symbols In Action

As I mentioned earlier, the classic case where use of a symbol server can really help is during a post-mortem debug session, where you have received a mini-dump of your application. So let’s simulate that use case by running the following bit of code on one machine, produce a mini-dump of that running exe, then take that dump over to another machine that does *not* have the source to the exe, load it into VS 2010, and see what we see.

Here’s the code I’m using for this example:

This code will run and break on the 50th iteration, allowing you to get a mini-dump in a later step.
Build that in Release mode, choosing “Any CPU” as the configuration.
Add the new symbols from your release directory to your build server, using the symstore.exe command I described above.
Run the app by hitting Ctrl-F5 in the Visual Studio. This will run your app without launching the debugger.
If you’re using the code above, you’ll see a console window appear and then an apparent “crash” dialog:
At this point, bring up the Task Manager by hitting Ctrl-Shift-Esc. Find your app in the process list, right click, and select “Create Dump File”:

A dialog will appear after a second telling you the location and name of the dump file that was just created. Keep that dialog up and handy, as you’ll be copying that dump file over to another machine next.
Copy the dump file over to another machine.
Open up Visual Studio 2010 and open the dump file.
Ensure that you have enabled all the symbol server settings in Visual Studio as described in my last post, as well as turned off “Just My Code”.
Add a new entry into the list of Symbol file locations that points at the UNC share that you enabled for your application symbols. My dialog looks like this:

NOTE:
There is a bug when attempting to open up a mini-dump for managed code in VS 2010 SP1. The workaround is to make a couple dlls available from the machine that the dump was generated to the machine that wants to analyse a dump. Details here. That’s what the last entry in the above image is doing, making those dlls available.
Now open the dump file in VS. You should see something like this in the VS doc well:
Click the “Debug with Mixed” link, outlined in read in the above image.
( I think mixed-mode debugging is worthy of its own post, so I’m not going to go into details on mixed-mode debugging right now. )
Visual Studio will go into a debug-like state. After a couple moments, take a look at your call stack and “Locals” windows. You should see your code showing up in the stack, as well as the value of your variables in the Locals window. Mine looks like this:

And my Locals like this:
Very cool! Now if you didn’t turn off “Just My Code” and were not using a symbol server, you would be presented with this dialog after clicking the “Debug with Mixed” link:

After hitting the “OK” button on that, your call stack would look something like this:

Not real useful.

Next Steps

I hope that gives you a good sense of how proper use of symbol servers can help you. In my next post, I’ll talk about a sister technology to symbols servers: Source Server. That will give you the added benefit of automatically opening the actual source code in the above scenario, in addition to the added data in the call stacks.

Stay tuned!

Cameron

Debugging Series: Symbol Server

CameronS - MSFT — Fri, 01 Apr 2011 22:19:07 GMT

Whether you are doing pre or post mortem debugging, whether you are using Visual Studio or WinDBG, one of the most important things you can do ( short of not writing the bug in the first place! ) to ready yourself for a productive debugging session is to establish the use of Symbol and Source servers. I’m going to give you some quick pointers of how to make use of these technologies in your day – to – day development process.

Symbol Server

What is it? Essentially, a symbol server is way to expose the symbols ( PDBs ) of your applications to the debugger in a way discoverable by the debugger regardless of where the debugger is run. This same thing is also true for system symbols as well. Not only that, it is a way to handle the versioning of those PDBs so that the debugger understands how to find version one of your symbols, vs. version two, and so on.

That’s all well and good, but why is this a good thing for the developer? Let’s look at what things look like when you *don’t* have a symbol server established.

Without Symbol Server

Here’s some sample code you have undoubtedly seen a zillion times by now:

using System;

namespace DebuggingSeries
{
   class Program
   {
      static void Main( string[] args )
      {
         Console.WriteLine( "Hello World" );
      }
   }
}

Fire up Visual Studio, create an empty C# project, drop in this source, put a break point at the Console.WriteLine line, and hit F5 to start the debugger.

After a moment, you will hit the breakpoint. Now, open up the Modules window ( while in the debugger, select the Debug->Windows->Modules menu item ):

While will open a tool window that looks something like the one below:

The “Modules” tool window shows you all the images ( dlls, etc. ) that are loaded in order to run the executable you are currently debugging. ( NOTE: This is a very useful tool window that many folks don’t know is available in the product, and has many uses which we won’t have a chance to go through today, but more some other time. )

You’ll notice in the image above that there is a Column called “Symbol Status”. Assuming you are running with default debugging settings that Visual Studio 2010 has shipped with, you’ll also notice that almost all the rows in the tool windows except the one I highlighted have the value “Skipped loading symbols.”. The one highlighted is the actual executable itself, which contains the symbols associated with the code you typed in. You’ll also notice that the “User Code” column is “No” for everything except for this last entry as well. More on this later.

Now bring up the “Call Stack” toolwindow ( Debug->Windows->Call Stack ). You should see something like this:

Cool, now let’s see what changes once you start using a Symbol Server, but there is actually one other thing you’ve gotta do before you see the goodness of the Symbol Server. You’ll need to turn off the “Just My Code” feature in Visual Studio.

Turn Off Just My Code

By default, Visual Studio 2010 has the “Just My Code” option turn on. This on on by default as it tends to reduce the amount of information a new user has to deal with when initially debugging inside Visual Studio. It tries to protect you by not drowning you in information.

I struggle with this option, as the intent of it is quite good, but in practice, I tend to always turn this off. ( I would love to hear your thoughts on whether or not this option should be on or off by default. Please fill the comment section with those thoughts! )

For the purposes of this post on this series, please turn off this option. Here’s how:

Go into “Tools-Options…” dialog, find the “Debugging” option on the left side of the dialog, and notice the “Enable Just My Code” option on the right:

Uncheck that box so that your dialog looks like this:

Now your ready to see the effects of the Symbol Server option.

With Symbol Server

Go back into the “Tools->Options…” dialog, and expand the “Debugging” option, and select the “Symbols” option:

Go ahead and click the check box next to “Microsoft Symbol Servers”. You should see a dialog box popup that you can safely ignore for now.

If you hit OK at this point, VS will automatically fill in a default directory that it will use for PDBs it pulls down from a public Microsoft site that contains the PDBs tied to the various versions of the framework DLLs.

If you are on a team of developers, it is a good idea to establish a common file share that all members of your team can use to house these symbols so that you don’t have to wait for the download of those images while you debug. The first developer who needs them would feel that delay, but everyone else on the team would simply pull from the common share.

For now, take the defaults and hit F5 again. You should be in the debugger waiting at the breakpoint.

Take a look at your Modules window now:

Notice how everything is loaded ( Symbol Status column reads “Symbols loaded.” ) and the User Code column reads “N/A”, ‘cause we disabled the “Just My Code Feature”

NOTE:

If you had turned on the Symbol Server options as described above but failed to turn off “Just My Code”, you would have seen something like the following in the Modules window, indicating that symbols were available to be loaded, but Visual Studio did not do so in order to abide by the constraints associated with “Just My Code”. Also, your call stack would look exactly the same as it did before.

Now take a look at your call stack window:

Compare this with the image of the call stack with the one I previously showed you above. Notice how much more information is now available to you?

And therein lies the point of all this:

When you are debugging, you need as much information as you can get in order to figure out the task at hand. You never know what little piece of information will be the clue that drives you towards the final solution.

Next Steps

This post is just scratching the surface. Next post in this series, I’ll dig a little further into some more of the benefits of the symbol server, and why making your own symbols available to your team in this manner will benefit you.

Cheers!

Cameron

New Docs for Windows Phone 7 Development

CameronS - MSFT — Thu, 31 Mar 2011 15:01:58 GMT

The Developer Guidance team has just released Building a Windows Phone 7 Application from Start to Finish in the MSDN Library. This content is intended to help developers with common challenges by putting the features together in a complete application from whiteboard to marketplace. It includes a running sample, guidance on core concepts for getting started with Windows Phone 7, and callouts for best practices and requirements. We hope it will provide a complimentary experience to the in-depth product documentation and quickstarts.

This is a great place to start for folks who haven’t done any WP7 development yet but want to. It covers almost all the major areas that a typical app would need to do. A notable topic that is *not* included is any information about the Push Notification Services, but more is on the way.

The guidance focuses on the following development tasks:

· Designing the user interface (UI) and choosing appropriate controls, icons, and graphics.

· Using the application bar and back button, and handling navigation between pages.

· Storing and retrieving data using isolated storage.

· Display data in controls, enabling user edits, and performing validation.

· Handling application deactivation, tombstoning, and reactivation.

· Publishing your application in the Windows Phone Marketplace.

The Visual Studio Debugger: A new series on an old topic

CameronS - MSFT — Mon, 28 Mar 2011 23:14:00 GMT

The Visual Studio Debugger has long been regarded to be one of the industries best debugger. The VS debugger’s ability to give developer’s insight into the running behavior and state of their .NET and native applications has been the foundation of what has made Visual Studio the IDE of choice for millions of developers around the world. Over the years, Visual Studio has seen many many features come and go into the product line, but the basic functionality of the debugger has been a constant. The ability to easily set breakpoints, step, view variables, and run have been at the heart of every developer’s workflow on the Microsoft platforms.

The debugger is a very interesting feature set in Visual Studio. It is one of those areas of the application where you can walk up to any VS developer and ask “Hey, do you know how to use the debugger?” They will undoubtedly look at you funny and say something like “Of course. What, is this a trick question?”

But how many developers actually know how to make the debugger do their bidding? How many know how to only use the debugger as a last resort, and when you do have to use it, maximize your time with it in order to get back to what you need to be doing, which is maximizing value for your end users? Turns out, the Visual Studio debugger gives you much more capability than simply the ability to set a breakpoint. The VS debugger has so many little features designed to make your life just a touch easier in many and different ways, most developers either haven’t discovered them, or they haven’t realized how those features can be applied in a way that maximizes their effectiveness.

There are many reasons for this, ranging from real discoverability issues with the features, to the lack of desire of the developer to reach for anything beyond the bare minimum feature sets. Regardless, I’d like to take the next few blog posts and examine some of these features. Features ranging from IntelliTrace, a marquee feature of the Visual Studio 2010 Ultimate product, to Trace Points.

There have been many articles, books, and blog posts written about the debugger, but it has been awhile since the topic has seen some fresh print. But as I said, since many of the features in the debugger have remained constant, much of the content out there is still quite relevant. I highly recommend checking out Jim Griesmer’s posts on the debugger, and of course, John Robbin’s debugging books are a must read. For the more advanced, I would highly recommend Mario Hewardt’s books ( this one and this one ). And of course, the MSDN documentation isn’t a bad place to start either, but for some reason most folks seem to forget or assume that the debugger isn’t documented! Go figure.

I don’t know how many posts will make up this series, but I do know that my intent is to provide you with more pragmatic information that you can use in your everyday. If I can help you save 10 minutes a day just by showing you some trick with the debugger, I’ve done my job!

Though I have a pretty good idea of the topics I’d like to cover, if you have a topic related to debugging inside Visual Studio that you are very interested in, please give me a shout either via the comments on this post, or via direct email.

Cheers,

Cameron

Lessons Learned developing a Windows Phone 7 App

CameronS - MSFT — Sun, 27 Mar 2011 08:02:15 GMT

Quite a few folks have been playing with the Windows Phone 7 platform, creating all kinds of crazy games, utilities, etc. for this new platform. I am no different. I simply couldn’t help myself, so once I had my new Samsung Focus in hand ( November of last year I believe ), I set out to build a game that I knew I would miss terribly after replacing my iPhone 4. This post is really less about the game however, and more about the various issues I found as I built the game and got it up on the marketplace.

I learned a ton while building this game, and ran into a number of little bumps along the way, mostly due to my inexperience with the new environment, but also due to issues with docs, limitations of APIs, etc.

Here’s a quick list of the things I ran into ( in no particular order ) that I’m hoping could save you some time when building your own WP7 apps:

Learned that trying to return anything other than HttpStatusCode.Ok or NotFound results in an exception being thrown when trying to retrieve the WebResponse during an EndResponse call. I was trying to return other status codes to indicate various error conditions when chatting between the phone and my web server.
I struggled a bit ( like a few folks ) trying to figure out the best way to deal with Splash screens. I found this blog post quite helpful. I also found that temporarily replacing the Content property of the rootframe with my splash screen page works like a champ. The general issue with the “Splash Screen” scenario is that you really don’t want the user to stop at the splash screen when hitting the Back button on the phone. You want the app to close. This was more of a problem than it really should be. Folks on the WP7 team are well aware.
I made heavy use of MVC 3 for this game, but only in regards to leaning on FormsAuthentication for auth and URL mappings for my REST based services. Worked great! One little issue I ran into here was the fact that if you want to get the FormsAuthentication ticket cookie back to a silverlight client, you have to be sure to set the HttpOnly flag to false on the cookie on the server side! That one had me stumped for *way* too long.
Be sure to make heavy use of the CacheMode for your UIElements if you are doing anything even remotely interesting. The performance impact was dramatically improved after I started using that little beauty. For general performance considerations, check out this MSDN doc page.
The Reactive Framework is fantastic! You’ve simply gotta check it out if you haven’t already. Check out this post for details, but the MSDN docs are a good place to start as well. Tons of great stuff on Channel9 as well.
Sometimes I would hit a problem when trying to deploy my app to my USB connected phone. Follow all the common steps to correct this problem, but sometimes I found I just needed to restart my phone.
Make sure to use the “High-Performance ProgressBar for Windows Phone”. Check out this post for details.
If removing or adding lots of listbox items at once, be sure to call UpdateLayout() in order for the ScrollIntoView method to work.
Test your app on your phone! Don’t just lean on the simulator! Also, be sure to test your app in the light theme. I tried to be diligent about that but it still bit me during the certification process.
If you use the ChildWindow class for dialogs in the SilverLight Toolkit ( which I highly recommend by the way ), be sure to handle the OnBackKey event. The requirement in order to be admitted into the marketplace is that if the user hits the back button on the phone, that should cancel any dialog and leave the user on the page the dialog was presented over. I dropped the ball on that as well.
Last but not least, if you are going to have a trial version of your app, be sure to test it and make sure your logic is sound! Nothing more annoying than downloading an app expecting to trial it only to find out that the trial has already expired! Yeah, I did that.

I’m sure I’ve forgotten a few other things that tripped me up along the way, but that feels pretty comprehensive to me.

All and all, a lot of fun building this thing. The WP7 team really did a great job, and the silverlight team did a bang-up job on the developer tooling!

Hope that helps!

Cameron

P.S. If you’re interested, the game my wife and I built is called “WordMe”. Pull it down, and challenge me in a word game. Bring it!

P.S.S. Oh, and I should dedicate this game to Karen Noble, who first introduced me to “that damn game” on the iPhone. Damn you Karen!

Job Opportunities

CameronS - MSFT — Thu, 24 Mar 2011 21:06:00 GMT

Wanted to directly call out a number of positions that are currently open on my team. To refresh everyone’s memory, my team, internally called “Visual Studio Ultimate”, is responsible for features ranging from the Visual Studio debugger to the Visualization and Modeling tools you see in the Visual Studio 2010 Ultimate product.

We’re looking for a few passionate folks in a few key areas. If you are passionate about creating tooling for your fellow developers or testers, please follow the links below and submit your resume!

Good luck!

Cameron

Here are the open positions, with a quick blurb and link to the Microsoft Careers site:

Debugger Program Manager

https://careers.microsoft.com/JobDetails.aspx?ss=&pg=0&so=&rw=1&jid=35719&jlang=EN

Blurb: Senior Program Manager for the debugger: Do you love solving challenging technical problems to build great user experiences? Do you want to help improve the productivity of just about every Windows developer? Working on the Visual Studio debugger provides great opportunity for both and a chance to work with numerous teams across Microsoft. We’re looking for a great technical program manager to help us build a roadmap for the future and advance the state of the art in software diagnostics.

IntelliTrace Lead Developer

https://careers.microsoft.com/JobDetails.aspx?ss=&pg=0&so=&rw=1&jid=37957&jlang=EN

Blurb: For the lead position, we are looking for an experienced lead to help us build the next version of IntelliTrace. We’re looking for someone with strong people and project management skills and experience developing both native and managed code.

Debugger Developer

https://careers.microsoft.com/JobDetails.aspx?ss=&pg=0&so=&rw=1&jid=35163&jlang=EN

Blurb: We’re looking for a bright developer with about 2 years of C++ experience who wants to help us advance the state of the art in debugging. Passion for User Experience design is a plus.

Debugger Tester

https://careers.microsoft.com/JobDetails.aspx?ss=&pg=0&so=&rw=1&jid=36997&jlang=EN

Blurb: Visual Studio debugger team is looking to hire a passionate and smart tester who can help us take the industry leading debugger to the next level. There are not only opportunities to work on the next generation of platforms and language features, but also the chance to shape the architecture of the engine and the user experience from the ground up.

Agile Developer

https://careers.microsoft.com/JobDetails.aspx?ss=&pg=0&so=&rw=1&jid=36406&jlang=EN

Blurb: We are looking for a strong senior dev who is passionate about Visual Studio, is a natural leader, has experience in agile development methodologies (scrum, TDD), and ideally has WPF knowledge.

More Docs Updated

CameronS - MSFT — Fri, 18 Mar 2011 16:47:00 GMT

Our UE ( User Education ) team is constantly updating our documentation on MSDN. This last month is no exception.

Be sure to check out the details here on Patrick’s blog about the latest updates. Lot’s of about T4 templates and extending our UML Models and Diagrams, as well as more clarification of work on the Visualization and Modeling SDK.

Cheers,

Cameron

Visual Studio 2010 SP1 Released

CameronS - MSFT — Tue, 08 Mar 2011 22:37:56 GMT

Lots of news today, as we have release the first service pack to Visual Studio 2010. At the same time, the teams are making available a new Feature Pack the enables a much tighter integration between Team Foundation Server and Project Server.

Please see Brian Harry’s blog for details on the TFS and Project Server announce, and Jason Zander’s blog for more SP1 details.

Enjoy!

Cameron

IntelliTrace and Azure

CameronS - MSFT — Mon, 21 Feb 2011 19:06:47 GMT

Grant Holliday has recently published a blog post that goes into more of the details around using IntelliTrace with your Azure projects. He does a great job in going through some of the lower level details of how to best use IntelliTrace in the Azure environment, with our without Visual Studio, and how to get the .trace files back for analysis.

Great stuff! Check it out here.

Cameron

Code Metrics, Reporting, and XSLT Debugging

CameronS - MSFT — Mon, 21 Feb 2011 03:57:20 GMT

In my last post, I announced a new power tool that allows you to analyze your managed assemblies to determine various complexity metrics. The output of the power tool is a fairly simple XML file, so in this post, I wanted to show you how simple it is to turn that simple xml file into a report you could actually use.

I’ve included a simple XSLT file as well as a CSS file that you can use to bootstrap any efforts you have in this regard.

All you need to do is drop the XSLT and CSS file into the same directory as your xml results after running the power tool, and then be sure to add one line to that xml file, like so:

<?xml-stylesheet type="text/xsl" href="MetricResultsTransform.xslt" ?>

right after the xml declaration statement at the top of the file.

Once you’ve done that, you’ll get a simple report that looks something like this:

NOTE: If you aren’t familiar with Visual Studio’s ability to debug XSLT transforms, I highly recommend checking it out. All you need to do is open an XSLT file in VS, set a break point anywhere in the XSLT file, then hit Alt-F5. VS will then allow you to step through the various transformations, seeing the result of the transformation in the doc well. Very cool stuff if you find yourself having to write lots of XSLTs.

Enjoy!

Cameron

Code metrics from the command line

CameronS - MSFT — Sat, 29 Jan 2011 00:19:18 GMT

Yesterday, we made available a power tool that allows you to analyze assemblies in order to understand the complexity metrics associated with those assemblies. I’m going to describe how to use that power tool and the results it generates.

If you are not familiar with the code metrics capability built into Visual Studio, please see this MSDN documentation for details. This power tool uses the exact same functionality that you see inside the IDE, but encapsulates the code required to do the actual analysis in the metrics.exe application, described below.

Installation

Grab the power tool from this location.

After successfully installing the power tool, you will find two new files in your (%PROGRAMFILES%)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop directory. One is the actual executable itself, Metrics.exe, the other MetricsReport.xsd, the XML Schema that defines the results format Metrics.exe generates.

I point this out as we don’t make that very obvious during install. We don’t slam anything into your Windows Start Menu, drop desktop icons, etc., so be aware of this directory location and executable as you start to play with this power tool.

Usage

To quickly see what this little power tool can do, locate any assembly you would like to generate code metrics and use the /f and /o command line options like so:

metrics /f:Metrics.exe /o:MetricsResults.xml

This will actually run the analysis over the metrics.exe itself and push the results into a file in the same directory called “MetricsResults.xml”. I point this out as you can run metrics analysis over any managed assembly whether you have the code for that assembly or not. However, if you do have the PDBs associated with those assemblies, that’s best. ( If you don’t have the PDBs you will get warning CA0068 ).

The /f and /o combination is the simplest form of usage, but many times, you need to provide the tool a little more information, such as where to find dependent assemblies. The /directory or /d option instructs the tool to look in the current directory to resolve necessary dependencies, while the /searchgac or /gac option will allow the tool to search the GAC to resolve those dependencies. You can also indicate per-file dependencies with the /reference or /ref option.

Results

But what do the results look like, and how do you consume them? Well, I would love to be able to say to you that the results are automatically pushed into your Team Foundation Server data warehouse or reported seemlessly in your reports directory of your team sharepoint projects, but alas, that is *not* the case. The results are XML in the form defined by the MetricsReport.xsd schema file. This is nice, as it allows you to consume and process these results any which way you’d like, but you do need to understand the form of the results to do so.

Double click on the MetricsReport.xsd file and it will appear in Visual Studio, like so:

If you click the “Show Graph View” and “Top to Bottom” toolbar items, you’ll see the schema represented in a tree-like structure like so:

This is a great way to quickly understand the containment structure of the results you will see output from this tool which will be important when processing the XML. However, it doesn’t quite give you all the information you need in regards to the actual values you can expect, especially when wondering what types of metrics will be reported. For that, there’s nothing better than inspecting actual data generated.

Here’s a snippet of some results created from my example above:

The elements I highlighted are the five metrics that we are tracking, and these five metrics will be child elements of the five containers found in the xsd. Target ( the actual file you specified in the command line ), Module ( the .NET assembly found by following the target ), Namespace, Type, and Member.

Why did we provide this power tool?

Many customers are looking for a way to generate code metrics information as part of their build process. In this way, the complexity associated with assemblies coming out of your nightly builds could potentially be tracked and examined over time, which is where I think information like this is most valuable.

With this power tool, we’ve provided the raw capability, but we have a lot more to do to get to automating other parts of the desired workflow, such as providing default windows workflow activities that include this capability. But for now, if you find this information valuable, you can certainly incorporate this into any MSBuild or Windows Workflow ( Team Build is WF enabled in TFS 2010, by the way ) process.

Enjoy!

Cameron

Force VS to garbage collect

CameronS - MSFT — Wed, 15 Dec 2010 18:35:35 GMT

Here’s another little gem I’ve got for you.

As you probably know, Visual Studio is a big product, with contributions coming from many many different teams, and languages. A big part of Visual Studio is written in managed languages these days, and there are a ton of 3rd party components that you can download and install from the VS Gallery that are also written in managed languages. As such, there are lots of developers out there writing managed components targeting the Visual Studio “runtime” if you will.

When testing code that is run in a managed runtime, sometimes it is quite helpful to force the runtime to garbage collect. The CLR has always had API that you could use to programmatically force a GC, but wouldn’t it be great if there was a way to force the runtime inside Visual Studio’s address space to collect via a simple keystroke?

Well there is. Ctrl-Alt-Shift-F12, twice, does exactly that.

So again, you have to hold down ctrl-Alt-Shift and then hit F12 twice in order to make Visual Studio garbage collect.

UPDATE ( 12/16/2010 ):

One thing I should have mentioned when I originally posted, was that if you don’t like that default mapping, or a 3rd party has overridden that mapping and you can’t find what key stroke the ForceGC command is mapped to, you can always check the Visual Studio key mappings by selecting Tools->Customize…, then hit the “Keyboard…” button:

…which takes you to the “Options” dialog where you can type “ForceGC” in the “Show Commands” text box and remap to whatever keystroke you’d like!

Enjoy!

Cameron

ALM Summit 2010

CameronS - MSFT — Mon, 13 Dec 2010 15:51:18 GMT

On November 16-18 here on campus, Microsoft sponsored an event called the “ALM Summit”. The event turned out to be a great success, with three days chalk full of useful presentations / information.

You can now see all the presentations, as they were recorded. The main site is here.

On this page is a list of all the presentations, with links to the video recordings.

I gave a talk about some of the learnings taking teams to a more agile process.

For those wanting to understand more about the support that we shipped in VS2010 for heterogeneous environments, I highly recommend watching Jamie Cool’s presentation.

And for those of you looking to understand how we at Microsoft use TFS to do our daily work, check out Stephanie’s talk, and check out Grant on how TFS is administered internally.

These are just a couple to whet your appetite. Lot’s of good stuff on this site, so enjoy!

Cameron

XMI Export Sample

CameronS - MSFT — Mon, 29 Nov 2010 16:39:28 GMT

Steve Cook, a long time architect on my team, has made available a sample that shows how to access the UML meta data in Visual Studio’s new UML project system and export that data into the OMG’s XMI data format. XMI is the OMG standard used to describe UML meta data for exchange between various tool vendors.

In Visual Studio 2010 Ultimate, we have the ability to import XMI ( via the Visualization and Modeling Feature Pack ), but we didn’t get XMI export into the feature pack.

If you are interested in this sample, here are the steps you need to do to take it for a test drive:

Download the sample
Once downloaded, double check to see if you need to unblock the zip file. Better to do this now if needed, rather than all the extracted files. Just right click on the XmiExporterSample.zip file and select “Properties”:
If you don’t see the “Unblock” button, then you can safely skip this step.
Extract the zip file to your favorite directory and double-click on the XmiExporterSample.sln file.
This will launch VS for you. If you are presented with any dialogs about version control, you can safely ignore. If you are asked, choose to permanently remove the version control settings from the solution.
Right click on the XmiExport project in the Solution Explorer and select “Set as StartUp Project”
Also, if you are running a x64 bit version of windows, you will need to go into the project settings to point at the appropriate version of Visual Studio. Right click on the XmiExport project, select Properties, click on the Debug tab, and make sure you are pointing at the correct DevEnv.exe. On my machine, that happens to be here : “C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\devenv.exe”
Set the “Solution Configuration” to be Release
Rebuild your solution
Double click the Microsoft.Example.XmiExporter.vsix file
In the output directory for the XmiExporter project ( XMIExporter\bin\Release ), you’ll find a Microsoft.Example.XmiExporter.vsix file. Double clicking that vsix will install the XmiExport sample into your Visual Studio instance.
Restart Visual Studio, create a new UML modeling project, create a UML class diagram, and notice the new “Export XMI…” menu item when right-clicking in the background of the diagram!
Drop some elements on the diagram so you have something to export.
Select “Export XMI…”
A dialog will popup asking where you want the resulting XMI file to go.

And that’s it!

The great thing about providing this as a sample is you can jump into the source to see how to get access at all the UML meta data in your UML Modeling projects. To start, reopen the XmiExporterSample and open the XmiExportCommand.cs file. Set a break in the Execute method…

Hope that helps,

Cameron

A Windows Explorer Gem

CameronS - MSFT — Mon, 11 Oct 2010 15:49:47 GMT

I just tripped into this little gem and just couldn’t let this go without telling somebody, ‘cause I could have used this little feature 15 years ago!

Ever had to find a file on your machine with the only purpose to determine the absolute location to that file so that you could write some code that makes the path relative, etc., etc.?

Until today, I would typically find the file in Windows Explorer, then quickly hit Alt-D to put the focus in the address bar of the explorer window, which selects the full path to the directory of the file, like so:

Then I can easily Ctrl-C to copy, and away I go.

That works pretty well, but when I want the actual name of the file included in that path, I have to go paste the copied path, then type in the ‘\’, and then type in the name of the file ( assuming I could remember the name! ).

Well, no longer!

Hold the Shift key down while right-clicking on a file or directory. Go ahead, try it. Do you see anything different?

Here’s the context menu when I right click *without* holding the shift key over the mscorlib.dll file:

And here’s the context menu with the Shift key down while right-clicking:

Yes, “Copy as path”!!!!

Learn something new everyday…..

Enjoy!

Cameron

Need your feedback on Visual Studio 2010

CameronS - MSFT — Thu, 07 Oct 2010 21:16:48 GMT

Do you use Visual Studio 2010 everyday? If so, I’d really appreciate it if you could take 5-10 minutes and fill out the following questions found in this survey:

http://go.microsoft.com/fwlink/?LinkId=203459

We’re really trying to get as much feedback as we can in regards to overall performance and stability of the application. As you already know, we take the quality of Visual Studio very seriously, and your feedback is a key ingredient in how we tune our efforts to ensuring that quality.

Thanks in advance!

Cameron

ALM Summit Nov 16-18

CameronS - MSFT — Tue, 28 Sep 2010 13:54:03 GMT

Brian Harry just blogged about a conference we’ll be hosting on the Redmond Microsoft campus this November 16-18th. If you do get a chance, drop by. I’ll be giving a talk about lessons learned and challenges overcome while I led a few product team transformations over to more Agile processes.

Find out more about the summit here.

Hope to see you there!

Cameron

TIP support for any ADO.NET app

CameronS - MSFT — Tue, 07 Sep 2010 00:57:32 GMT

In my last post, I discussed the benefits of the Tier Interaction Profiler found in Visual Studio 2010 Premium. If you are accessing a database via ADO.NET APIs ( which includes the new Entity Framework 4.0 features ), you can get the same benefits from TIP.

If you recall, one of the last pages in the performance wizard was a simple checkbox allowing you to collect TIP data. Unfortunately, if your project is not a web app or web site, performance wizard doesn’t include the option to turn Tier Interaction Profiling on.

You can manually configure your performance session to collect TIP data by right clicking on the Performance session in the Performance Explorer, select “Properties”, and then click on the “Tier Interactions” entry in the property pages window, as seen in the following image:

To create a new performance session, you can either create it through the perf wizard, or select the “Analyze->Profiler->New Performance Session” menu item, which will result in an empty performance session inside the Performance Explorer tool window:

From here, simply right click on the “Targets” folder and select a project or binary to associate the performance session with.

Cheers!

Cameron