JB Brown

DYK in 2010 - You can delete a Team Project collection?

2009-11-14T07:00:00.000-08:00

Deleting Team Project collections can be done through command line

Use "TFSConfig Collection" to delete a team project collection

On your TFS Server open a command window (as TFS Administrator) to [TFS Install Drive]:\Program Files\Microsoft Team Foundation Server 2010\Tools

Enter "TFSConfig Collection /delete /collectionName:[COLLECTION NAME]"

Respond to the irreversible "Are you sure" prompt

Visual Studio 2010 Facts and Links

DYK in 2010 - Security and Group Membership is slightly different?

2009-11-13T07:00:00.000-08:00

Team Project Collections have their own Group Membership and Security

New in TFS 2010 are Team Project Collections, a way to make groups of Team Projects. Along with these groups comes a new level of Group Membership and Security management within the Team Foundation Administration Console.

To view or manage your Team Project Collection group membership and security.

Open the Team Foundation Administration Console

In the left pane expand Application Tier -> Team Project Collections

In the top of the right pane highlight a Team Project Collection

In the bottom of the right pane choose the "General" tab

On the left of the general tab click either "Administer Group Membership" or "Administer Security"

When you click "Administer Group Membership" you see the following.

Visual Studio 2010 Facts and Links

DYK in 2010 - Each Team Project Collection has it's own database?

2009-11-12T07:00:00.000-08:00

Team Project Collection databases

When setting up a Team Project Collection you are given the choice to use an existing empty database or create a new one. That's right each Team Project Collection has it's own DB to allow for moving (Detaching/Attaching) the collection seperate from other collections.

Durring Team Project Collection setup you'll see this screen.

Then once the Team Project Collection is complete you can see the new dedicated database.

Visual Studio 2010 Facts and Links

DYK in 2010 - You can create "groups" of Team Projects

2009-11-11T07:00:00.000-08:00

Team Project Collections

In the Team Foundation Administration Console you can now create groups of Team Projects with the new Team Project Collections feature. If you are upgrading an existing TFS your current Team Projects will be placed in the Team Project Collect ion aptly named "DefaultCollection."

To create and manage Team Project Collections

Open the Team Foundation Administration Console

Under the "Application Tier" section choose "Team Project Collections"

More on Creating Team Project Collections in 2010 Beta 2

Visual Studio 2010 Facts and Links

DYK in 2010 - There are new TFS configuration options

2009-11-10T07:00:00.000-08:00

Basic, Advanced, Application Tier, and Upgrade

If you consider "upgrade" as a type, there are 4 types of configuration options for TFS 2010. You can find them in the Team Foundation Administration Console.

Basic - the compact, quick, easy way to install TFS 2010. Although you don't get sharepoint, reporting, or many choices about your installation.

Advanced - similar to a 2008 install but with more options - lots of choices and the full TFS feature set at your finger tips.

Application Tier - if you have a multi-tier deployment with your TFS Databases somewhere else, this is for you.

Upgrade - speaks for itself - you have a 2008 TFS and you want to upgrade it to 2010

Visual Studio 2010 Facts and Links

DYK in 2010 - You can also configure TFS from command line?

2009-11-09T07:00:00.000-08:00

The Key is the TFSConfig

It must be run from the TFS server (App tier) in [TFS Install Drive]:\Program Files\Microsoft Team Foundation Server 2010\Tools. Obviously to administer TFS you need to run it from an account that has TFS Administration privileges.

Visual Studio 2010 Facts and Links

DYK in 2010 - There's a new way to manage and configure TFS

2009-11-08T07:00:00.000-08:00

Team Foundation Administration Console

In TFS 2010 there are new TFS management and configuration options. These are surfaced in the Team Foundation Administration Console. Among these options are the TFS configuration setup (Basic, Complete, Advanced), Team Project collection setup and more.

To find the Team Foundation Administration Console

Install TFS 2010

Click Start -> All Programs -> Microsoft Team Foundation Server 2010 -> Team Foundation Administration Console

Check out the Team Foundation Administration Console

Visual Studio 2010 Facts and Links

DYK in 2010 - MSDN documentation is already available?

2009-11-07T17:01:00.000-08:00

2010 documentation is under "Application Lifecycle Management"

In case you we're looking for it under "Team System" it's under Visual Studio 2010 Beta 2 -> Application Lifecycle Management instead.

Visual Studio 2010 Facts and Links

DYK in 2010 - Facts and Links

2009-11-07T16:57:00.000-08:00

A (continually updated) list of Visual Studio 2010 Facts and Links - I'll be referencing this from other posts.

Launch date is March 22, 2010

2010 Sku Structure, Upgrade Plan, and Pricing

Visual Studio Beta 2 Downloads

TFS Beta 2 download

Use Visual Studio 2008 with TFS 2010 Download

MSDN Documentation
VM Prep Tool for Visual Studio Team Lab Management 2010

First Look: Beta 2 Diagnostic Tools

2009-10-19T12:02:00.001-07:00

John Robbins is either the fastest blogger known to man, or is an extemely well prepared geek. He has already provided a series of great First Look blog posts about Visual Studio Beta 2 Diagnostic Tools, check them out.

VS 2010 Beta 2 Debugger In-Depth First Look

VS 2010 Beta 2 IntelliTrace In-Depth First Look

VS 2010 Beta 2 Code Analysis In-Depth First Look

VS 2010 Beta 2 Sampling and Instrumentation Profiling In Depth First Look

VS 2010 Beta 2 Concurrency Resource Profiling In Depth First Look

Using VSTS 2008 Client and TFS 2010

2009-10-19T11:43:00.000-07:00

Want to test out TFS 2010 with your existing Visual Studio 2008 install?

Use the 2008 Forward Compatibility Service Pack - "This is an update for the 2008 SP1 version of Visual Studio Team System Team Explorer and allows the 2008 SP1 version to work with the Team Foundation Server 2010. The update will allow teams to move forward and use the Team Foundation Server 2010 server even if part of the team continues to use the Team Explorer 2008 SP1 client."

Visual Studio 2010 Beta 2 - the Ultimate one

2009-10-19T09:16:00.000-07:00

Beta 2 is available on MSDN- when you get there you'll notice a few things

MSDN looks different
There's are new VS, TFS..etc Logos
There isn't a "Team Suite" or other former Team System versions. What you're looking for is now called "Visual Studio Ultimate"

There are now less Visual Studio SKUs and here's how they compare to the 2008 versions.

The following graphic shows the migration path for existing MSDN customers, this should happen around the March 22, 2010 launch date. That's right the Launch Date is out!

For more information here's a great fact sheet from Microsoft News room about the Sku structure, Migration and pricing.

Where to find VSTS Project Manager Ideas and Answers

2009-05-25T17:10:00.000-07:00

If you search the web, CodePlex, The Team System Widget list, and the Visual Studio Gallery you can find all types of great goodies.

But where are all the Project Manager resources?

Now there is a location - VSTS Project Manager - Where Project Managers that use Team System go for ideas and answers.

Let's look at one of the resources available - an Excel Dashboard for CodePlex project teams to manage their projects. This was generously contributed by Ben Amodio after I saw a great presentation from him at the Dowtown Seattle.Net User Group and asked enough questions that he whipped out this dashboard in no-time at all.

So, follow along with me using your project as I go through the steps to use the Dashboard for TeamReview, and then analyze the results and discuss the immediate insight it provides.

Setting up the CodePlex dashboard

I've explained this in an extreme amount of detail, so it looks much longer than it is - in reality it only takes about 5-10 minutes the first time and then you are set-up. Once you're done you'll make your colleagues jealous that you have such accurate insight into the state of your project - and all you are doing is hitting the refresh button once in a while.

The workbook we are going to load up needs a Team Query that has all the work items and some important fields, so let's set that up in VSTS in preparation. CodePlex doesn't allow us to add new Team queries, so you'll have to create a private one. In Team Explorer under "Work Items", right click on "My Queries" and choose "Add Query"

The default filters that are provided are exactly what we want - everything! So save this as "All History" where it's "only visible to you"

Now we're ready for the Excel Dashboard - Download the latest Source from VSTSProjectManager.codeplex.com

Open the \CodePlex\Excel Dashboards\CodePlex Dashboard.xlsm workbook.

This is a macro enabled workbook so the first thing we need to do is make sure it's in a location on your computer where macros are allowed to execute. From the file menu select "Excel Options"

Then on the "Trust Center" channel click "Trust Center Settings.."

Now, in the "Trust Locations" channel verify that the workbook is already in a trusted location, or add a new trusted location and then click ok a few times to get back to the main workbook screen

Now that has been completed click the "Options" button to enable macros

Choose the option to enable macros and then click OK

The workbook comes with some "Test data" (ahem, masked stuff from TeamReview) and isn't going to help you make decisions - so it's time to import your CodePlex project data. In Excel click on the "Work Item Data" Spreadsheet, then go to the "Team" tab and choose "New List"

Now we can connect to the Private Query that we created in the first few steps. Enter or choose your CodePlex server and then provide your CodePlex credentials; finally you should be able to select your CodePlex project

Next you'll be prompted to select a Team Query - this is where you should choose the "All History" personal query you set up earlier.

Only a few more steps to go.. The "All History" query may not return all the columns the workbook requires, so click "Choose Columns" and move everything over. You don't need them all, but it's easier than being selective.
Ok - now it's time to configure the workbook to look at your real data instead of the test data. Go to the "How to Use This Dashboard" spreadsheet and click the "Autoconfigure" button.

You're done! Go to the Dashboard spreadsheet and analyze your project.

Gain Insight into your Project

No wonder TeamReview's last release had me feeling anxious about getting it published and overwhelmed with testing to feel comfortable pushing the final "can't turn back now" button - look at how big 1.1.0 was compared to the previous releases. That's quite a progression in release size.

Scanning down and to the left a few pixels it's easy to see why the release was so big, it wasn't just me writing code this time - the team got a new coder and Ian (bluess57) was making some great head-way on work items. He contributed way more than this chart gives him credit for - and I contributed a lot less than the chart shows. In the end, having two ambitious coders made the release size swell faster than I had experienced in the past and beyond the point where I was passively comfortable publishing the release.

Looking back at the Work Items By Release chart it looks like the next release - only 3 days old - is heading down the same track as the last. Since I know that now, before any work has really started, I have options and can re-adjust the release back-log to have less items, be focused on a certain sub-area to avoid regression testing the whole code base, or recruit a tester.

The Results

I've uncovered some very accurate insight about TeamReview release planning that will help me plan the next release without feeling over-whelmed with testing - and it only took a few minutes of work. To top it off, next time I'll just be able to hit refresh!

I'm really hoping more people like Ben and people like me can share and learn from VSTSProjectManager.CodePlex.com because Team System has some great facilities for making informed decisions based on accurate data. Hopefully VSTS Project Manager will help guide Project Managers on how to get that data into a format that allows them to get the most out of Team System.

TeamReview Introduction Video

2009-05-25T14:58:00.000-07:00

If you'd like to see exactly how TeamReview works before trying it watch this 6 and a half minute introduction video I just put together showing the basic usage and workflow of TeamReview

Priority, ChangeSet association and Saved settings are new in TeamReview

2009-05-22T22:11:00.000-07:00

A new release of TeamReview has been published - and this is a fun one. For the first time I wasn't the only coder. Our newest team member both added a bunch of great new inspiration to the release and cleaned up a lot of my perpetual hacking-just-to-make-it-work, and TeamReview is much better off for it.

As I said - we have some very fun stuff for you to try out-

You can now associate code review responses directly with a change-set
A priority can be assigned to your code review feedback - and - this is backwards compatible to the client - you can have an old client and a new Work Item Type
You can choose individual code review responses in the Code Review Replay window
TeamReview has it's own output window to help you remember what you've done in your code review activity
The default values for the size and location of the New Code Review Response window are persisted between VS.Net sessions
The last used values for the New Code Review Response fields are saved per Team Project and are persisted between VS.Net sessions
Thanks to Libaty we have an optional Japanese language Work Item Type definition for Code Review Response
A handful of bug fixes

Release 1.1.0 has the full detail on these new features and the links to download the latest version of TeamReview

Visual Studio Team System MVP award!

2009-04-02T16:19:00.000-07:00

Yesterday I received the Microsoft MVP award for Visual Studio Team System!

It's quite an honor, and I am very excited about it. I haven't yet been calm enough to sit down and read through all the details, benefits, and opportunities that come with the award. However, I have already scheduled a new internet provider for more bandwidth to take advantage of some of the freebies I do know about.

Thanks to everyone from the MVP Program, with special recognition to Steven Borg and Chuck Sterling for handling my nomination.

New TeamReview release & new TeamReview contributors

2009-03-29T22:29:00.000-07:00

TeamReview has crossed a few milestones lately that I am proud of, including another release (details below), and we have one big upcoming celebration to tell you about.

Today "the most complete code review tool for Team System" surpassed the 2K download mark. Yesterday we published the 9th release of TeamReview to add some nice-to-have features out-lined below. You may have noticed I said "we published" instead of "I published" in the last sentence. One of the things I am most proud of, and most excited about is that 2 new contributors recently joined and have started making some great changes. Somehow going from just one guy with a far-fetched idea hacking out some code to now being part of a team of 4 developers delivering on the product's vision makes this open source project seem more real. Maybe it's my perspective, but at least to me it feels like a "bigger" open source project with a brighter future than before.

The cherry on top of all the fore-mentioned positives is that TeamReview will be celebrating it's first birthday on April 8th! It's hard for me to believe it's been a year, time flies when you're having fun.

Here are the features in yesterday's release to make TeamReview an even better product.

A packaged VSTS 2010 install
Support for DB Projects
More support for Solution Items and projects within Solution folders
Form fields are sorted logically
The New Code Review Response form is re-sizable
The New Code Review Response form will show in the same position and size as last used during that Visual Studio "session"
The Code Review Replay form is updated with values when work items are edited and saved.
The grid in the Code Review Replay form is sortable
A few minor bug fixes

VSTS Code Review Tools Evaluation

2009-03-22T13:10:00.000-07:00

In early February I gave a presentation on Code Review Tools in Team System. During that event we recorded a group evaluation on various aspects of the tools. I am finally publishing those results. The evaluation was relatively simple, I demonstrated the product and then asked the group if the tool supported various aspects that are beneficial to code reviews, and recored that as a simple Yes or No.

As you can see, the Out-of-the-box guidelines had the worst combined score, with the Yell method, and the CRMail offering doing a little better but each scoring fairly low on our evaluation. TFS Code Review Workflow and Attrice's Code Review Sidekick fared better, with TeamReview having the highest approval rating of the available code review tools for Team System.

Evaluation Form - Code Reviews in Visual Studio Team System

Presented by JB Brown and the .Net Developers Association, Feb 9, 2009 - Redmond Wa.

Supports..	OOB	Yell	CRMail	TFS Workflow	Attrice	TeamReview
Updates to the project (project is active)	Y	Y	N/A	N	Y	Y
Workflow	N	N	N	Y	N	Y
Conversation	N	Y	N	N	N	Y
Good, Fast, Clear, Objective Feedback	N	Y	N	Y	N	Y
Clear outcomes	N	Y	N	Y	N	Y
Identifying and managing the bad things..	N	N	N	N	N	N
Sharing Tacit Domain-Based Knowledge	N	Y	N	N	N	Y
Distributed teams, different time-zones	N	N	Y	Y	Y	Y
Team Members without Visual Studio	N	Y	Y	N	Y	N
First class member of ALM	N	N	N	Y	N	Y
Low TCO	N	Y	Y	N	Y	Y
Auditing, reporting, trending	N	N	N	Y	N	Y
VSTS 2005	Y	Y	Y	Y	Y	Y
VSTS 2008	Y	Y	Y	Y	Y	Y
VSTS 2010	Y	Y	Y	N	?	Y
Developer Joy	N	N	N	N	Y	Y
Creating Business Value via Code Reviews with VSTS	N	N	N	y	Y	Y

Whitespace in Team System Compare Results

2009-03-18T21:12:00.000-07:00

Why do VSTS diff results include whitespace?

A teammate of mine shared a great tip with me during a merging exercise the other day. We noticed many differences shown in a file comparison that didn't seem different to us. It was simply whitespace that was causing the comparison tool to show more differences than would actually matter to the compiler.

He then recommended creating the following setting buried deep in the chasms of Visual Studio in

Tools -> Options -> Source Control -> Visual Studio Team Foundation Server -> Configure Users Tools.. -> Add ->

It's the "%5 /ingorespace" ending that differentiates the new Compare behavior from the out-of-the-box results. Now a Compare action will create results that you might expect - only the differences the compiler cares about.

James Manning has a great blog post explaining all the options and further Visual Studio configuration for compare tools.

Fixing the 2008 Power Tools Team Members IM feature

2009-02-20T19:44:00.000-08:00

If, like me, your development team uses VSTS along with Office Communicator, you may find like I did that the Team Members feature of the TFS 2008 Power Tools does not work. In this article I will explain why (atleast 1 reason why) and give you some code to help start you down the path to getting it to work for you.

The problem
I spent a while trying out all the permissions and compatibility mode setting suggestions I could find on the internet, before finally asking for help. Team System MVP Ed Blankenship came to the rescue and had me check for matching SIP and SMTP addresses for team members - and of course they didn't match. I looked at my contact info in Outlook and saw something like this screen shot, with JB.Brown@exchange.ControlStatements.com being my primary SMTP address.

What I then found out from Ed, and two other Team System MVPs; Eugene Zakhareyev and Sondre Bjellås, was that Team System doesn't specifically know or store the SIP address of Team Members, it only knows SMTP. This works great for shops where they match, and is the reason the defect ended up being shipped. When they don't match the 2008 Power Tools can't find Team Members on IM. For example Team System tries to look for the IM address JB.Brown@exchange.ControlStatments.com which is not my IM address - my IM address doesn't have the "exchange" sub-domain.

Options to make it work
The obvious, and expensive, answer is to contact your exchange admin and force them into changing their naming standards.

Since that's unlikely to happen, the second best option is to fix the Power Tools code. This is a problem though, because even if we could get access to the Power Tools source code and could alter it to use a different value for looking up IM addresses, where would we get those values from? Team System doesn't store SIP address for memberships. So, this option is also pretty expensive and unlikely to happen quickly. I'm hoping however that the 2010 version of TFS will have expanded membership properties to include SIP in some way. Until then we'll need an answer.

The good news is that there is a published API that can be leveraged to write a custom ICollaborationProvider to extend VSTS. In fact there is already a CodePlex project for sharing CollaborationProviders. It would be a waste of time and effort though to re-write all the stuff to get data out of TFS, Establish IM sessions, get contact status, keep track of running conversations, etc. All that needs to be done is change the addresses being used based on a text pattern - remove the "exchange." from STMP and use it as SIP.

The Answer
The API still presents a way to achieve what we want without a lot of expensive work.

The solution is fairly simple, and seems to work, at least for me and a few of my team members. The code is linked here (use at your own peril and discretion) and I hope to get it added to the Collaboration CodePlex project shortly. It's certain that not everyone will want a simple find-and-replace, so I've encapsulated the make-IM-work algorithm into an abstract class and deferred the step to get the SIP address from the SMTP address to implementers to allow for easy extension.

What's most important is that there is a simple way to plug in your own method for fetching SIP addresses from the SMTP values provided by Team System.

Here's the new abstract class to take care of most of the Collaboration providing. I inherited from the built-in CommunicatorProvider so that all I had to worry about was overriding the little pieces I wanted to be different. Also this prevented me from having to deal with the entire Communicator API, as well as the entire Collaboration API and kept me from doing a full regression testing of the Team Members functionality - it's still Communicator after all.


using MessengerAPI;
using Microsoft.TeamFoundation.Collaboration;
using Microsoft.TeamFoundation.Collaboration.Microsoft;

namespace TfsCommunity.Collaboration.Communicator
{
 /// <summary>
 /// Create an algorithim that will allow us to inject our own SIP
 /// addresses for Team Members since Team System only knows about
 /// their SMTP addresses. These aren't always the same, so we need
 /// a way to get from SMTP to SIP for Communicator functionality
 /// in the Team Members piece of the TFS 2008 Power Tools October release.
 /// </summary>
 public abstract class CustomCommunicatorProvider : CommunicatorProvider
 {
  /// <summary>
  /// Defer how the contact ID is acutally augmented, so that we can
  /// have different implementations base on need
  /// </summary>
  /// </pre><param name="contactId">
  /// <returns></returns>
  public abstract string AugmentContactId(string contactId);

  /// <summary>
  /// When adding a new contact make sure we use the desired SIP, not SMTP
  /// </summary>
  /// <param name="contactId">
  public override void AddContact(string contactId)
  {
   base.AddContact(AugmentContactId(contactId));
  }

  /// <summary>
  /// When getting a contact, get it by SIP - if nothing comes back then add it by SIP
  /// </summary>
  /// <param name="contactId">
  /// <returns></returns>
  public override Contact GetContact(string contactId)
  {
   string augmentedContactId = AugmentContactId(contactId);
   Contact c = base.GetContact(augmentedContactId);
   if (c != null)
    return c;
   else
   {
    IMessengerContact contact = (IMessengerContact)base.Messenger.GetContact(augmentedContactId, base.Messenger.MyServiceId);
    MessengerContact mc = base.NewContact(contact);  
    return base.GetContact(augmentedContactId);
   }
  }

  /// <summary>
  /// Make sure my contact address is SIP and not SMTP
  /// </summary>
  public override string MyContactId
  {
      get{ return AugmentContactId(base.MyContactId);}
  }

  /// <summary>
  /// When adding a new contact, use our custom <see cref="MessengerContactDecorator">
  /// as the implementation of <see cref="IMessengerContact"> so that we can ensure
  /// that the SIP is the <see cref="IMessengerContact.SignInName"> value.
  /// </see>
  /// <param name="mc">
  /// <returns></returns>
  protected override MessengerContact NewContact(IMessengerContact mc)
  {
   var contactDecorator = new MessengerContactDecorator(mc, AugmentContactId(mc.SigninName));
   return base.NewContact(contactDecorator);
  }
 }
}

That's pretty simple, not a whole lot of code. In fact there's probably more comments shown above than code. There's 1 structure piece left and the all-important translation from SMTP to SIP to show. Let's look at the structure piece first.

When adding a new contact to the Team Members section the CommunicatorProvider.NewContact() method shown above is invoked, and the passed in argument contains a get-only property for "SignInName" which happens to be the SMTP address. To fix that NewContact() is overriden with a Decorator pattern to wrap the passed in argument to achieve the same IMessengerContact interface but have a new value for the SignInName property. Here's the decorator - MessengerContactDecorator.


using MessengerAPI;

namespace TfsCommunity.Collaboration.Communicator
{
 /// <summary>
 /// Decorate an object of the same interface, so that we can change
 /// the value of the <see cref="SignInName"> property to be SIP
 /// and not SMTP
 /// </see>
 public class MessengerContactDecorator : IMessengerContact
 {
  //our decorated instance - it's SignInName value would return SMTP
  private IMessengerContact decorated;

  //the new value we want to return for SignInName - the SIP address
  private string newSignInName;

  /// <summary>
  /// Basic constructor - the thing we are decorating and how we want to
  /// augment the behavior
  /// </summary>
  /// </summary></pre><param name="contact">
  /// <param name="signInName">
  public MessengerContactDecorator(IMessengerContact contact, string signInName)
  {
   decorated = contact;
   newSignInName = signInName;
  }

  /// <summary>
  /// The only place in this class that really matters -  This is the new
  /// implementation that returns a SIP address - an augmentation of our
  /// decorated instance's value of SignInName
  /// </summary>
  public string SigninName
  {
   get
   {
    //this is it...
    return newSignInName;
   }
  }



  #region IMessengerContact implementation - nothing changed.. just calls decorated instance

  public bool Blocked
  {
   get{return decorated.Blocked;}
   set{decorated.Blocked = value;}
  }

  public bool CanPage
  {
   get { return decorated.CanPage; }
  }

  public string FriendlyName
  {
   get { return decorated.FriendlyName; }
  }

  public bool IsSelf
  {
   get { return decorated.IsSelf; }
  }

  public string ServiceId
  {
   get { return decorated.ServiceId; }
  }

  public string ServiceName
  {
   get { return decorated.ServiceName; }
  }

  public MISTATUS Status
  {
   get { return decorated.Status; }
  }

  public string get_PhoneNumber(MPHONE_TYPE PhoneType)
  {
   return decorated.get_PhoneNumber(PhoneType);
  }

  public object get_Property(MCONTACTPROPERTY ePropType)
  {
   return decorated.get_Property(ePropType);
  }

  public void set_Property(MCONTACTPROPERTY ePropType, object pvPropVal)
  {
   decorated.set_Property(ePropType, pvPropVal);
  }

  #endregion
 }
}

Now finally the good stuff, everything else was structure to extend CommunicatorProvider, now for the content - our new Provider to fix the SIP address problem.


using Microsoft.TeamFoundation.Collaboration;

namespace TfsCommunity.Collaboration.Communicator
{
 /// <summary>
   /// <para>
   ///
   ///          This is an example implementation.. you plug your changes in here
   ///
   /// </para>
 /// </summary>
 [CollaborationProvider("Communicator Provider for SIP/IM addresses that can pattern match SMTP addresses")]
 public class FindAndReplaceCommunicator : CustomCommunicatorProvider
 {
  const string replace = "@";
  const string find = "@exchange.";

  public override string AugmentContactId(string contactId)
  {
   return contactId.Replace(find, replace);
  }

 }
}

To Deploy

Download the code (use at your own peril and discretion)
Change the FindAndReplaceCommunicator to meet your needs for fetching SIP addresses
Compile
Drop it in C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\PublicAssemblies\CollaborationProviders
Restart Visual Studio
Right Click on "Team Members"
Choose "Personal Settings.."
Click "Change"
Choose "Communication Provider for SIP/IM addresses that can pattern match SMTP addresses"
Click OK

And now your Team Members should light up red, green and yellow. Now if only double clicking one would start a conversation...

If you find any optimizations, issues, fixes, or extend this in any way please post it back as a comment so that we can all benefit ( and I can fix my code ).

Team System Code Review Presentation

2009-02-08T13:24:00.000-08:00

Tomorrow (Feb 9, 2009) I'll be demonstrating out of the box and open source solutions for performing Team System Code Reviews. Each participant will have the opportunity to record their own evaluation to take home as a I show off the various tools. We'll also try to do the same as a group in order to share opinions as thoughts as long as it doesn't get time consuming.

For a preview here's JB Brown's Team System Code Review Tools Presentation, and here's the evaluation form.

The only thing I ask is that you notify me of any corrections I should make or of suggestions about other criteria for the evaluation form.

New release of TeamReview - Team System code review

2009-01-30T16:20:00.000-08:00

I've just published a new release of TeamReview.

As the release summary indicates TeamReview should work on more file types and with more project structure variances, and in Visual Studio Team System 2010.

Not mentioned in the summary is a small but really nice change that the New Code Review Response window no longer holds focus, so you can now copy and paste from the editor window into the New Code Review Response form for the Description and Suggested Resolution fields.

Team System Code Review

2009-01-27T20:00:00.000-08:00

Are you looking for an answer on how to perform code review in Team System? Do you want to know about the most successful open source tools for VSTS code review?

On Feburary 9th I'll be presenting that topic at the .Net Developers Association meeting starting at 6pm in Microsoft Building 40, Steptoe Room #1450

Join me for a demonstration of out-of-the-box and open source code review tools and processes for Visual Studio Team System. We'll discuss the pros and cons of each and analyze them for how they provide business value through code reviews.

The Social Dynamics of Code Reviews

2009-01-07T20:31:00.000-08:00

Tiago Pascoal has hit the proverbial nail-on-the-head with his post "Your Code Sucks and I Hate You" regarding code reviews and the lack of proficient OOTB Team System code review tools. In his article he does mention TeamReview as the "The more complete solution for Team System" - which of course I very much appreciate. Thanks Tiago!

The larger compelling argument that Tiago makes so subtly and accurately is that there are successful code review tools to emulate that create continuous business improvements by leveraging under-valued existing feedback channels in the software development process. These same feedback channels are there for the taking for Team System users, like anyone else creating software, so long as there is a business advantage for doing so. Creating that advantage is where Team System's OOTB offering falls short and where TeamReview shines.

What's the line, "I'm not only the president, I'm also a client?" Yeah it's really cheesy and worn-out - but it's particularly true statement for me. TeamReview, and it's predecessor were originally used in my office after a lot of semi-forceful prodding (begging) from me due to my code review experience. After nearly two years, it's easy for me to say that the use of TeamReview has caused a change in The Social Dynamics of Code Reviews with my team. We now get the greater business value of code review without most of the personal confrontation costs and the transition costs of traditional team review conversational style. I actually find myself really liking code-review now, because for the most part it's just reading code and externalizing my thoughts right with the code as I read it, and implementing feedback is an immediate sigh-of-happiness-for-better-code gratification with TeamReview.

In bigger marketing grandiose words TeamReview has helped celebrate the business benefit of the professional exchange of view points, exploration of possibilities, and challenging of assumptions. Above all, I know from my team's use that TeamReview allows the natural synergistic elements of code reviews to happen more frequently and have a much greater positive business affect than exists with Team System out-of-the-box.

Migrating a Visual Studio Add-In to 2010 - Part 2

2008-11-29T12:42:00.000-08:00

My last post was an introduction into the new construction pieces of Visual Studio 2010 add-ins: Managed Extensibility Framework (MEF), Managed Add-In Framework (MAF), and Windows Presentation Foundation (WPF). As mentioned before the migration path for an add-in from Visual Studio 2008 to 2010 doesn't necessitate a re-write if you don't want to leverage these new pieces; let's put that to a test today with TeamReview.

Software
First, let's lay out the bits I'll be using. Luckily I attended PDC 08, so I was given most of them on "The Goods" USB hard-drive. It's all available for download however, here are the links.

That's it! Just get the 2010 & .Net 4 CTP up and running, and after that download the code for TeamReview.

Converting the Solution and Project files

Startup the 2010 CTP server
Login as TFSSetup / 1Setuptfs
Accept the licensing terms
Start Visual Studio 2010
Create a copy of the 2008 folder of TeamReview (or your add-in) into a "2010" folder for your conversion to 2010, because we don't want to convert the 2008 source in place.
Mark the 2010 folder and it's contents as writable. If your 2008 copy was in source control it was probably read-only on disk, which means so is your 2010 copy. The conversion wizard we're going to run the 2010 copy through needs to be able to update those files, so mark them as writable.
Open up the 2010 copy in Visual Studio 2010
Follow the default settings of the Conversion Wizard
Once the Conversion Wizard is done, review the Conversion Report. You'll likely see a line similar to the following one in your projects. Visual Studio 2010 has some new facilities for segmenting and managing FxCop Rules into distinct sets. That's most likely what causes this line.
Created rule set file "Z:\Developer\TeamReview\2010\TeamReview\VS 2008 Rules.ruleset" for the "Debug (Any CPU)" configuration.
Now the moment of truth. Compile it and find that (hopefully) nothing breaks. You may find like I did that some assembly references were broken. This makes sense if your 2010 machine doesn't have those referenced assemblies. For example converting TeamReview resulted in 56 errors.

These errors aren't really the fault of the conversion wizard because those references were to the 2008 version of various Team System assemblies, and really they should be 2010 references now. So, it's time to go hunting for those new references.
For the most part you can open up your project files in notepad and simply replace the number "9" in the assembly name and hint paths with the number "10" to find the new reference. For example the new version of some Team System assemblies that are in "..../Program Files/Visual Studio 9.0/...." for 2008 are now in "..../Program Files/Visual Studio 10.0/...." in 2010. I had a bit of trouble finding a few assemblies that originated from the Visual Studio 2008 SDK. Low and behold a bare-bones version of the 2010 SDK is in the CTP virtual image at "c:\Users\public\documents\CTPWalkthroughs\Visual Studio\SDK". So, close down Visual Studio and ran the installer with all the default options. After the SDK installation completes, you should be able to find the new version of all the assemblies needed in the GAC.
Now re-compile and and you may find that you still have 1 error (that may lead to some other missing reference errors).

If you "find all references" on the Settings class you'll see the two declarations with an error indicator in the "Find References" window.

By looking at the non-converted 2008 code you can see that the conversion wizard didn't mess this up and in-fact there was a mismatch in the 2008 code that the compiler didn't catch, but does now in 2010. Because this code is only executed on add-in installation, which is typically a hard thing to debug and troubleshoot on many different system configurations let's go with the the more relaxed option and set both to "pulic sealed partial."
Try again, and.. Success! It compiles. (this is Change Set 18131) But will it run in 2010? Nope, we haven't changed the installer to put the Add-In in the 2010 location and not the 2008 location. Also, the Add-In's configuration hasn't been changed to identify that it runs in Visual Studio version 10 (2010) and not Visual Studio Version 9 (2008). Let's do those steps next.
First open the TeamReview.VSNetAddIn.AddIn (or your *.Addin) file and change the references from "9" to "10"
Next, open up Program.cs in the TeamReview.SetupRegistrationAction project, this is the custom code that runs during the install. It knows where to put the Add-in file where Visual Studio can find it. Find the reference to 2008 and change it to 10 - not 2010 - just 10. I'm not sure why this change was made but it caught me off-guard the first time.
Rebuild, and run the MSI or EXE in the bin/debug directory of theTeamReview.Setup project
Go to the Add-In Manager in the Tools menu. Activate TeamReview, and test it out.

Completion
That completes a basic conversion of an AddIn from Visual Studio 2008 to 2010 - seemingly working with barely any code change. It needs to be tested more, but so far the migration path seems to be pretty painless. The code changes that were made as part of this post can be found in Change Set 18138.

Now for the fun to begin. The next post will start taking advantage of those new pieces in 2010 - MAF, MEF, and WPF.

Migrating a Visual Studio Add-In to 2010 - Part 1

2008-11-28T20:59:00.000-08:00

With the release of Visual Studio 2010 looming in the distant future and it's new capabilties now seemed like a good time to discover the impact to TeamReview. It's an open source add-in after all, so why not use it as a case study?

And so it begins. I'll be publishing pieces of this "case study" as I progress through the migration. Because Part-1 is a little lengthy here's a guide.

New pieces of Visual Studio 2010
Managed Add-In Framework (MAF)
Managed Extensibility Framework (MEF)
Windows Presentation Foundation (WPF)
MAF and MEF Working Together
MEF and WPF Working Together
MEF, MAF and WPF as on big happy family

New pieces of Visual Studio 2010

VS 2010 leverages the Managed Add-In Framework (MAF) released in .Net Framework 3.5, the new Managed Extensibility Framework (MEF) scheduled for .Net 4.0, and a re-work of the Visual Studio editor to use Windows Presentation Foundation (WPF), which was released in the .Net 3.0 framework. Unfortunately I haven't used any of these technologies yet, so the migration will be quite the learning experience . It sounds like there is a low-impact migration path for an existing add-in to work in VS 2010 without rewriting everything to use these new pieces. A few people I've talked to say their is a "shim" as part of VS 2010 that allows "most" things to work without change. So that seems like a good first step for TeamReview. However, before we try that let's delve a little deeper into the new pieces.

Managed AddIn Framework (MAF)

From the Add-In Overview

The add-in model consists of a series of segments that make up the add-in pipeline (also known as the communication pipeline), that is responsible for all communication between the add-in and the host. The pipeline is a symmetrical communication model of segments that exchange data between an add-in and its host. Developing these segments between the host and the add-in provides the required layers of abstraction that support versioning and isolation of the add-in.

The following illustration shows the pipeline

The rest of the summary lists the add-in model's capabilities in more detail, here's a short review.

Independent versioning of hosts and add-ins. Use an older add-in in a newer host and vice versa.
Discovery and Activation of Add-ins. Find an add-in by unique identifier or by the type of add-in.
Configurable Isolation level of the add-in and host including using the add-in as an external process of the host
Lifetime Management of the Add-In. Due to the various isolation models that can be used garbage collection of a single process or app domain isn't enough.

It seems clear from the literature that MAF will become the core Add-In framework for all/most Microsoft products with Visual Studio and Office included. This would allow a single add-in to be used in many products, which is difficult currently due to the disperate add-in model designs.

At this point my assumption is that I'll have to write some pieces on the right side of the diagram above and that Microsoft has taken care of defining the contracts. Hopefully I won't have to spend too much time writing framework pieces and Microsoft has even written the add-in side adapter and the add-in view and I just have to write the Add-in.

MAF Resources

Managed Extensibility Framework (MEF)

From the MEF Home Page

The Managed Extensibility Framework (MEF) is a new library in .NET that enables greater reuse of applications and components. Using MEF, .NET applications can make the shift from being statically compiled to dynamically composed. If you are building extensible applications, extensible frameworks and application extensions, then MEF is for you.

That sounds a lot like a IoC Container to me. However, MEF is not just another IoC container, in fact it's not meant to be an IoC container at all. MEF unlike IoC containers is used to compose an application by dynamically including new bounds of functionality through discovery. Each extension can it-self include more discovery of extensions. IoC containers on the other hand know much about the structure and type of functionality and usually determine the parts via configuration. Often IoC is used to choose between a few known options that provide the same type of functionality, such as a stub for testing or the real thing for implementation. Contrary to IoC designs the composition of a MEF app can take endless permutations, and the set of options is not known by the application or the developer before hand.

MEF is meant for larger systems such as Visual Studio which can be extended by numerous people around the world to do un-predictable augmentations of that system. This is starkly different from the goal of an IoC design that's usually used by a development team for flexible testing and extension, but only within tight constraints of known needs. So, MEF is not just another general purpose IoC container.

MEF Resources

Windows Presentation Foundation (WPF)

By now most of us have an understanding of what WPF is so we don't need to go into much detail. However for a short recap here's an "official" wording from the Introduction page

Windows Presentation Foundation (WPF) is a next-generation presentation system for building Windows client applications with visually stunning user experiences. With WPF, you can create a wide range of both standalone and browser-hosted applications.

Why are we talking about WPF in this Visual Studio Add-In article? The 2010 shell and editor is written in WPF. If you want to extend it you're best bet is with WPF.

WPF Resources

MEF and MAF working together

MEF is a more generic extensibility model with lazy loads of dependencies, the ability to traverse large catalogs of extensions, dependencies-of-dependencies etc. MAF is focused on isolation and versioning of an add-in model where the host and add-in are most often written by different people or companies at different times.

Whether right or wrong, I find it helpful to conceptually bucket the two by thinking of MEF as achieving the intent of the Decorator pattern and MAF as achieving the intent of the Bridge Pattern.

Are they both used by Visual Studio 2010? Yes.

MEF can be used to augment the look and display of the editor for example to change XML comment display in C# files like Scott Guthrie did in his PDC 08 Keynote. MAF would be used for more invasive changes such as adding brand new functionality that you might want to be isolated from the VS process, or that you want to work in both VS and Office products, or so you can have a different versioning timeline from Visual Studio.

Could you use them together? Yeah, for example TeamReview will be included into Visual Studio via MAF, and then I could my define own MEF extensibility points and provide default implementations to the various TeamReview responsibilities to allow others to extend some aspect of TeamReview with MEF.

MEF and WPF Working Together

If like me, you aren't a WPF programmer already this section doesn't matter as much as the previous two. However, if you are - sorry, I'm not - so what I can tell you is that is that MEF takes care of the composing of WPF portions of an app, so Prism/CompositeWPF is no longer the first choice for putting WPF pieces together in Visual Studio 2010. Instead MEF should be your instinctual composing tool.

MEF, MAF, and WPF as one big happy family

In the end an Add-In will be loaded with MAF, compose itself with MEF, potential surface extensibility points with MEF, and create it's UI facilities with WPF. All three new acronym babies working together as part of one big big happy Visual Studio family.

More Resources

Seattle Alt.Net meeting -December 13

2008-11-23T11:49:00.000-08:00

The next meetup for the Seattle Alt.Net group will be held on December 13. Seems like there will be a planning session for an upcoming open-spaces Alt.Net meeting in Seattle.

Where: Microsoft, 320 Westlake Avenue N, Seattle
When: Saturday, Dec. 13th, 10am-5pm

Once you arrive, go up to the third floor, and there will be # posted to call to get in.

Seattle Code Camp Presentation

2008-11-15T20:46:00.001-08:00

Today I presented at Seattle Code Camp on Coding Standards and Code Review in Visual Studio Team System 2008. The content was a bit of a re-hash of some stuff I've been doing at work with CI Builds and mofiying FxCop rules and at home with TeamReview. While there were only a few attendees, it was still very cool. If you have the opportunity to volunteer for a local meet-up please go for it and don't think twice.

Here's all the content from my presentation including code samples and a team build file - start with the index.html at the root to guide you through. You can find posts on this blog that covers most of it if you look hard enough, ok.. if you look at all.

I didn't get to how treating XML comment compiler wanings as errors works out, or how to baseline your code base by automating Ghost Doc with TheWolf macro that I wrote - but those code samples are included in the downloadable rar file.

Here was the offiical blurb on my Seattle Code Camp presentation:

How to get better Coding Standards and Code Review from VSTS

There's some good stuff in VSTS for coding standards and code review, but how can you use it, and more importantly how can you make it better? In this session I will share my experience of successfully extending and customizing VSTS simultaneously in the open source community and at the enterprise level to get better code by automating the most important code standards and creating more valuable code reviews. Experience, an adoption/implementation plan, and code will be shared.

VSTS Code Coverage Bug?

2008-09-23T13:11:00.000-07:00

I am doing code coverage analysis with Visual Studio, which is generally an easy task now with the tools that are included. However, I have an issue that I can't overcome. Let's say I have assemblies A, B, C, and D and have marked them all for coverage analysis. I run the tests and look at the results and find a report that contains A, B, and C - but not D. I investigate and find that no tests actually execute any code in D (let's say it's the asp.net front end and I don't leverage UI testing yet). Because there are no tests for D causing D to be missing from the report the total code coverage percentage and "blocks not covered" are incorrect.

Does anyone know how I can do either of the following?

Calculate the total "number of blocks" in D so that I can manually adjust the coverage report to be correct?
Get the Coverage report to automatically show the number of blocks not covered for assemblies that are instrumented for coverage but are not tested at all?

While I do want test coverage to improve I am analyzing coverage reports saved at historic points in time in the code base. Thus I don't want to create a test that simply executes at least 1 block of code in each assembly and the re-calculate test coverage by running the tests. That would be a pretty time consuming work-around to something that seems like a simple problem.

TeamReview makes the list

2008-09-03T17:56:00.000-07:00

TeamReview has made it onto the definitive Team System Widget list!

A generous thank you goes out to Team System MVP, Richard Hundhausen, of Accentient for not only inlcuding TeamReview on the list but for also providing me with a tremendous introduction to Team System in a TFS Deep Dive workshop I attended through Accentient a few years ago. The course material is still at my desk, and I still use it.

Using GhostDoc in a macro to comment an entire solution

2008-09-02T19:46:00.000-07:00

At work we've started leveraging Visual Studio Team System to essentially automate the checking of Standards and Best Practices (S&BPs). We decided that anything that could be automatically enforced could be deemed part of the S&BPs because it was cost effective. Anything else could be deemed guidance but would not be required. One of the aspects that we desired was being able to effectively use Sandcastle to generate technical documentation. I personally feel that the most valuable documentation from XML comments comes form the comments on Acceptance Tests since they define the expectations of the system. To make those XML comments required we created a shared MSBuild file that treated some of the XML compiler warnings as errors.

Playing Catch-Up
This unfortunately left us with a lot of catch-up work. We needed to fill in and correct thousands of missing comments. While it would have been the most valuable to add thoughtful defined explanations in those places it also would have been the most costly - and it wasn't in our project budget to take on that cost. As a result I adapted a Visual Studio macro with some code-DOM traversing material borrowed from TeamReview in order to leverage GhostDoc to automatically fill in missing comments and fix some comment structure for an entire Visual Studio solution. This allowed us to take on the endeavor of changing our S&BPs, being able to enforce them for the better, and allowed us to move forward without immediately paying for Technical Debt due to the change in S&BPs.

Again, GhostDoc comments are meant to get us over the hurdle of not being able to enforce a coding standard. I know as well as you that auto-generated stuff isn't very valuable, but without it we wouldn't be able to approach this endeavor.

Before you run the macro
Be sure your code compiles and that you have the entire solution checked out from source control. Otherwise you'll get lots and lots of prompts, potentially two for every file.

Below is the code. The macro is named after the Winston Wolf character in the movie Pulp Fiction.

The Code

Option Explicit Off
Imports System
Imports EnvDTE
Imports EnvDTE80
Imports EnvDTE90
Imports System.Diagnostics

Public Module TheWolf

Public Sub CleanUpSolution()
IterateFiles()
End Sub


Private Sub IterateFiles()
Dim project As EnvDTE.Project
Dim projects As EnvDTE.Projects
Dim window As Window
Dim target As Object
DTE.ExecuteCommand("View.SolutionExplorer")
window = DTE.Windows.Item(Constants.vsWindowKindCommandWindow)
projects = DTE.Solution.Projects
If projects.Count = 0 Then
  Exit Sub
End If


For Each project In projects
  If (Not project.ProjectItems Is Nothing) Then
      CleanUpProject(project.ProjectItems())
  End If
Next
'RebuildSolution()
End Sub

Private Sub CleanUpProject(ByVal items)
Dim file As ProjectItem
For Each file In items
  If file.Name.EndsWith(".cs") OrElse file.Name.EndsWith(".vb") Then
      ActivateFile(file)
      RemoveAndSortUsings()
      FormatDocument()
      DocumentCode(file)
  End If

  'Handle folders within a project
  If Not file.ProjectItems() Is Nothing Then
      If file.ProjectItems.Count > 0 Then
          CleanUpProject(file.ProjectItems())
      End If
  End If
  SaveAll()
  CloseAll()
Next
End Sub

Private Sub RebuildSolution()
DTE.ExecuteCommand("Build.RebuildSolution")
End Sub

Private Sub SaveAll()
Try
  DTE.ExecuteCommand("File.SaveAll")
Catch ex As Exception
End Try
End Sub

Private Sub CloseAll()
Try
  DTE.ExecuteCommand("File.CloseAllButThis")
  DTE.ExecuteCommand("File.Close")
Catch ex As Exception
End Try
End Sub

Private Sub ActivateFile(ByVal file As ProjectItem)
file.Open()
If (Not file.Document Is Nothing) Then
  file.Document.Activate()
End If
Try
  DTE.ExecuteCommand("View.ViewCode")
Catch ex As Exception
  'do nothing - it's probably already viewable
End Try
End Sub

Private Sub RemoveAndSortUsings()
Try
  DTE.ExecuteCommand("Edit.RemoveAndSort")
Catch ex As Exception
  'does not work on VB code
End Try
End Sub

Private Sub FormatDocument()
DTE.ExecuteCommand("Edit.FormatDocument")
End Sub

Private Sub DocumentCode(ByVal file As ProjectItem)
Dim element As EnvDTE.CodeElement
Dim document As EnvDTE.TextDocument
document = CType(file.Document.Object(""), EnvDTE.TextDocument)
If (document Is Nothing) Then
  Return
End If
DocumentElements(document, file.FileCodeModel.CodeElements)
End Sub

Private Sub DocumentElement(ByVal document As EnvDTE.TextDocument, ByVal element As EnvDTE.CodeElement)
Dim startPoint As EnvDTE.EditPoint
document.Selection.GotoLine(element.StartPoint.Line, True)
startPoint = document.CreateEditPoint(document.Selection.ActivePoint)
document.Selection.MoveToPoint(startPoint, True)
DTE.ExecuteCommand("Weigelt.GhostDoc.AddIn.DocumentThis")
End Sub

Private Sub DocumentElements(ByVal document As EnvDTE.TextDocument, ByVal elements As EnvDTE.CodeElements)
Try
  For Each element In elements

      Select Case element.Kind
          Case vsCMElement.vsCMElementFunction
              Dim func As EnvDTE.CodeFunction
              func = CType(element, EnvDTE.CodeFunction)
              If (func.Access <> vsCMAccess.vsCMAccessPrivate And func.Access <> vsCMAccess.vsCMAccessProject) Then
                  DocumentElement(document, element)
              End If
              DocumentElements(document, func.Children)
          Case vsCMElement.vsCMElementProperty
              Dim prop As EnvDTE.CodeProperty
              prop = CType(element, EnvDTE.CodeProperty)
              If (prop.Access <> vsCMAccess.vsCMAccessPrivate And prop.Access <> vsCMAccess.vsCMAccessProject) Then
                  DocumentElement(document, element)
              End If
              DocumentElements(document, prop.Children)
          Case vsCMElement.vsCMElementEvent
              Dim evt As EnvDTE80.CodeEvent
              evt = CType(element, EnvDTE80.CodeEvent)
              If (evt.Access <> vsCMAccess.vsCMAccessPrivate And evt.Access <> vsCMAccess.vsCMAccessProject) Then
                  DocumentElement(document, element)
              End If
              DocumentElements(document, evt.Children)
          Case vsCMElement.vsCMElementClass
              Dim cls As EnvDTE.CodeClass
              cls = CType(element, EnvDTE.CodeClass)
              If (cls.Access <> vsCMAccess.vsCMAccessPrivate And cls.Access <> vsCMAccess.vsCMAccessProject) Then
                  DocumentElement(document, element)
              End If
              DocumentElements(document, cls.Children)
          Case vsCMElement.vsCMElementStruct
              Dim strct As EnvDTE.CodeStruct
              strct = CType(element, EnvDTE.CodeStruct)
              If (strct.Access <> vsCMAccess.vsCMAccessPrivate And strct.Access <> vsCMAccess.vsCMAccessProject) Then
                  DocumentElement(document, element)
              End If
              DocumentElements(document, strct.Children)
          Case vsCMElement.vsCMElementDelegate
              Dim dlg As EnvDTE.CodeDelegate
              dlg = CType(element, EnvDTE.CodeDelegate)
              If (dlg.Access <> vsCMAccess.vsCMAccessPrivate And dlg.Access <> vsCMAccess.vsCMAccessProject) Then
                  DocumentElement(document, element)
              End If
              DocumentElements(document, dlg.Children)
          Case vsCMElement.vsCMElementEnum
              Dim enm As EnvDTE.CodeEnum
              enm = CType(element, EnvDTE.CodeEnum)
              If (enm.Access <> vsCMAccess.vsCMAccessPrivate And enm.Access <> vsCMAccess.vsCMAccessProject) Then
                  DocumentElement(document, element)
              End If
              DocumentElements(document, enm.Children)
          Case (vsCMElement.vsCMElementVariable)
              Dim var As EnvDTE.CodeVariable

              var = CType(element, EnvDTE.CodeVariable)
              If (var.Access <> vsCMAccess.vsCMAccessPrivate And var.Access <> vsCMAccess.vsCMAccessProject) Then
                  DocumentElement(document, element)
              End If
          Case vsCMElement.vsCMElementNamespace
              Dim nmspc As EnvDTE.CodeNamespace
              nmspc = CType(element, EnvDTE.CodeNamespace)
              DocumentElements(document, nmspc.Children)
                Case vsCMElement.vsCMElementInterface
              Dim inter As EnvDTE.CodeInterface
              inter = CType(element, EnvDTE.CodeInterface)
              If (inter.Access <> vsCMAccess.vsCMAccessPrivate And inter.Access <> vsCMAccess.vsCMAccessProject) Then
                  DocumentElement(document, element)
              End If              
              DocumentElements(document, inter.Children)
            End Select

  Next
Catch ex As Exception

End Try

End Sub

End Module

Automating the Checking of Standards and Best Practices

2008-09-02T18:01:00.000-07:00

During the past few months I have been taking care of some developer "ecosystem" tasks at work. You know, all those tedious first-time tasks that nobody looks forward to doing but everyone should see the value of having them done. Things that increase a team's sustainability. Things like setting up a CI build, dealing with tests that have been ostracized for over a year, converting projects to the latest IDE and framework, making sure project files are set to create debug symbols properly, re-checking the "run code analysis on build" setting, deleting the slanderous comments that blame me - I'm sure you get the picture.

One of the more interesting challenges in this endeavour has been trying to create what is essentially automatically enforced Standards and Best Practices (S&BPs) to be used by the entire group. The IDE and Team System can assist in that enforcement with Code Analysis rules, Team System check-in policies, and automatically executed tests. However, if you're a .Net developer you probably know the disdain that some of us have for enforcing the full multitude of available Static Analysis rules. It's a fairly common occurrence to find the rules to be unchecked of the "run code analysis on build" setting to be turned off, or simply that developers suppress all violations with a highly tuned reflex of the mouse-button finger. Additionally, I've never seen anyone spend the time to fix all the code analysis warnings, because they don't "stop the line" by breaking the build.

One FxCop file for all Visual Studio Projects

There is a way to have a single shared FxCop rule file that all projects reference, that project files can't override, and that role-base security can be applied. And it's easy to implement.

Create a StaticAnalysis.targets file with the content below
Put the file somewhere convenient in TFS source control
Change the source control permissions of that file to be limited
Edit each csproj or vbproj file in notepad and add the following line just before the </Import Project="$(MSbuildBinPath)\Microsoft.CSharp.targets" /> tag - placement is important for overriding the specific project's Static Analysis settings (c# version shown here)

Build
Make sure your build server will properly get the StaticAnalysis.targets file to the location you referenced in your vbproj or csproj
Check-In
Notify your team that they need to get latest of the code and the location where you checked in the StaticAnalysis.targets file

What's in the file

The top line includes compiler warning numbers that we want to be treated as errors so that violations of them will "stop the line" and not just be ignored. Most of the numbers below are for XML comment issues. If you want to treat these XML comment problems as errors, consider this macro to help you clean up existing issues. You can get the number from warning statements in the output window when you compile.

The second section is the list of FxCop rules turned on as a waning (+), on as an error (+!) or off (-).

The File

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<WarningsAsErrors>1572,1591,0105,1574,0649</WarningsAsErrors>
<CodeAnalysisRules>
+!JBBrown.FxCop.Rules#JB1502;
+!JBBrown.FxCop.Rules#JB1505;

+!Microsoft.Usage#CA2209;
+!Microsoft.Usage#CA2215;
+!Microsoft.Usage#CA2202;
+!Microsoft.Usage#CA2241;
+!Microsoft.Design#CA1012;
+!Microsoft.Design#CA2210;
+!Microsoft.Design#CA1040;
+!Microsoft.Design#CA1005;
-!Microsoft.Design#CA1020;
+!Microsoft.Design#CA1021;
+!Microsoft.Design#CA1010;
+!Microsoft.Design#CA1011;
+!Microsoft.Design#CA1009;
+!Microsoft.Design#CA1050;
+!Microsoft.Design#CA1026;
+!Microsoft.Design#CA1019;
+!Microsoft.Design#CA1031;
+!Microsoft.Design#CA1047;
+!Microsoft.Design#CA1000;
+!Microsoft.Design#CA1048;
+!Microsoft.Design#CA1051;
+!Microsoft.Design#CA1002;
+!Microsoft.Design#CA1061;
+!Microsoft.Design#CA1006;
+!Microsoft.Design#CA1046;
+!Microsoft.Design#CA1045;
+!Microsoft.Design#CA1038;
+!Microsoft.Design#CA1008;
+!Microsoft.Design#CA1028;
+!Microsoft.Design#CA1004;
+!Microsoft.Design#CA1035;
+!Microsoft.Design#CA1063;
+!Microsoft.Design#CA1032;
+!Microsoft.Design#CA1023;
+!Microsoft.Design#CA1033;
+!Microsoft.Design#CA1039;
-!Microsoft.Design#CA1016;
+!Microsoft.Design#CA1014;
+!Microsoft.Design#CA1017;
+!Microsoft.Design#CA1018;
+!Microsoft.Design#CA1027;
+!Microsoft.Design#CA1059;
+!Microsoft.Design#CA1060;
+!Microsoft.Design#CA1034;
+!Microsoft.Design#CA1013;
+!Microsoft.Design#CA1036;
+!Microsoft.Design#CA1044;
+!Microsoft.Design#CA1041;
+!Microsoft.Design#CA1025;
+!Microsoft.Design#CA1052;
+!Microsoft.Design#CA1053;
+!Microsoft.Design#CA1057;
+!Microsoft.Design#CA1058;
+!Microsoft.Design#CA1001;
+!Microsoft.Design#CA1049;
+!Microsoft.Design#CA1054;
+!Microsoft.Design#CA1056;
+!Microsoft.Design#CA1055;
+!Microsoft.Design#CA1030;
+!Microsoft.Design#CA1003;
+!Microsoft.Design#CA1007;
+!Microsoft.Design#CA1043;
+!Microsoft.Design#CA1024;
+!Microsoft.Design#CA1062;

-Microsoft.Globalization#CA1301;
-Microsoft.Globalization#CA1302;
-Microsoft.Globalization#CA1303;
-Microsoft.Globalization#CA1304;
-Microsoft.Globalization#CA1305;
-Microsoft.Globalization#CA1306;
+!Microsoft.Globalization#CA2101;
-Microsoft.Globalization#CA1300;

-!Microsoft.Interoperability#CA1403;
-!Microsoft.Interoperability#CA1406;
-!Microsoft.Interoperability#CA1413;
-!Microsoft.Interoperability#CA1402;
-!Microsoft.Interoperability#CA1407;
-!Microsoft.Interoperability#CA1404;
-!Microsoft.Interoperability#CA1410;
-!Microsoft.Interoperability#CA1411;
-!Microsoft.Interoperability#CA1405;
-!Microsoft.Interoperability#CA1409;
-!Microsoft.Interoperability#CA1415;
-!Microsoft.Interoperability#CA1408;
-!Microsoft.Interoperability#CA1414;
-!Microsoft.Interoperability#CA1412;
-!Microsoft.Interoperability#CA1400;
-!Microsoft.Interoperability#CA1401;

-!Microsoft.Mobility#CA1600;
-!Microsoft.Mobility#CA1601;

+!Microsoft.Naming#CA1700;
+!Microsoft.Naming#CA1712;
+!Microsoft.Naming#CA1713;
+!Microsoft.Naming#CA1709;
+!Microsoft.Naming#CA1708;
+!Microsoft.Naming#CA1715;
+!Microsoft.Naming#CA1710;
+!Microsoft.Naming#CA1720;
-!Microsoft.Naming#CA1707;
+!Microsoft.Naming#CA1722;
+!Microsoft.Naming#CA1711;
+!Microsoft.Naming#CA1716;
+!Microsoft.Naming#CA1725;
+!Microsoft.Naming#CA1719;
+!Microsoft.Naming#CA1721;
+!Microsoft.Naming#CA1724;
+!Microsoft.Naming#CA1726;

+!Microsoft.Maintainability#CA1501;
+!Microsoft.Maintainability#CA1500;
-Microsoft.Maintainability#CA1502;
-Microsoft.Maintainability#CA1505;

+!Microsoft.Performance#CA1809;
+!Microsoft.Performance#CA1811;
+!Microsoft.Performance#CA1812;
+!Microsoft.Performance#CA1813;
+!Microsoft.Performance#CA1823;
+!Microsoft.Performance#CA1800;
+!Microsoft.Performance#CA1805;
+!Microsoft.Performance#CA1810;
+!Microsoft.Performance#CA1822;
+!Microsoft.Performance#CA1815;
+!Microsoft.Performance#CA1814;
+!Microsoft.Performance#CA1819;
+!Microsoft.Performance#CA1804;
+!Microsoft.Performance#CA1820;
+!Microsoft.Performance#CA1802;
+!Microsoft.Performance#CA1807;
+!Microsoft.Performance#CA1817;
+!Microsoft.Performance#CA1818;

-!Microsoft.Portability#CA1901;
-!Microsoft.Portability#CA1900;

+!Microsoft.Reliability#CA2002;
+!Microsoft.Reliability#CA2003;
+!Microsoft.Reliability#CA2004;
+!Microsoft.Reliability#CA2006;
+!Microsoft.Reliability#CA2000;

+!Microsoft.Security#CA2116;
+!Microsoft.Security#CA2117;
+!Microsoft.Security#CA2105;
+!Microsoft.Security#CA2115;
+!Microsoft.Security#CA2104;
+!Microsoft.Security#CA2122;
+!Microsoft.Security#CA2114;
+!Microsoft.Security#CA2123;
+!Microsoft.Security#CA2111;
+!Microsoft.Security#CA2108;
+!Microsoft.Security#CA2107;
+!Microsoft.Security#CA2103;
+!Microsoft.Security#CA2118;
+!Microsoft.Security#CA2109;
+!Microsoft.Security#CA2119;
+!Microsoft.Security#CA2106;
+!Microsoft.Security#CA2112;
+!Microsoft.Security#CA2120;
+!Microsoft.Security#CA2121;
+!Microsoft.Security#CA2126;
+!Microsoft.Security#CA2124;
+!Microsoft.Security#CA2100;

+!Microsoft.Usage#CA2236;
+!Microsoft.Usage#CA1816;
+!Microsoft.Usage#CA2227;
+!Microsoft.Usage#CA2213;
+!Microsoft.Usage#CA2216;
+!Microsoft.Usage#CA2214;
+!Microsoft.Usage#CA2222;
+!Microsoft.Usage#CA1806;
+!Microsoft.Usage#CA2217;
+!Microsoft.Usage#CA2212;
+!Microsoft.Usage#CA2219;
+!Microsoft.Usage#CA2201;
+!Microsoft.Usage#CA2228;
+!Microsoft.Usage#CA2221;
+!Microsoft.Usage#CA2220;
+!Microsoft.Usage#CA2240;
+!Microsoft.Usage#CA2229;
+!Microsoft.Usage#CA2238;
+!Microsoft.Usage#CA2207;
+!Microsoft.Usage#CA2208;
+!Microsoft.Usage#CA2235;
+!Microsoft.Usage#CA2237;
+!Microsoft.Usage#CA2232;
+!Microsoft.Usage#CA2223;
+!Microsoft.Usage#CA2211;
+!Microsoft.Usage#CA2233;
+!Microsoft.Usage#CA2225;
+!Microsoft.Usage#CA2226;
+!Microsoft.Usage#CA2231;
+!Microsoft.Usage#CA2224;
+!Microsoft.Usage#CA2218;
+!Microsoft.Usage#CA2234;
+!Microsoft.Usage#CA2239;
+!Microsoft.Usage#CA2200;
+!Microsoft.Usage#CA1801;
+!Microsoft.Usage#CA2205;
+!Microsoft.Usage#CA2230;
</codeanalysisrules>
<RunCodeAnalysis>true</RunCodeAnalysis>
</PropertyGroup>
</Project>

Team System MVPs press on TeamReview

2008-09-01T13:45:00.000-07:00

Over the last few weeks a couple of Team System MVPs, Omar Villarreal and Willy-Peter Schaub have been doing TeamReview a tremendous favor. Omar has been giving some great feedback on the TeamReview product and helped identify and resolve a few bugs. Additionally he was able to get Willy-Peter's attention which lead to a wonderful write-up of TeamReview and an outstanding WorkFlow guidance poster.

From Omar Villarreal on using TeamReview

From Willy-Peter Schaub

Introduction to TeamReview
Evaluation of TeamReview
Follow-Up on TeamReview
Quick Reference Work Flow Posters: JPG (high quality), PDF (low-meduim quality)

Thanks Omar and Willy-Peter!

Attending VSX DevCon 2008

2008-08-25T23:01:00.001-07:00

I will be attending VSX DevCon 2008. If you see a guy with TeamReview on his badge, talking about Code Review process a lot, or otherwise trying to pimp some open source project on CodePlex called TeamReview that uses the VSX model and the Team System API..... it's me.

More importantly, if you've used TeamReview and can give me constructive feedback I'd love to hear it, and I'm not above buying a drink or two in order to monopolize your time.

TeamReview - new business value from code review

2008-06-01T14:58:00.000-07:00

Visual Studio Team System allows software development to focus more time on the most valuable piece of creating software – creating business value. With the integration and collaboration support of Team System teams can now focus more on their business domain and spend less time creating and managing the software development process and its supporting ecosystem. VSTS, like all the best software tools, removes waste from the software development process allowing teams to deliver more value. TeamReview continues the waste reduction that Team System supplies by augmenting the code review sub-ecosystem with a Vs.Net add-in that integrates Team System and VS.Net’s extensibility model to create a new completely in-IDE code review experience.

The .Net Code Review Ecosystem
.Net code review tools have been improving over recent years and removing some of the traditional necessity of code review, but not the most valuable aspect. There are static analysis tools like FxCop to automatically review for all the code-deterministic industry standard guidance. There are source analysis tools like Microsoft’s recently released Source Analysis (a.k.a. StyleCop) to review all the source code style choices made. With Continuous Integration and TDD code is reviewed to make sure it builds and meets the expected business scenarios. Products like NDepend have been recently introduced to review code and provide statistical information to help determine if designs are following principles that lead to sustainability. All of these types of tools augment the ecosystem in which we review our software. However, none of them provide any help in one of the most critical aspects of code review - the answer to the question “does this code deliver the best value for the business domain?” Just because code passes FxCop, StyleCop, looks good in NDepend and passes automated tests doesn’t mean it provides the best business value. Those tools are part of a domainless code review ecosystem, they don’t have any insight into any of the businesses we create software for or how well our code serves that domain. The answer to the “best value” question is in some ways subjective, but the most capable people to provide the answer are the coders in that domain using the tacit technical and business knowledge that only they retain. Code reviews are the way to apply and share that tacit knowledge and find the answer to the “best value” question.

Traditional Code Review Style
Traditional code reviews are conversational in style. One person asks for a review and they get any number of responses from any number of people. Each response is usually recorded in note style indicating where the code is, what it’s doing, and how to make it better. There are a lot of transitions in the traditional process; for example transitions of people to and from meetings, transitions in and out of the code to a note taking, reading, or explanation system, transitions from reviewing developer to developer representative to requesting developer and back, etc. In each transition there is waste in the cost of the transition and waste in intent and accuracy lost during the transition.

TeamReview
TeamReview uses Team System and VS.Net’s extensibility features to retain the conversational style of code reviews without the transition waste. With TeamReview team members have the ability to provide their code review feedback without transitioning out of the IDE. That response subsequently becomes directly available to the requester also without transitioning out of the IDE. Code Review feedback is given by highlighting a chunk of code, choosing the “New Code Review Response” option of the TeamReview menu, entering a few fields, and assigning it to another team member. [1] [2] When the requester is ready to review and implement feedback they choose the “Replay Code Review” option of the TeamReview menu, which displays a grid of all the feedback in a new window in the IDE. [3] Clicking on any of the grid rows will open the local copy of the code file and highlight the snippet of reviewed code putting the developer at the exact place where changes are suggested with all the information necessary to act on that suggestion. [4]

The beauty behind this process is that submitting feedback with TeamReview creates a new work item in the Team System project that includes the entered feedback, highlighted code, file name, line numbers, and names of the Project, Namespace, Type, and code member such as the method or property name. [5] The work item is a new work item type, Code Review Response, that is shipped as part of the TeamReview download. [6] [7] As you might have guessed reviewing and acting upon responses with TeamReview’s “Code Review Replay” option is implemented behind the scenes by TeamReview running a TFS query for those items and then displaying them in a grid, followed by using Vs.Net extensibility model to handle select and click events.

Since the review process and the details of the code within that process are stored in Work Items not only do you gain the standard project management capabilities that come with work items you also have the ability to perform code review forensics. For example a query for code review responses that are in an open state is easily added to the Team Queries of the TFS project. Another query could find code projects, namespaces, types, or members that traditionally get the most code review feedback indicating a trend that they may need to be refactored. Another query could find all code review responses for a particular Type to get suggestions about that type’s responsibility and design intent if that type was being redesigned, re-used or extended. A report could determine the lag time between feedback being supplied and being implemented by comparing the work item creation and closed dates.

Conclusion
TeamReview exploits the advantages of Team System and the Vs.net extensibility model to reduce transition waste and surface new value from the code review process. Using Work Items to facilitate the code review process creates a completely in-IDE code review experience, the ability to project-manage the code review tasks, and the opportunity to get new value from the code review process through code review forensics.

For More..

On how to use TeamReview see TeamReview by Example section on the TeamReview home page
To download TeamRevew see the current release (1.0.6) of TeamReview
To setup your TFS Project for TeamReview see the Setup instructions
To debug or contribute to TeamReview see the debugging instructions

Why is ReaderWriterLockSlim missing from Enterprise Library 4?

2008-05-20T19:41:00.000-07:00

With the release of Enterprise Library 4 I thought for sure the Caching Application Block's use of the simple System.Threading.Monitor would be replaced with the new ReaderWriterLockSlim that is part of .Net 3.5. After all, Jeffrey Richter was right about the slow performing ReaderWriterLock, and now there is a better solution than what was in Enterprise Library 3.1, right? Yet in the source of EL 4 you can still find the calls to Monitor and some simple lock(object) statements. It seems like an easy performance win to me, but hopefully there is a good reason it's not included that I just don't know about.

Documentation is Modeling

2008-05-11T10:58:00.001-07:00

I've had the opportunity to discuss the value of documentation as a part of the software creation process lately. I hadn't noticed until then how much my views were influenced by a couple of pages in Agile Principles, Patterns, and Practices in C# by Robert and Micah Martin. The book is absolutely phenomenal and has had a strong influence on my development in the last few years. There's a small transition between two sections of the book as it leads out of principles and into modeling practices. That transition struck a cord with me in regards to documentation and that cord is resonating loudly as of late.

Modeling
A bridge builder creates a model to test the strength to weight ratio of the bridge. An airplane designer creates a model to put it in the wind tunnel to test the aerodynamics of the design. The bridge and airplane models were smaller versions of the real thing built to learn something about how to better build the real thing. Why smaller? Smaller is cheaper in these cases. An important aspect of modeling is that the model is cheaper to build than the real thing. If the model is more expensive to build than the real thing it wouldn't be providing any strategic value, you could just skip building the model and go straight to building the real thing. The second value in the bridge and airplane models is that they were built to be tested. One was tested by how much weight it could hold, one was tested to see how efficiently it could move through the air. Without being tested the models provide no value, they're just like the model car kits I put together as a kid, they're fun to look at but not good for anything else. Without testing the model you don't learn anything about building the real thing.

Value from Modeling
Modeling provides value only when both of the following are true. Without both being true modeling is just wasted work to create something pretty to put on a shelve and admire.

The model is cheaper to build than the real thing.

The model is built to be tested to figure out how to build a better real thing.

Modeling Software
Software is no different from the bridge or aerospace industries in regards to modeling. We model software by writing something down on a piece of paper, whiteboard, or napkin to express the characteristics and designs of the real thing. We then test that model by asking our peers, customers and other knowledgeable people if their assumptions, scenarios, goals, etc are all fulfilled by the model. Their answers determine how much the real thing will reflect the model, or if remodeling needs to be done. Modeling in software takes many forms, UML, requirements documents, technical specifications, test cases, use cases, etc. They are however all textual models that can be tested to prove some virtual characteristic of the software.

Value From Documentation
Thus, applying the two points above that determine when modeling is valuable we can determine when to document and how to get the most value out of documentation.

Documentation should be relatively cheap.

Documentation should be created when we want to test the software before building it.

To get the most from documentation we should only create it when we need to test and when we can create the documentation and test it cheaper than creating and testing the software. I think the key point that is often missed is that the documentation needs to be easily testable. Documentation in thesis form might be a well written masterpiece but it's not easily testable. To figure out if a particular scenario will be fulfilled I would have to read the whole document to find all the references for impacts to that scenario and then compose them into one and apply my scenario test. That is not cheap, nor easy. Modeling software with User Stories however is much easier to test because the model is organized into identifiable pieces of work in the way that the development team builds and tests the software. This results in a shared thought pattern (ahem, mental model) by the entire team - the modelers and the builders. User Stories convey the virtual characteristics in ways that allow for cheaper and easier testing of the documentation in order to build better software.

So, as we create documentation to help us build software we should ask ourselves:

Is this documentation testable? (If no - then don't create it.)
Can something be learned about the software by testing this documentation? (If no - then don't create it)
How can I make this documentation cheaper to build and maintain?
How can I make this documentation easier to Test?

Changing FxCop Maintainability and Cyclomatic Complexity rules

2008-05-10T14:28:00.000-07:00

I'm finally moving to VSTS 2008, and yesterday I spent some time playing with the new Maintainability index. I am a big fan of NDepend and have used it for a year or so now in an effort to create more sustainable code, thus the new Maintainability index was promising to me. However, after finding out the range for the index is 0 - 100 and the thresholds are 10 for an error and 20 for a warning I was again disappointed with the extremely conservative implementation, just like I was with the high Cyclomatic Complexity thresholds.

How to change the thresholds
I started out trying to use the same approach that worked with 2005 in order to change the FxCop thresholds for these two rules. However editing the IL and reconstituting the Maintainability.dll without the strong name doesn't work anymore with 2008 because it references two other strong named assemblies. Also, I was never really ethically satisfied with the old approach any way.

After looking at the assembly with Reflector and reading a great tutorial on creating FxCop rules I started approaching the problem with the Decorator pattern to wrap the existing rules with my own. I assumed then that I could deactivate the Microsoft shipped version of the rules and activate my own in each Vs.Net project's Static Analysis settings. Implementing the Decorator pattern was a bit tricky though because the existing rules have both the Internal and Sealed modifier so I couldn't simply "new up" an instance nor could I inherit from the shipped types and override the pieces I wanted to augment. Luckily reflection provides a way to do everything that I needed even though the type signatures don't.

What I ended up with was a new JBBrown.FxCop.Rules.dll containing 3 class definitions - 1 abstract class and 2 new FxCop rules that implement the abstraction. The abstract class does the work of instantiating the Microsoft shipped rule, setting the thresholds and delegating FxCop API calls off to the decorated instance. The two new rules specify the new threshold values by providing the names of private variables within the Microsoft shipped rules to be reset to new custom chosen values. This is what the resulting VS.Net project's Static Analysis settings looks like when using the Decorated rules.

The Code
The entire source can be found here to allow you to set your own preferred thresholds for the Maintainability and Cyclomatic Complexity FxCop rules. After you compile the project then just drop the dll in your Rules directory and restart your Vs.Net. The FxCop rule directory path should be similar to "C:\Program Files\Microsoft Visual Studio 9.0\Team Tools\Static Analysis Tools\FxCop\Rules"

TeamReview 1.0.2: Code Review - just a lot less painful

2008-05-02T18:32:00.000-07:00

A few days ago I released TeamReview version 1.0.2, which introduced integrated IDE support for Code Review Item closing/editing during the Code Review Replay process. Also, thanks to Maarten Balliauw a bug was fixed for VSTS 2008.

If you could benefit from cheaper, easier and more valuable code review TeamReview might be your answer; check out this TeamReview Example

Defining a Project Vision with the Minimum Useful Feature Set

2008-04-30T18:18:00.001-07:00

A while back at work I was included in a project kick-off session. The general idea of what would be developed was already determined, but neither the exact features nor a feature priority had been identified. What we needed to do was find the most valuable features that met the product vision.

We needed to find the Minimum Useful Feature Set (MUFS).

The practice and principles I describe below helped us discover the MUFS and has since been used in a few more projects and has been a great introduction to Lean for many.

What is a Minimum Useful Feature Set?

A MUFS is the smallest amount of work that provides the most new market value. If that definition seems vague and subjective it's because it is; and defining the most valuable work for any business to endeavor upon is not easy - people struggle at it everyday. One thing that is clear about a MUFS is that the value from a MUFS is not necessarily cash flow coming in from customers. Many times a MUFS value can be realized from such things as internal learning from a prototype, the ability to do some usability testing on a subsection of what will eventually be delivered, or simply realizing that a critical user story has not been satisfied. Thus a MUFS does not necessarily mean "something that can be deployed to customers."

Sounds complicated - where did you get this stuff?

It's an application of Lean, the Minimum Useful Feature Set term comes from Implementing Lean Software Development from Mary and Tom Poppendieck. The MUFS is a result of eliminating waste - specifically waste from what I'll call Kitchen Sink Marketing - when software tries to satisfy everyone in a market all at once by including every possible feature instead of satisfying the most valued part of the remaining market successfully in increments.

So how do I figure out the MUFS when there are so many potential features?

To discover the MUFS you can use a technique that you probably are already familiar with, but apply it a bit differently. The Planning Game has been used by many development teams to estimate the development effort of a User Story after Features are chosen by a business. Later in this article I'll present how to use the Planning Game in a new way, with a different group of people at an earlier stage in the project in order to eliminate waste and identify the MUFS. However, before we get to how this works let's talk about why it works.

Latest Responsible Moment Decision Making

James Shore has a great post Beyond Story Cards that explains the Latest Responsible Moment Decision Making well. I'll be using a lot of his material here, so let it be known that he deserves credit for this section.

'Latest responsible moment' is a core agile idea. The term comes from Lean Software Development. The idea is that you want to put off decisions as long as you can: to the latest responsible moment. But it's the latest responsible moment, not the 'last possible' moment. That wouldn't be responsible. - James Shore

Lean Manufacturing uses a principle called Just In Time. Like most things in Lean, the fundamental purpose of Just In Time is to eliminate waste. Instead of each station on an assembly line running at full capacity and pushing inventory out of the station and into a pile, a storage facility, or somewhere else that station only runs fast enough for the next station to pull what is needed just in time to do it's work to meet the pull of the following station etc. This avoids materials being consumed without any realized value. When materials are pushed out of a station and into a pile or storage area they have incurred the cost of being created, the cost of being transitioned to the storage and will incur the cost of being found again for consumption and the cost of being transitioned back to wherever they are needed - if they don't expire, and if they are needed, which sometimes is not the case. In software we don't have a constrained amount of raw materials going in and tangible goods coming out of an assembly line. Instead we have a limited amount of decision power going in and software being delivered at the end.

To make sure that we are not creating decision waste we should make decisions only when they are needed - at the latest responsible moment - when you have the most information, that information is the most accurate and making the decision is the most valuable thing that can be done.

Thus with Latest Responsible Moment Decision Making decisions are pulled into existence because they are demanded by something that needs to consume that decision immediately. This is opposite of what we often experience in software where decisions are made and pushed into later phases of development with the belief that those decisions will be needed. Those pushed decisions may not be valuable at all and would end up in the waste section of the image above by not contributing to the delivery of the software. Even if the pushed decisions end up being needed and inside the focus-time cone above they still incur the waste of decision inventory storage and retrieval from somewhere such as your email inbox or a spec document.

How to define a Vision with the Planning Game

This is how we found the Minimum Useful Feature Set by using the principle of Latest Responsible Moment Decision Making.

Prepare you materials

Set up the meeting, invite the Customer/Customer representative and a representative from each group that will be affected by the project. Some examples include the project manager, the marketing representative, the solution architect, a customer service lead, a tester, and one person from each system that will probably be impacted. Somewhere around a 70/30 business/technical mix of people seems to work well. In total a group of around 10 to 15 people is good.
Get A lot of 3 x5 index cards
Find some tape
Get some markers
Find a white board or paper
In your meeting room draw the Latest Responsible Moment Decision Making diagram
In you meeting room draw the following X-Y chart (to be explained later)

Define a few roles

The visionary - this is the customer or customer representative. The person paying for the project that knows what they want. This person is responsible for making sure that decisions are made within the Focus-Time cone above as indicated by the green vertical line. For fun you can refer to this person as the Focus Waste Engineer.
The facilitator - the person who knows the Planning Game, can teach it to others and can politely settle disputes. This person is in charge of making sure that the group is making timely decisions as indicated by the orange horizontal line above. For fun you can refer to this person as the Time Waste Engineer.
The scribe - no matter how successful the facilitator is at minimizing decision waste, people will discuss tangential things that may be valuable. The scribe records them, mostly to comfort group members that the important stuff they say isn't just gone forever.

Explain Latest Responsible Moment Decision Making
Supplement the description above with some information that Lean was established by Toyota over half a century ago and that it has been used successfully by companies around the world for many years to gain a competitive advantage in their market.

Create Feature Cards
Feature cards are nothing more than Story cards, but for features, or a Theme of stories if you prefer. I just use a different name so that if/when you get to the normal Story Cards or Story points part of your project people don't get confused.

A feature card is a 3x5 index card with the name of the feature on the front and behaviors of the feature on the back
It's a 3x5 because there's no room to record decision waste by making too many or too detailed decisions
Feature Cards are placeholders for future conversations
Feature Cards are not the spec, the spec comes later (if at all)
Don't worry about spelling, punctuation etc
If a behavior doesn't fit on one line it's probably more than one behavior in disguise

Play Planning Poker
This is much like your basic planning poker. However instead of playing poker for development effort you are instead going to play poker twice, once for Value and once for Ease of Deployment. Value in this case is defined by the amount of good a feature will contribute to achieving the Vision. Ease of Deployment is estimated instead of cost of development for a couple of reasons. The first is simply for information display purposes - we want the good stuff in the upper right since that's how most people expect to read the graph. Also, cost of development is often viewed as just the Dev and QA efforts and doesn't include other costs such as sales staff training, customer service impacts, marketing efforts, etc. - and all of that stuff is real cost so it should be included. Thus, estimate the 'ease of deployment' instead of the 'cost of development' to remove that ambiguous 'development' word from being a stumbling block.

As you play planning poker you'll need to record both the Value and Ease Of Deployment values as noted by the "V=80" and "D=30" on this example Feature Card

Discover the Minimum Useful Feature Set
Once you have created all your Feature Cards and played Planning Poker for Value and Ease of Deployment you tape up each feature at the appropriate place on to the Value-Ease of Deployment graph shown above.

At this point you'll have a very easy to understand visual representation of the relative ROI ratio of each feature.

Now starting at the bottom left of the graph read a feature and ask if the feature should be included in the MUFS. You may have to remind the group at this time that just because a feature is not in the MUFS it doesn't mean it won't be delivered, it just means it won't be planned for the first development cycle and that cycle may or may not end in a customer release. I don't have any defined voting or other process for doing this step in identifying the MUFS. I've found so far that one isn't needed and that general discussion is valuable and "close enough consensus" will be achieved. By starting in the bottom left with the features that are hard to deploy with low value the decisions are easy and the group will get comfortable with this process and establish a rhythm. When the group indicates that feature isn't part of the MUFS remove it from the chart and tape it up somewhere else for display. Leaving it up on the side is a gentle reminder to people that the feature isn't lost forever, it could still be delivered later. As you start moving from the bottom-left to the top-right picking off features the discussion will get more involved and the weighing of pros and cons will become more lively. This is an indicator that you are close to identifying the green MUFS arch shown in the Value-Ease of Deployment image above. After you've crossed that arch and get very close to the top right you'll find that the decisions are again easy and not much discussion is needed.

When you are done with all the Feature Cards the MUFS is the collection of features left taped to the value-ease of deployment chart - you'll need to mark each card as part of the MUFS so that you'll know when they come off the board. The smaller the arch is - the higher the ROI ratio is for the MUFS.

Polyglot programmer

2008-04-30T12:59:00.000-07:00

My thanks go out to Dave Laribee for sharing the opening “Fishbowl” session of Alt.net on video. The fishbowl topic is “Polyglot Programmer” which was a topic mentioned many times during the weekend. The fishbowl method of hosting a discussion was neat to see. This fishbowl was done in order to show the rest of us how it worked, so there’s some explaining mixed in with the Polyglot discussion.

You won't see me, but my Mt. Dew bottle has a cameo.

The Alt.Net Community

2008-04-23T22:07:00.000-07:00

If you share the goals of Alt.Net but missed the "big" conference this past weekend, join the mailing list on Yahoo. Or a regional list such as this Google Group for Seattle.

Planning and Migrating TFS Videos

2008-04-23T12:36:00.000-07:00

These videos are an outstanding find for those planning or implementing a TFS install or migration.

Thanks to Willy-Peter Schaub for sharing this with the community

Alt.Net in Seattle

2008-04-21T16:20:00.000-07:00

I was able to attend Alt.Net in Seattle last weekend. I am drained now and need some recovery time. It was mentally intense for me. If you haven't been to an Open Spaces conference before I recommend that you find one soon. While there are many highlights that I could catalog I was mostly in awe to be around such a telented and notable group of individuals. Also, it's just plain fun to say I saw some guy try and win a professional dissagreement against both Martin Fowler and Scott Hanselman.

TeamReview released

2008-04-21T16:08:00.001-07:00

Last week I released a new open source project on CodePlex, TeamReview. It's a Visual Studio.Net addin that facilitates an in-IDE code review process and provides many advantages over the traditional code review meeting, or "reply all" email broadcast.

After trying to patch Guy Kolbis Code Review Addin and having my patches unevaluated for over 9 months I finally resigned myself to finding a different way to contribute to the community. I commend Guy Kolbis's ideas and he deserves credit for what he's done. However, the product offering of TeamReview and the code base that it's built upon are big differentiators between the two projects.

Check out the TeamReview by Example on the CodePlex home page and then try out release 1.0.1

Cage Match: Decorator, Pipeline, Chain Of Responsibility

2007-09-10T18:46:00.000-07:00

Update Note:

When I first wrote this post I argued that the alias_method_chain example in the article linked below felt more like the Pipeline / Pipes and Filters pattern to me. What I didn't comprehend was that the alias_method_chain functionality of Ruby invokes behavior in another block of code within the context of the preceding block in the chain, and not simply an iteration of blocks of code (methods). So, while eating crow, I'll leave my post with some editorial adjustments to keep my comparison of the patterns and retain the knowledge that I can alias "alias_method_chain" to "decorate_methods" to make me feel more comfortable, and less misguided.

The Pipeline Pattern has been part of the coding that I've been doing lately, so when I got sent a great discussion of the Decorator Pattern in the Rails implementation from my design patterns discussion group co-host Wes I had to check it out. Charlie started a pretty intriguing discussion about the differences between the Decorator and Chain of Responsibility (CoR) patterns. Charlie started out his article with the claim that the Rails architecture was a CoR implementation and later on had a smart reply by Peter Williams that the architecture was not CoR, but rather closer to Decorator. It's hard to argue with a code author about the patterns they used, and even harder when the response comes from someone like me who is not a user of that code. (I should have known better, guess I'll learn) However I'd like to compare the Chain of Responsibility and Decorator patterns with the Pipeline /Pipes-and-Filters pattern.

I think the Charlie was on a common thought-track when he inadvertently described a piece of the Rails Architecture as Chain of Responsibility. Limited by the pattern vocabulary in the GoF book any list of methods to invoke in sequence might lead you to thinking about the CoR. In fact Chalrie's description of the code still contains the words "chain" and "link" in many places. In retrospect, the name alias_method_chain is a bit misleading for folks with a design pattern history and common practices that include pattern hints in the names of code elements, such as ValidatorFactory, ItemIterator, or BowlingFacade. Following the thought process in the article I began to think (and ultimately falsely came to the conclusion) that it wasn't CoR, but rather Pipeline / Pipes and Filters.

Until recently I wouldn't have been able to distinguish Chain of Responsibility and Pipeline, but after a while working with Pipeline I've formulated the following reasoning. As it often is with patterns, the two vary in their intent. The Pipeline Pattern is not CoR because pipeline pieces are collectively responsible for handling a message unless an exception condition is met in any one piece, while CoR passes the request only up-to the point at which a single chain claims responsibility for the complete processing of the message. Pipeline is meant to be used as a static whole, while CoR (and Decorator) are designed for dynamic part-whole composition. The individual components of the Rails implementation probably aren't designed to be used in any combination, or in whole-part compositions, but rather designed to be used as a single conceptual entity with it's pieces always in the same order relying on processing precedence.

Charlie's frustration with not being able to break existing dependencies in the Rails framework and inject a new participant in the middle of the established code helps support the argument for Pipeline with it's static whole nature instead of the dynamic part-whole design of CoR and Decorator. The author's follow up quandary about being able to distinguish the conceptual difference between the "Decorators" and Rails filters helped me believe that Pipeline/ Pipes-and-Filters was a more accurate description of the design than CoR. Conceptually it seemed like Pipeline / Pipes-and-Filters to me, not CoR or Decorator.

Where I went wrong was being too confident in my interpretation of the problem and the consequences of the pattern that Charlie was experiencing. I skipped the very crucial step of evaluating the pattern within it's context; I didn't look at how the alias_method_chain structure and the aliased methods' implementations fit together. As a result the Decorator pattern wins the cage match with a knock-out punch to my ego at the end of the first round.

Team System, WorkFlow and C# Concept Posters

2007-07-29T12:36:00.001-07:00

Some great concept posters for the visual learners amongst us can be found at the Developer Readiness Program. The colorful Team System, WorkFlow, and C# posters are going to be the primary focus of the new decor in my cube.

Best Practices for Designing Frameworks that are Reusable Object-Oriented Libraries

2007-07-23T10:22:00.000-07:00

I finally got around to watching best practices for designing frameworks that are reusable object-oriented libraries. The presentation is based on the content from MSDN’s Design Guidelines for Class Library Developers and the Framework Design Guidelines book.

Presentation Positives:

100% .Net focused – some topics that you’d only consider in a .Net environment
Well organized
Well presented for a developer presentation, I liked the analogies and a great quote from Napoleon
He gives an overview of Microsoft’s api review process, including mentioning a tool that makes an API word document from the code. I haven’t searched for the tool yet.
There’s a 20 minute section at the very end where he explains constructing teams that produce good API designs

Presentation Negatives:

It’s long; there is a “fast mode” that makes the presentation watch-able in 1 sitting though
The speaker is a bit repetitive at times to really “hammer home” a point
No details on processes or tools that help an organization measure “API effectiveness” or “API cost”
No helpful ways to train and educate “shu” level on good API design other than reading the design guidelines. He recommends having someone who is “ha” or “ri” level be responsible for the API on a project and have an organization wide API review team for inter-project API consistency.

Recommendations:

Overall, I would recommend watching this if you haven’t already read the MSDN site or the book and want to be a good .Net API designer and have your code “feel like” the .Net framework code.

Joshua Bloch’s “How to Design a Good API and Why it Matters” has more value for the time spent watching the video, and is more concentrated on non language specific OO design guidelines making Bloch’s video more universally true and probably more timeless. The .Net video has its place however; I’m glad that I finally watched it but I don’t think I’ll have a need to watch it again any time soon. Having discussed many of the .Net API Design Guidelines and consumed many .Net libraries a lot of the concepts are ingrained into my practices and expectations already.

I am thankful, however, that API design resources like this are published in a medium from which I may learn.

Change FXCop Cyclomatic Complexity Threshold Values

2007-06-19T19:27:00.000-07:00

Update: Here's the 2008 Version, the below post is for Visual Studio 2005.

Glavs Blog has provided light at the end of the tunnel for those of us who have been scouring the Internet for a way to change Visual Studio Code Analysis Cyclomatic Complexity thresholds. The shipped thresholds are way to high for my taste and I've wanted an easy way to integrate an enforced cyclomatic complexity ceiling within the red-green-refactor process. Glavs article about Creating Custom FXCop rules and altering existing ones - Part 2 shows how to use the .Net framework utilities Ildasm.exe and ILasm.exe to pipe out the contents of the code analysis rule to MSIL, change it and then recompile with the changes. Following this procedure the shipped CC thresholds of warning at 25, critical warning at 50, error at 75 and critical error at 100 can now be whatever you desire.

I suggest one alteration to Glavs directions; don't' recompile to the same assembly name. This will cause other code, such as the Code Analysis Check-In Policy, that was compiled against the Microsoft shipped strong name version to break, and any service packs that ship a new version of the assembly will overwrite your changes. So compile it to a new name leave it in the same folder then in your VS.Net projects enable the new code analysis rule and disable the old.

Of course, I don't know the legal or ethic responsibilities of Monkey Patching the code analysis rule under the Visual Studio license. Hopefully Microsoft will understand that this is an attempt to get the best value out of the IDE when other options aren't available and not an attempt to gain a competitive advantage or tarnish their product.

Dining on your education

2007-06-03T15:09:00.000-07:00

Scott Hanselman is one of my favorite bloggers, and he recently posted a great follow up about one my favorite tools, NDepend. As he states, the nitty-gritty of NDepend can be overwhelming at first, but it's power is immediately obvious. Sorting out how to get a team to collectively and effectively use the vast capabilities of NDepend can be an obstacle. Thanks to Scott's blog entry, and offer to share at Tech-Ed we can all dine on our NDepend education. I'm not going to Tech Ed, hopefully I can get a coworker to snag one of the placemats for me.

Additions to Guy Kolbis - Code Review Add-In

2007-06-03T12:32:00.000-07:00

Update: - TeamReview, the open-source project that I started a while after I wrote this post, is thriving as the most complete code review solution for Team System

I just completed my first participation in an open source community by submitting a patch to Guy Kolbis - Code Review Add-In. The new features were enjoyable to code since the Team System code api is well designed and intuitive. You don't need much time, and very little reference material to figure out how the pieces of the API work together. The additions to the Code Review Add-In were much easier to accomplish than I originally expected. It's certainly not the most elegant code I've ever written, but the cost-to-value ratio has got to be pretty high. Prior to this morning I hadn't even looked at any of the Team System code API, let alone write anything useful. Ten hours later I'm writing my first blog post about my first open source work that was with my first experience with Team System API.

New Add-In Feature - Work Item Association
The new features, by themselves, are going to be helpful to me and hopefully to you too. I think one of the biggest advantages of the update is the ability to associate Work Items being submitted with other existing work items. This may seem like a pretty basic accomplishment, but with the right work item setup you can bridge the gap between the Add In and another CodePlex project; TFS Code Review Workflow. The Workflow project includes a check-in policy that causes code to be shelved and a work item created for someone to review the code shelf. Once the code is reviewed and the work item addressed, the code can be committed from the shelf. The work item type that the Workflow project uses is aptly named "Code Review," the definition of that type is a part of the Workflow project and is easily imported into any project you desire.

The Code Review Request-Response Gap
Now that the Guy Kolbis - Code Review Add-In can associate new Work Items to existing ones all a code reviewer needs to do is configure their Add-In settings to query for the items of the "Code Review" type created by the Workflow project. This is done by creating a new Team Query that returns only work items of the "Code Review" type in the proper state (for example "Open, In Progress"). Then as the reviewer highlights-right-clicks-and-submits their review items the existing Code Review work item created by the Workflow check-in policy is updated each time with a link to the reviewers submission. When the reviewer has completed their review they then have the single Code Review work item that catalogs their review, and can assign the Code Review work item back to the originator. Thus the "TFS gap" between code review initiation and code review feedback has been bridged and a more effective and developer friendly process created.

Work Item Type Compatibility
Included in the patch I submitted are two work item types, the first is a slightly modified "Code Review" type from the Workflow project that shows off some of the patch's updates. This type should still be compatible with the Workflow project, and work well as a Work Item to link to from the Add-In. The second work item type "Code Review Item" is one that I made in order to map the Add In's resolution field to an HTML formatted text field in Team System. Both of these types reference a "Code Reviewers" Team System group, this is to remain compatible with the TFS Code Review Workflow project, which has the capability of emailing the Code Reviewers group when a new Code Review item is submitted.

Conclusion
Of course all of this excitement is tentative at the moment while the patch is being evaluated. Hopefully everything will go smoothly and the patch will be accepted. Even if it isn't I am encouraged by the well thought out Team System API and platform, the flexibility in outcomes that it supports, and the velocity at which it allows development to occur. So, thanks for that Microsoft, and thank you Guy Kolbis for letting me meddle in your code.

Here's some information and screen shots about Guy Kolbis - Code Review Add-In before the patch.