Eric Lee - A Humble Blog

My blog has moved

ericlee — Wed, 03 Jan 2007 00:26:00 GMT

Hey guys,

To better coincide with my company, my blog has moved to http://blogs.counterpunchsoftware.com; I hope to see you at that new location!

Thanks,

Eric.

Apologies, forgot to include a file in my Hemi distribution

ericlee — Mon, 20 Nov 2006 22:56:27 GMT

Hey guys,

Sorry, in my Hemi tool, I’m using a 3rd party control from Component One. I have a license for their tools and they allow redistribution. The file you need is located here: C1.Win.C1FlexGrid.2.zip.

Thanks to Grant for spotting this so quickly.

Eric.

Work Item Moving Tool is back!

ericlee — Mon, 20 Nov 2006 12:35:45 GMT

Hey guys, I've finally had a chance to update my work item moving tool to work with the RTM release of Team Foundation Server. Along the way, I made some modifications and changes that I've wanted to do for a while. I haven't thought of a better name than 'work item mover' so for now I've code-named it if you will 'Hemi'.

I’ve posted the tool to: http://www.counterpunchsoftware.com/downloads/hemi.release.zip. You’ll also need: C1.Win.C1FlexGrid.2.zip.

I included the Team Foundation Server binaries that it depends on, but the best way to run the tool is just to run Hemi.exe from the Visual Studio Tools Command Prompt.

Hemi starts up and looks as follows:

I’m thinking about using a MDI type of interface in the future; that would enable you to save and re-run moves that you might do on a regular basis.

To start moving work items, the first thing to do is use the File menu…

This starts the various stages involved in moving work items from one team project to another.

The first thing to do is pick the Team Foundation Server that you want to access.

Depending on the authentication that you are using, you may get prompted for credentials. Once you’ve chosen a Team Foundation Server, the next step is to select the work items that you want to move. This is done by selecting a Team Foundation Server Query.

Pressing this button will bring up the same work item query control that is used in the Excel integration.

Once you select a query, press the Find button on this dialog to bring up the actual work items. Press OK and you’ve established the work items that you are going to move. Now select the Team Project to move these work items to.

Once you’ve done that, press Next to move on to the next stage.

Any query that you might use might encompass a few different work item types, so in this stage, you’ll decide how to map those work item types to the Team Project you are moving the work items to. In most cases, you’ll probably move the work items to the same type in the other Team Project.

But, sometimes work item types are defined differently. For example, in a CMMI project, a bug is defined with two required fields – Symptoms and Steps to Reproduce. These fields aren’t required in an Agile project. So, this stage also gives you the chance to fill these missing values in. Press the Check for Missing Values to see what these missing values are.

If there are any, enter values into the table.

Press Next to move on to the next stage and actually move your work items.

This stage shows you what work items will be moved, as well give you a couple of options for your original work items. Team Foundation Server doesn’t support deleting work items, so your original work items will still exist. By default, Hemi will create a Moved state for these work items and assign them to that state. Also, it will create links between the original work items and their new copies, and vice versa.

Once you move to the next stage, your move will be committed!

If you look at your original work items, what you should see is that it is in a Moved state:

And also, your original work item will be linked to the new one, and vice versa.

Anyways, I hope you find Hemi useful – if you run into any bugs or have suggestions, please let me know. Either through this blog or email me at eric@counterpunchsoftware.com.

Thanks!

Eric.

A change of address of sorts...

ericlee — Wed, 08 Nov 2006 18:44:00 GMT

Hey guys,

Well, the time has come.

After 8 years at Microsoft, I've decided to pursue a long-time dream of running my own business. My new venture will be in a Seattle-based consulting company, CounterPunch Software (www.counterpunchsoftware.com). Not surprisingly we (or more accurately I) will be focusing on Microsoft technologies and solutions. My last day at Microsoft will be towards the end of November.

Not too much will change blog-wise – I believe that I am still allowed to have my blog on MSDN so I’ll keep it here. MSDN has been pretty good to me, and I’m loathe to change my blogjet settings

I will always look back on the past 8 years with fond memories. I'll apologize for not thanking everyone individually, but I've enjoyed the tremendous privilege of working with, and learning from, some of the smartest and most passionate people imaginable. For that, I'll always be grateful.

It's a cliché of course, but it really does seem like yesterday when I walked into building 44 to start my first day at Microsoft. At the time, I thought I was joining what was then known as the Visual Interdev team, little did I know that I had already experienced my first re-org and had been transferred to the Visual J++ team :) In any case, it all worked out very well

I’ve always been very passionate about Microsoft products – particularly, but not limited to, developer tools – and the folks who use them. I think, and hope that my new venture will allow me to get closer to that.

My new email address is eric@counterpunchsoftware.com.

Anyways, just a personal update

Thanks!

Eric.

Windows Vista for Extreme Programming?

ericlee — Wed, 25 Oct 2006 05:44:00 GMT

Hey guys,

As you can probably tell, the bright shiny lights of the soon-to-be-released products like Windows Vista and Office 2007 have caught my eye lately. I promise I’ll be back to Team Foundation Server blogging soon.

I’ve been playing with a feature in Windows Vista that I thought might be useful for development teams who are practicing Extreme Programming. The feature is called Windows Meeting Space and is one of the out-of-the-box applications that takes advantage of Windows Vista Peer-to-Peer networking and more specifically, People Near Me.

Both Peer-to-Peer networking and People Near Me are vast areas that I don’t fully understand; Justin Smith does a nice job of talking about the technology in his recent MSDN article.

In terms of leveraging what is already there, Windows Meeting Space struck me as an easier to use netmeeting/netsharing/livemeeting technology. It seems perfectly suited for a quick code review, or paired programming session.

I found Windows Meeting Space from the handy search dialog in the start menu:

Starting a meeting is pretty easy – easier than most of the Microsoft collaboration tools I’ve used. Basically pick a name and a password. I like how Windows Meeting Space puts the time into your name automatically. You could also search for existing meetings. Let’s say that we’ll create a code review meeting.

Once created, you can invite people from the menu. This is where People Near Me (PNM) comes into play. PNM is supposed to search your subnet for peopled who have chosen to broadcast their identity. From this list, you can invite people to join your meeting. It might have been because of mismatching versions of Vista, a weird network connection, or something else, but I was never able to get a list populated with people near me.

In any case, you can use the “Invite others…” button to create an invitation file that you email around. Or, people in your network can use Windows Meeting Space to find this meeting, and invite themselves. For example, on my other Windows Vista machine, I’m running Windows Meeting Space and I can see this meeting we’ve just created:

Suppose that we were given the password out of band, we’re able to join this meeting.

Now we can start some sharing and do our code review. If you press the sharing icon in the meeting, you get a choice of what kinds of applications you want to share. The PNM API supports a way to determine whether the attendees of your meeting have the same application or not. In our case, since we are doing a code review, we’ll share Visual Studio.

As the person you initiated the sharing, you see a subtle tool bar in your desktop that says you are doing the sharing. You have the option of stopping your sharing, pausing it and even sending it to a projector.

On the other side, for the folks who are attending the meeting, they see Visual Studio embedded into their meeting space window.

The image of VS that I have there is really squeezed, it is because I only have 1 monitor, so I have to show both my host VS instance as well as my shared one on the same real estate.

Anyone in the meeting can request control of the application and make code changes, comments etc.

None of this is necessarily anything new – you could always share with LiveMeeting and Remote Assistance and what not, but somehow Windows Meeting Spaces feels easier to use than all of those technologies. I like that you don’t have to explicitly send out invitations if you don’t want to; you can just search on your network for a meeting to join. Also, I like that there is an API underneath the covers; in theory you could build this type of sharing into right your application. For example, for Visual Studio, maybe you could setup sharing for individual document windows or something?

In any case, I thought this might be an interestig feature in Windows Vista, so I thought I would share.

Thanks!

Eric

Fixed my images and uploaded the Exchange sample code...

ericlee — Tue, 24 Oct 2006 22:43:00 GMT

Not sure what happened, but it seems like BlogJet is struggling with my build of Vista. In any case, my images are fixed up and I posted the full sample code here.

Thanks!

Eric

Ugh, messed up my images...

ericlee — Mon, 23 Oct 2006 07:56:54 GMT

Apologies, I seem to have hosed something on my hosting site. Other than today, all of the images from my posts seem to be gone; hopefully I’ll have things up and running again soon.

Thanks,

Eric

Exchange Server 2007 Web Service API for Developers!

ericlee — Mon, 23 Oct 2006 06:33:00 GMT

Hey guys,

Exchange is a Microsoft technology that I’ve used everyday for email, but never really delved into as a developer. I’ve been working on some Office 2007 stuff, so I figured I would give it a try.

I was absolutely knocked out by how much you can do as a developer with Exchange Server 2007. There are a number of things, but what really caught my eye was the Web Service API.

I’ve experimented with CDO and MAPI a little bit in the past, but I’ve always struggled with it. It was always a struggle to download the version of CDO/MAPI that matched my server; and even the most trivial task like sending an email seemed really difficult.

But, with Exchange Server 2007, you can access a wide range of its functionality through its web service API. I didn’t find a lot of documentation about the API – a lot of it seems to be a work in progress – but I managed to get some of it working, so I wanted to share what I’ve learned.

First, I downloaded Exchange Server 2007 from http://www.microsoft.com/technet/prodtechnol/exchange/2007/downloads/beta.mspx. The installation was relatively painless. The setup is quite good, there were a few prerequisites that I didn’t have, so I was notified and had a chance to restart the setup.

The exchange web service is located at http://<yourserver>/EWS/Exchange.asmx, so you can literally just add a web reference to that URL and get a proxy class generated for you.

The main proxy class is ExchangeServiceBinding, you can instantiate it just like any other web proxy class.

The exercise I took myself through was fairly straightforward – what I wanted to do was to expand a distribution list to see who belonged to that list. For each person on that list, I want to check their availability. In other words, I want to see if they are available for a 1–hour meeting today.

The first thing to do is to expand out the distribution alias – Exchange Server 2007 has a web method to do exactly this, so it is just a matter of making the call.

You’ll notice something about the Exchange Server 2007 API that you may love, or you may hate. Notice that the ExpandDL takes a single parameter – an instance of ExpandDLType. That type contains members for all of the information that ExpandDL might need as input.

In my experience, there are essentially two main schools of thought about how to define a Web Service API.

One school of thought is to develop web service methods just like they are ‘regular’ methods. For example, if a web service method needs 4 parameters for input, that web service method signature would have 4 parameters. It is pretty intuitive for developers to use a Web Service API like that.

Another school of thought is to develop web service methods as though they were endpoints to which documents were submitted. I was introduced to this approach when I was a developer on the UDDI feature in Windows Server 2003. That is how we defined our web service API. There are pros and cons to this approach. When you take this approach, you typically start designing the web service method from the XSD schema onwards. When you have to worry about interoperability, this isn’t a bad approach at all. When I worked in UDDI, we worked with other companies to be sure that our UDDI implementatio would work with theirs. Whenever we met, we would work on defining just the XML schema. That helped because some companies used Java, some script and we used .NET to implement our version of UDDI. It would have been difficult to talk about programming interfaces since there were so many in play. What is also helpful about this approach is that you can use XSD schema validation to do some basic parameter checking. For example, consider the following XSD type:

Exchange Server 2007 uses this type as a return value of sorts when you make a request to see a user’s oof (out of office) settings. It’s funny to see a relatively colloquial term like OOF make it into the API of a enterprise messaging solution Anyways, the author of this API is using XSD and its ‘minOccurs’ and ‘maxOccurs’ operators to define what is essentially the post-condition the operation to retrieve a user’s oof.

This can be good for both the producer and consumer of the API. For someone who is looking to use this API, the XSD gives them an idea of what to expect as a return value. When you have detailed documentation, this isn’t a big deal, but when you have a new API like with Exchange Server 2007, reading the XSD is critical. For someone who is developing this API, there is validation that is usually done on the outgoing end of the web service. Each outgoing message (i.e. GetUserOofSettingsResponse) is validated against its schema. If it violates something, it is returning something the user is not expecting, so it fails. Essentially, you are checking against the contract you agreed upon with your intended caller.

This approach was really helpful for us in UDDI because our shared UDDI specification was always changing. What we did was put XSD schema validation on the incoming and outgoing ends of our web service. Whenever we got a UDDI message, we validated it against schema before we passed it on to the appropriate method (ASP.NET allows you a hook to do this before it delegates to the appropriate web method). If the incoming message didn’t pass validation, that meant it would give our actual method trouble of some sort. Either the signature didn’t match, or the expected parameters changed. In any case, if the message failed validation, we threw an exception right away. On the outgoing end, we validated each response message we sent against its schema. If something failed validation, that meant whatever we were returning was not what was expected by our caller. Again, we threw an exception in this case. Whenever our UDDI specification changed, we just uploaded the new XSD schemas in our system. Whenever the UDDI design committee decided that a given parameter must occur at least once, but not more than 5 times for example, they put it into the XSD. And through XSD validation, our code automatically checked for that condition. That saved us from spending a lot time writing and changing our input and output validation code.

All that said, there are drawbacks to this approach as well. Mainly, it feels weird if you’re coming from a pure programming perspective, and instantiating a bunch of composite classes can be a pain Once you get used to it though, it’s not so bad.

OK, enough about XSD and web service API design methodologies and back to Exchange Server 2007. Once you make the call to expand the DL, you basically get back a set of email addresses (sort of).

What you get back at first is a collection of response messages. I’m not sure when there will be more than one response to your request, maybe if there are clustered/linked Exchange servers. In any case, in any given response, there is a collection of email addresses. The double loop to go through this looks like:

I should mention, I don’t work at a fashion design firm – the context of the code being shown is for a demonstration that I’m working on

What our inner loop, as illustrated above, is working through is each member of our distribution list. Each member may be a person or another distribution list itself. I didn’t write this code, but what we should do is check for the type of member that we got back. There is an enumerated type on EmailAddressType that we can check for:

If this is another DL, I suppose you might want to go through and recursively expand each one. We won’t do that in this simple example, so let’s assume that each member we get back is just a person and not another DL.

If that’s the case, the only thing we need to do is define what our meeting time looks like:

And make the call to check the user’s availability.

I skipped some of the plumbing code – mostly setting up some of the parameter types. I’m having some trouble with my FTP server, but I’ll post the rest of my code tomorrow.

That’s about it – the next thing I’d like to look at is actually creating some lists and folders in Exchange 2007.

Thanks!

Eric

Presentation/Demo Tips

ericlee — Tue, 17 Oct 2006 11:03:00 GMT

Hey guys,

When I first started at Microsoft 8 years ago, I was an awful presenter. I hardly made any eye contact and I spoke really, really, really fast. Over the years, I’ve had some training by some really good instructors and gotten a lot of practice. Now I like to think of speaking as one of my strong points.

Mentally, I’ve been keeping a little list of tips and tricks – many of which have come from fellow speakers – that have helped me. I thought I would share some of them in this post. A lot has to do with doing technical demos since I feel like that is one of my strong points in any presentation I do.

Make sure the audience can see what you’re doing

It can be really hard for an audience to see things on the screen when you’re doing a demo; particularly in a complicated user interface like Visual Studio. There are some things you can do, and utilities that you can use to help them out.

ZoomIt is a great tool for zooming in on specific parts of Visual Studio (thanks for the tip Martin Woodward!)

Try the following from Tools -> Options in Visual Studio

In the Environment->Fonts and Colors setting, make the text editor font use at least size 16 and change the font to Lucida Console (I find this font shows the larger text better). Try to make this change before you speak because the first time you access the Fonts and Colors settings it takes a long, long time.
Turn your system font up to Large from the properties of your Windows desktop. The Visual Studio tool windows will pick up this larger font. Make sure to test all the windows that you are going to show since some VS windows don’t handle the large system font that well. You might have to restart Visual Studio as well.
Try hiding as many tool bars as possible to keep Visual Studio from looking cluttered.

Keep things snappy

Performance is always important for any demo that you might do. It goes without saying to get a machine with as much RAM and CPU horsepower as possible; here are some of my other favorite tips.

If you’re running a Virtual PC or Virtual Server, a secondary hard drive is an absolute must. Virtual PC and Virtual Server are really IO intensive, so if you run a virtual image on the same hard drive as your native operating system, you will get a lot of contention on that drive. Another hard drive, either native in your computer or USB does wonders.
Buy as much RAM as you can afford/fit into your machine – at least 2 GB is ideal
Try to use fast hard drives, at least 7200 RPM.
I’m addicted to defragging my VPC drive – I do this after almost every time I run a virtual PC image. The built-in defrag utility in Windows is pretty good. The commercial product from Diskeeper seems to defrag faster and can be put on a schedule. I’m not sure if it does a better job or not. I’ve also used a free tool from http://www.flexomizer.com/PermaLink,guid,ce99367e-158c-487a-879d-b32145cc1957.aspx. That tool probably takes the longest, but does the best job I’ve seen. Thanks to David Whitney for writing this tool!
There are tons of ways to optimize your VPC images themselves. A good document can be found at: http://blogs.msdn.com/nolansax/attachment/700992.ashx. These tips really do make a big, big difference in performance.
Before you finalize your VPC image, try running CCleaner. This handy tool cleans up IE history, old setup files and a bunch of other bits of data cluttering up your system.
If you can, don’t use differencing drives – they are really handy, but they eat up your performance.
If you can, don’t enable undo drives – again, undo drives are super handy, but they do eat up performance. Despite this, I tend to run with undo drives enabled.
If you turn off themes in the VPC OS, or set the UI to maximize performance, your image will run faster. I don’t usually do this because I don’t like the way the display looks.
For Visual Studio Team System demos, my colleague, Ajay Sudan has a nice technique where he runs a Team Foundation Server in a VPC, but uses a natively installed Visual Studio to access it. That’s a nice combination because you can’t beat running the client bits natively when it comes to performance.
This can be time consuming, but I think it’s worth it. If you’re showing Visual Studio, open up each file type (i.e. C# files, resource files, etc) and note what tool bars they enable in Visual Studio. To maximize the perceived performance, close every tool bar that every document you are doing to show enables. This way, when you switch from document to document in Visual Studio, there are no delays from drawing the tool bars.

Slow Down!

This is something that I use to really, really struggle with - trying to slow down my speaking pace. What I’ve found is that I can’t just tell myself to slow down. What I try to do is concentrate on maintaining my volume from end-to-end when I’m presenting. One thing I’ll notice when I’m speaking quickly is that my voice tends to trail off at the end of a sentence. This is usually because I’ve used one breath for the entire sentence and by the time I get to the end of that sentence, I’ve run out. Using one breath for a sentence like that is usually a sign for me that I’m going too fast. So, I concentrate on making sure I take a breath somewhere in the middle so that I can finish strong. To get that breath in, I’ll need to pause somewhere between my words. With some practice, I’ve been able to take a quick breath and still sound like I’m speaking naturally. That has really helped me slow down. I’m still a fast speaker, and I probably always will be, but what I’ve found with trying to breath better is that I can make myself easier to understand.

A funny thing to keep in mind is that I think that no matter how experienced of a speaker you are, there is some inaccuracy in how you perceive yourself and how your audience perceives you. This is particularly true for pace. What tends to happen is that when you’re trying to slow down your pace a bit on stage, your brain will tell you that you’re speaking way too slowly and that you sound like an idiot. In reality, you sound perfectly normal to your audience. This is where video tape comes in handy. What I’ve done in the past is record myself speaking at various speeds. I’ll go really, really slow; so slow that I can barely take it and then go watch myself on tape. What I’ve noticed is that you can go really, really really slow and feel awkward doing it, but it looks and sound perfectly normal. I didn’t have to do this too many times before I got a better at gauging my actual pace versus my perceived pace.

All that said, the last thing you want to do is stretch out every single word and put your audience to sleep. Varying your pace is always good and makes you sound (and be) much more a genuine speaker. If you’re excited about something, let yourself speak a bit faster, a bit louder. Just be sure to slow down now and again when you wanto make a point or do a re-sync with the audience.

Enjoy Yourself

We’re lucky to be in an industry that is driven by so much passion. If you’ve taken the time to put together a presentation, take the time to enjoy delivering it. No matter how badly you think you did, chances are it wasn’t that bad. Chances are, you did a good job. In almost all cases, your audience wants you to succeed – so if you meet them 1/2 way, you’ll have done a nice job more times than not.

Anyways, just some thoughts I wanted to share.

Eric.

A diversion - Windows Live Alerts

ericlee — Sun, 08 Oct 2006 04:26:00 GMT

I’ve been poking around the Windows Live stuff for developers (http://dev.live.com) and someting caught my eye. With Live Messenger (formerly MSN Messenger), you can sign up for, as well as provide Alerts. These alerts get delivered to your device of choice (MSN Messenger, Phone, PDA, etc).

One of my projects at work right now is to work on the keynote demo that will be delivered at Tech Ed Barcelona later this fall. Not to give too much away, but one of the things we might try to cover is the developer angle for Windows Live. So, I thought I would give this alerts thing a try.

I went over to http://signup.alerts.live.com/brochure/index.jsp and registered the RSS feed for my blog as a provider of alerts. The sign-up experience was a pleasant surprise. The form was pretty short and a few minutes after submitting it, I received an email with a confirmation link. After clicking on the confirmation link, I received another email a few minutes later with the following image/link:

If you click on that link, you’ll have the option of signing up for alerts from my blog

Oh one thing – you’ll notice that my alert is called ‘Fabrikam Design’ – I named it that to match the fictious company name we are using for the demo.

Thanks,

Eric.

'Wall Time' as a way of determining correctness

ericlee — Fri, 29 Sep 2006 01:01:00 GMT

Quite a few years back, I joined the Windows Server 2003 team as a developer. Windows Server 2003 is a massive organization – I was part of the UDDI team which resided under Directory Services.

Our QA team had a suite of about 300 automated tests. The collected the ‘wall time’ of a test run – so literally how many minutes/seconds it took for each test to run. The ‘wall time’ amounts were aggregated into a test suite run time.

When I first joined, that suite of tests was taking about 2 hours to complete. That was a concern because the test suite used to only take about 20 minutes. We used a homegrown solution to store our test data and this was 2002, so there was no SQL Server 2005 Business Intelligience to take advantage of

My first task when I joined was to determine if there was a performance problem – the number of tests in the suite had increased, and so had our functionality – and if there was one, to fix it. I spent a long while in our profiling tools (crude compared to what we have today) and tracked the problem down to a Thread.Sleep() that someone had accidently put in the code.

What was ironic was that we had several unit tests that targetted that particular piece of code. Looking back, at the test results for those unit tests, I could see that the ‘wall time’ for those tests had almost tripled. On their own, these slower unit tests only added a little bit of time to the test run. But when the Thread.Sleep() code those unit tests were targetting werer hit by our load/scalability tests, the slowdown because expontential.

What we didn’t have then was a way to express how long a test was supposed to take. We checked for return values, the presence of exceptions, etc, but we couldn’t say that a test would fail if it took longer than some amount of time.

This ‘timeout’ is something that is built into Visual Studio Team System. If you look at the properties of a test, you’ll see a timeout property.

The value of this property is a handy way to define the performance characteristics of a given test. Run times will of course differ based on hardware, but this property is a good sanity test.

Thanks,

Eric.

Building development scorecards

ericlee — Thu, 28 Sep 2006 01:03:00 GMT

Hey guys,

Earlier this year, I did some blog posts about how to create key performance indicators (KPIs) based on the software development data that Team Foundation Server collects.

There are numerous clients for those KPIs, but the one that is probably the most dedicated KPI client from Microsoft is Business Scorecard Manager (BSM); with the upcoming Office 2007 release, this product will become a part of Microsoft Office PerformancePoint Server 2007. The BSM team blog has lots of great information about their product.

Scorecards in general are interesting. In just about any business, there are dozens, if not hundreds of data points to collect when trying to build an overall (or sub-overall ) view of the business so somebody can make a decision. One of my first projects when I joined Microsoft was to build a status collection and display web application for our QA team. Team members would update the status of their test runs, and every week the managers would look at the overall status and decide on strategy. That simple web site was in essence a score card. Maintaining it was a pain, because different teams had different data formats and different preferences for updating their data. Some didn’t want to use a web site, some did, etc.

Gathering and displaying data from across many different teams and normalizing data formats is what Business Scorecard Manager does a really nice job of. BSM takes KPI’s from various sources, including itself, and visualizes them in a consistent manner.

Usually, BSM is shown in the context of business functions like sales and finance, but there is no reason not to use it for software development data as well.

Let’s use the KPI’s from my earlier posts as an example. Below is a screen shot of what one of them looks like inside the SQL Server 2005 KPI browser view.

The first step is to import our SQL Server 2005 KPIs’ into a format that BSM understands. The KPIUtil from Microsoft Downloads does exactly this. The instructions for the tool are excellent; basically you install the sample indicators and run the tool to import your KPIs from SQL Server 2005. The first step is necessary to bring in the indicators that SQL Server KPIs have access to.

After running KPIUtil, we will have access to our LeadTime KPI inside of Business Scorecard Manager. I just used one of the example workspaces (SalesSummary) from Business Scorecard Manager to augment. In a real project, you would probably want to create your own workspace from scratch.

A BSM scorecard can be published into many different forms. One way is to publish the scorecard into Windows Sharepoint Services – BSM will automatically create, format and populate a WSS page for you. Once published, this page will stay in sync with any changes that you might make to your scorecard.

Before adding our LeadTime KPI, the WSS page generated by the example Sales Summary score card looks like this:

Inserting a new KPI into the scorecard is pretty straightforward. Objectives are used to organize data in your scorecard, so you might create an objective for tracking various KPIs for your software development.

There are various aspects of an objective that I can’t do justice to, so I’ll just add the LeadTime KPI to the objective we just created.

Once we re-publish this scorecard, our WSS page is updated as well, and we see our new KPI, displayed pretty much the same way as we saw in the SQL Server 2005 browser view:

I’m not sure that scorecarding is for everyone, but I think it might be more applicable than people think. Whenever I walk through the hallways of our development team, or many others at Microsoft, I see monitors on the walls that show various charts and graphs tracking project progress. Most of these systems are hand created and maintained. I wonder if Business Scorecard Manager would be a more efficient solution?

In any case, I’m always on the look out for a technology that might make software development a little bit easier. There is a lot of capabilities in the upcoming release of Office 2007, so I’m looking forward to doing more posts about that.

Thanks!

Eric.

Building a Virtual Kanban System with Team Foundation Server - Part 1

ericlee — Mon, 11 Sep 2006 23:11:00 GMT

Hey guys,

David Anderson is someone that I’ve had the privilege of working with for the past couple of years. One of the things that I’ve found really interesting about his work is that he often takes practices from other industries and applies them to managing software development.

One example of his is the idea of a Kanban System. Many Japanese manufacturing companies have used this process with great success. The basic idea is to control the amount of raw material in play. Wikipedia has a great explanation of the system in general.

“The Kanban system might be visualised as a "Three bin system" - one bin on the factory floor, one bin in the factory store and one bin at the Suppliers' store. The bins usually have a removeable card that contains the product details and other relevant information - the Kanban card. When the bin on the shop floor is empty, the Kanban card is removed and given to the store. The store then replaces the bin on the factory floor with a full bin which also contains a removeable Kanban card. The store then contacts the Supplier and indicates the need to replenish the Kanban card. The product also containing a Kanban card is delivered into the factory store completing the final step to the system. So it will never run out of product, providing of course, the cards are reliably collected from empty containers”

David Anderson has had a lot of success applying the principles of a Kanban System to software development. It remarkable how effective a relatively lightweight process like a Kanban System can be; his paper describes in detail the success of a Microsoft IT team.

I won’t do justice to the work so I’ll leave it to you to read the paper; what I wanted to explore was how one might implement a Kanban System with Team Foundation Server.

As I mentioned in one of my earlier posts, I think there might be some really interesting integration between BizTalk Server and Team Foundation Server. BizTalk becomes really useful when you have to make a bunch of things and people interact in a reasonable and consistent way; otherwise referred to as orchestration

I’m new to BizTalk Server so I wanted to experiment with how it can be used in conjunction with Team Foundation Server. I’m just scratching the surface of BizTalk so be warned, there might be easier/better ways to do things. The full solution can be downloaded here.

The Orchestration Designer integrates into Visual Studio 2005 and is a key part of BizTalk Server. First, I’ll show you the orchestration as a whole; then we’ll dive down into the details.

Let’s go through each step so we get a basic idea of what the orchestration looks like. The number items below match the numbers in the diagram above.

The orchestration is activated when we get a message indicating that a work item is changed
From a Kanban perspective, we only care about a work item that has changed if it is just been created, made active or closed. We don’t care about any intermediate changes. If this change matches that criteria, we are going to query Team Foundation Server to determine the number of active work items.
If a new work item has been created, and our Kanban is full – i.e. there are more than a certain number of active work items – then we will have to put this work item in our back log.
If a work item is being closed, and our Kanban has at least one open card – i.e. there are less than a certain number of active work items - then we will notify the customer that a free card is available.

That’s all there is to our Kanban System example.

But, you’ll notice that I left out a bunch of details – things like how do we determine the number of active work items, notify the customer, etc. One advantage of using BizTalk Server is that there is a separate between logical and physical ports.

A port in BizTalk Server is something you receive data from and/or send data to. The data being sent or received is in the form of XML. You have to define the structure of the XML immediately, but you can decide what the physical ports are later. You change them as well. So for now, we don’t have to worry about how we’ll get information about the number of work items in Team Foundation Server or how we notify our customer. We know we have to do it, we’ll figure out exactly how to do it later on.

Now let’s look into the details of the orchestration. First, let’s look at how the orchestration is activated.

1 – Port_WorkItemChanged Port

We haven’t done it yet, but we will register for WorkItemChanged events with Team Foundation Server. These event notifications will come into this port.

The designer unfortunately does not allow you to change the width of things, so the name of this port is somewhat obscured. The message we are waiting for is defined by an XML schema that we create. Actually, strictly speaking, we can create the schema from scratch or reference an existing one defined in XSD, as a .NET or as a web service.

The structure of the message we are waiting for is very simpe and looks like:

Ideally, I would have liked to use the WorkItemChangedEvent that is delivered directly from Team Foundation Server’s event notification system. But, the structure of that message makes it somewhat difficult to extract the information that I need from it. For now, I took the easy way out and defined my own message structure that I’ll hyrdate.

2 – Receiving the message

This is just a standard BizTalk Server thing – this receive is what activates our orchestration.

3 – Deciding if we are interested in this event

We’re not interested every time a work item changes; the Expression shape in BizTalk Server allows us to define an expression to find only the ones we’re interested. The expression behind this shape looks like:

The only changes we’re only interested in are the newly created work items, the ones that get closed, and the ones that are reactivated.

When we have a work item in any of those states, we’ll treat them differently based on the number of active work items that we have. The section of our orchestration below is what we use to count up our active work items.

1 – Counting Work Items

We have a web service that queries Team Foundation Server and returns the number of Work Items in the active state.

2 – Web Service Port

BizTalk Server setups up a request/response port for you automatically when you use a port from a web reference.

Once we have the number of active work items, we will combine that information along with the state of the work item.

If the work item is active (either because it is newly created, or because it’s state was set that way), and our Kanban is full, we will ‘punt’ the work item. A Kanban is full when there are no open slots or cards to represent the work. This enables us to control the amount of work the development team has to worry about.

We ‘punt’ a work item by calling another method on our web service port. What that web service does is change the state of our Work Item to ‘BackLog’. This is the end of the orchestration for this branch.

If the work item is closed and our Kanban has an empty slot, then we will notify our team of a free Kanban card.

This is the end of the orchestration for this branch as well.

So, what we have in our orchestration as a whole is the basic implementation of a Kanban system. To summarize, when a work item is created or re-activated, we check to see if we have any open kanban cards. If we do, that’s fine we don’t need to do anything. But if we don’t, then we will assign that work item to the backlog. Every time a work item is closed, we check to see if we have any open kanban cards. If we do, then we send a notification to our team to let them know that a card is open.

Those are the basics of the system – I’ll do a follow up post that delves into some of the details about how the ports are bound and show some examples of the orchestration actually executing.

Thanks!

Eric.

Quick post - 2 really cool features about Work Items

ericlee — Wed, 06 Sep 2006 06:50:00 GMT

I’ve just returned from Tech Ed Australia and New Zealand and I’ve got lots to blog about that.

But before I do that, 2 features about Work Items caught my eye tonight that I really wanted to share.

First, you can copy a single work item to another Team Project by simply right-clicking on it.

When you choose Create Copy of Work Item… you get a choice of what Team Project and Work Item Type you like to make the copy to.

Neat stuff! I am perpetually working on my tool for copying work items en mass, and in all honesty I had overlooked this feature before. Now I wonder if this is exposed in the API somewhere I don’t think it is, but maybe it is something we can do in the future.

Another neat feature is the way process guidance is integrated – let’s say that you’re wondering what the lifecycle of a given work item type is. For example, do bugs go from active to resolved to closed; or active to approved to resolved to close? If you’re ever wondering, just right-click on the work item and view the process template.

This will bring up the process template at exactly the place that is pertinent at the moment. One can easily view every related to this work item type in the guidance.

If you customize your process guidance, then you can be taken to information that pertinent to your organization as well.

Lately I’ve been trying to drill into the depths of work item tracking and these 2 tips caught my eye so I wanted to share. It never ceases to amaze me how dense of a product VSTS 1.0 is.

Anyways, hope you’re doing well, look for a Tech Ed wrap up post from me soon.

Thanks!

Eric.

You meet the nicest people on a Honda...

ericlee — Mon, 14 Aug 2006 05:54:00 GMT

When I moved to Seattle, one of the most enjoyable things I learned how to do was ride a motorcycle. I really enjoyed the open air, speed and thrill of riding.

Both of the bikes that I’ve owned – a Kawasaki Ninja 500 and a Ducati Monster 750 – were very reliable and never caused me any problems; a good thing, since I don’t have any mechanical skills to speak of.

The only thing I had to worry about was learning how to ride. And even that wasn’t very hard – in Washington State, there is a Motorcycle Safety Foundation class that is jointly sponsored by the state and several of the major motorcycle manufacturers – Honda, Kawasaki, Suzuki, etc. The class was just $50 and included 1/2 day of classes and 2 full days of riding.

Just about everything was provided for us. A few weeks before the class, everyone that was registered for the class received vouchers in the mail entitling us to 20% off helmets and gloves at most of the local motorcycle dealerships.

For those who didn’t buy their own gear, there was a reasonable selection of helmets and gloves to use onsite. We had brand-new, friendly, 250cc motorcycles to learn on as well. These bikes were provided by the various manufacturers that sponsor the course. Generally speaking, we had our choice of bikes that represented the major categories of motorcycles – cruisers, standards and dirt-bikes.

The last-half of the course was our endorsement test. Our instructors became our evaluators and one-by-one we did the test. My class had 30 or so people and everyone passed. Many, like myself, had had never ridden any motorized 2–wheelers in their lives before.

After 3 days, the market for motorcycles in Washington State grew by 30

At the time, I took the class a bit for granted. However, had I wanted to learn how to ride a motorcycle in the 1950’s or early 1960’s, things would have been very different.

‘You meet the nicest people in a Honda’ is a popular ad that Honda ran in the 1960’s to promote their new motorcycle, the ‘Super Cub’. This ad campaign and the motorcycle represented an important turning point in the motorcycle industry in the United States.

At the time, the perception around motorcycles in the United States wasn’t very positive. Generally speaking, motorcycle-ists were considered rebels, outlaws and members on the fringe of society. Also, maybe more importantly, the motorcycles at the time were not very attractive for the mainstream. Motorcycles of that era were heavy, difficult to ride and unreliable. You had to have a good understanding of the workings of a motorcycle to perform the near constant maintenance that the bikes of that day required.

Honda’s ‘Super Cub’ changed all of this. It was small, friendly-looking and easy to ride. And it’s engine was nearly maintenance free. The ad campaign that introduced this motorcycle focused on parents, young couples and professionals riding the ‘Super Cub’.

What Honda did was pretty impressive. They identified an appealing thing that a small, niche segment of the market was doing, and, more importantly, they identified what was keeping this niche thing from being popular in the mainstream United States. To name a few examples, motorcycles in the United States at the time:

suffered from a negative image
required its customers to have indepth mechnical knowledge
was thought to have little practical value

To mitigate these issues, Honda did 2 things. First, they built a great product - a fun, easy to ride, bullet-proof motorcycle that could accomodate 2 people easily; this helped increase the broad appeal of the motorcycle. Second, Honda built a friendly ad-campaign to start changing the negative perception of motorcycling in general.

The rest is history, the ‘Super Cub’ sold 200K units in its first year, more than all the other motorcycle manufacturers combined that year and went on to sell 50M units in its lifetime. The ‘Super Cub’ is largely remembered as being the motorcycle that brought motorcyling into the mainstream US market.

So what does this have to do with software? Or Application Lifecycle Management? Well, my hypothesis is that there is an opportunity to bring what customers who are very, very early adopters have been doing into the mainstream.

When we launched Visual Studio 2005 last year, we started talking about something called the Application Platform, which was the combination of BizTalk Server (BTS), Visual Studio and SQL Server.

My hypothesis is that the Application Platform represents what a few of our very early adopter customers have been doing for quite some time.

For example, BTS can do many things, but one of the things it does very well is provide a way to implement complex workflows and flow of data.

From a software development standpoint, BTS is pretty useful. There are lots and lots of complex human workflows that take place in software development – code reviews, buddy builds, check-in approvals are just a few examples. Why not take advantage of a graphical designer to literally orchstrate these instead of relying on word of mouth or documentation? SQL Server is pretty useful as well – I’ve gotten a lot of interest around building Key Performance Indicators from software development data as well as applying data mining to it. Whether you are doing either or both, the great thing about having a data warehouse for your software development is that you can use it in so many other places. Project Server, Business Scorecard Manager and Excel are all clients that can make very sophisticated use of a data warehouse.

If your organization happens to be using BTS and SQL Server for more traditional scenarios, you all of a sudden have a single place for to implement all of your processes – either business-related or software development-related, and you have a common format, a data warehouse, to represent all of your data – either business-related or software development-related.

My hunch is that some customers have been able to do this with BTS 2004, VS 2003 and SQL Server 2000 products, but it hasn’t been easy. There certainly are a lot of hurdles that prevent this type of solution from being accepted by the mainstream.

With the Application Platform bringing together SQL Server 2005, BTS 2006 and VS 2005, I think we are taking a step towards making a solution like this attractive for the mainstream.

For example, BTS 2006 has a bunch of new adapters, but 2 that are really interesting for software development are the email and sharepoint adapters. A BTS adapter allows BTS to accept messages from whatever is being ‘adapted’. With these 2 new adapters, BTS can treat email and sharepoint (SPS and WSS) documents as though they were XML documents and use them in BTS orchestrations. SOAP is another BTS adapter.

Since Team Foundation Server uses email or SOAP for its notifications and automatically creates a WSS sharepoint site for your projects, there is a natural way to integrate with BTS. Team Foundation Server doesn’t have a great workflow story right now, but BTS is all about complex workflows and orchestrations. It’s not hard to imagine a TFS event notification that activates a BTS orchestration which runs its course and reports its results by creating a new document on a Team Project’s portal. I’m sure there are tons and tons of other possiblities.

Another example in terms of making this solution more mainstream is the integration with the Visual Studio client – now without ever leaving the friendly confines of the Visual Studio shell, you can:

write C++ code
design a class in C#
design a multi-tier SOA application
kick off a load test
create a KPI to report your results
data mine to find interesting associations
design your business process

If you know the previous generation tools, then this integration maybe isn’t as important. But if you’re new to an Application Platform-style solution, then centering everything around the familiar – Visual Studio – can really ease the learning curve.

Anyways, just some thoughts on a Sunday evening. The more I dig into SQL Server 2005 and BizTalk Server 2006, the more excited I become about how to apply those technologies to software development. I don’t think we have a ‘Super Cub’ yet, but it’s getting there.

Thanks!

Eric.