Continuously Integrating

Interesting IntelliTrace Anecdotes

2012-01-06T09:37:00.000-08:00

Over the past few months I have had the opportunity to encounter some interesting anecdotes from customers that are using IntelliTrace as part of their development cycle with Visual Studio Ultimate. The ones that I want to highlight here have come to me as perceived flaws with IntelliTrace. Now don't get me wrong I'm not saying that the feature is flaw free but there are some interesting side effects of using IntelliTrace as part of your development cycle.

IntelliTrace is broken, it's recording way too many ADO.NET calls!
This was an interesting complaint that I got a while back. A developer was working on an application and looked at the recorded ADO.NET events that we had on the IntelliTrace list and noticed that there were four events listed for the exact same database call. This was not good! We took a look at the problem and it turned out that the path through the application was actually executing the same database call four times. Naturally IntelliTrace recorded each call. This was a great example of how IntelliTrace can be used in a static analysis manner on top of runtime data. We were able to identify a great opportunity to optimize the code and reduce the extra database calls from the code path and make the application faster.

When I turn IntelliTrace on High (IntelliTrace Events and Call Information) it's too slow!
Well this can easily be very true and unfortunately it's one of those things that really depends on a few variables. Let me explain. When IntelliTrace is turned on high all of the modules (aka assemblies) are instrumented when you start debugging. This means that we add extra code to record a certain degree of data for all of the parameters and return values for every single method call in all modules that are not in the inclusion/exclusion list. Running against the RAWR application using the default IntelliTrace high settings can be a painful experience, however once you have clicked two buttons and patiently waited for the action to complete if you analyze the IntelliTrace data you might find that at least one method was call about 1,250,000 times! This was occurred when simply clicking two buttons after starting the application! Of course things are slow when we record data for 1.2 million method calls. This is another great indication that there are some optimization that can be made in the code. IntelliTrace runs slow when it's recording a lot of data. Take this as a clue to analyze what's going on to seek out opportunities to improve your application.

One of the optimization that was taken early was to turn off certain IntelliTrace events by default. We did this to improve performance. During early testing we encountered an application that was running very slowly with IntelliTrace due to a huge number of registry access calls that it was performing. With the registry events turned on data was being collected for each access and it caused poor performance. What it also did was highlight a tight loop within the code that was accessing the registry far more than was necessary. By moving the call to the same registry out of the loop improved both IntelliTrace performance as well as the application performance.

The default settings for IntelliTrace is to exclude certain modules when running on high mode. A more optimized approach is to use an inclusion list rather than an exclusion list for the modules. By switching the Modules setting to "Collect data from only the following modules" and then providing strings to match only the modules that you care about will improve performance as well. Otherwise any modules that don't match the exclusion list will be included, this would include all third party modules that you may not care about.

When my boss saw the IntelliTrace log he made me change my code!
Using an IntelliTrace run as part of a code review is a great way to get some insight into what's going on from a high level. Reviewing exceptions that were caught within the user developed code showed a high number of catches that weren't being recorded or rethrown. Essentially there were exceptions being caught and swallowed. This is always a danger. If an exception is thrown and caught but not logged there can easily be bugs in your code that can be very hard to track down. Reviewing the exceptions data can help you develop more robust applications.

Conclusions
These are a few examples of anecdotes that I have encountered over the past few months that have shown some of the additional value that IntelliTrace adds to the development cycle in addition to the ability to historical debugging. I hope you find these ideas valuable and can share a few of your own.

IntelliTrace In Production with VS11 CTP

2011-09-15T07:56:00.000-07:00

Ok, so you've got your hands on the CTP of Visual Studio 11 that was released at the //build conference. Cool. Have fun with that, there's a ton to play around with! More info here.

So where do you get the IntelliTrace cab file that was shown for the "IntelliTrace in Production" scenario? Well, it's not exactly the most obvious but you can track it down in the following location once you've installed Visual Studio Ultimate CTP (note that this location is likely to change with upcoming releases). C:\Program Files (x86)\Microsoft Visual Studio 11.0\Team Tools\TraceDebugger Tools

Once you have the IntelliTraceCollection.cab file you can take it to any other machine to leverage the IntelliTrace collection against IIS application pools without anything else! No Visual Studio installation is required.

To extract the files in the cab be sure to use the expand command from the command line and don't just open the cab and extract the files. The extract command from the command line maintains the file structure while using the extract command from Windows Explorer does not. This is very important!

e.g. "expand /f:* IntelliTraceCollection.cab c:\IntelliTrace" This will extract the files into a folder named IntelliTrace on the c: drive of the local computer.

Once you have the files extracted you are good to go with the PowerShell import and start collecting IntelliTrace against an application pool.

Note that you need to run your PowerShell as Administrator due to the stopping and starting of the application pool that is performed when the IntelliTrace profiler is started and stopped. Once you have PowerShell running you add the IntelliTrace bits by running
Import-Module \Microsoft.VisualStudio.IntelliTrace.PowerShell.dll

Once that succeeds you can validate the import by executing "Get-Help IntelliTrace" in your PowerShell window to see the commands that are available. Use Get-Help on any of the commands provided to get details on the usage. Also watch Mark Groves and Tracey Trewin's Thursday afternoon session at //build to see advanced usage.

I would love to hear your responses and experiences with this feature. More blog posts and official documentation will be forth coming. Send me feedback at my Microsoft email address which is larrygug.

Examining IntelliTrace Events

2011-07-08T14:26:00.000-07:00

This post dives into IntelliTrace Events as available in Visual Studio 2010 Ultimate edition, explaining what they are, how they work and the benefits to be had.

The typical “F5” usage pattern of IntelliTrace goes something like this:

- Press F5 while in Visual Studio to initiate a debug run

- Record an IntelliTrace session of your application during execution

- Use the recorded information to enable replay of the execution

- Analyze the data to determine what happened

Let’s take a look at some really useful analysis that can be done with IntelliTrace event information.

The examples in this post will assume the default settings for IntelliTrace that configure the feature to only record selected “IntelliTrace events”.

The events that are captured are found under the IntelliTrace Events section.

You can think of these events like log entries that are handled for you without adding anything to your code at design time. You can turn on or off event collection by category or by individual events within a category. The only event type that you do not have control over are Exceptions. Regardless of any other events that may be selected IntelliTrace will always capture Exceptions thrown and caught when IntelliTrace is enabled.

What can be prove to be an interesting exercise is to take a look at the events list that IntelliTrace captures during a run of your application. Do this by checking that IntelliTrace collection is enabled as shown in the first screenshot and then run your application in Visual Studio in debug mode. Walk through a usage scenario or two in your application. Before exiting your application return to Visual Studio and select the “Break All” link in the IntelliTrace window.

If you don’t see the IntelliTrace window, open it by going to Debug -> IntelliTrace -> IntelliTrace Events from the Visual Studio menu or by pressing Ctrl+D, V. What you see next depends on what events IntelliTrace collected during the execution of your application. You may see anything from a very short list to a very long list. The events are listed in the chronological order in which they occurred with the first event at the top and the last event at the bottom of the list.

Reviewing the events list can provide insightful information about the behavior of your application, the structure of the code, various IO performed and many other things. Take a look at the following events list as taken from a quick usage of the StockTrader sample WCF application:

By reviewing this events list you can determine which database calls were made, what requests were made to the web server, what exceptions were thrown and caught and any breakpoints that were hit. Analyzing this information can be very beneficial as part of a code review as well as provide understanding of execution paths and opportunities for improvement in addition to finding and resolving bugs.

Click any of the events in the list to get further information. For example, clicking on the first exception may do a couple of things.

- it expands the event to provide more information inline as shown below.

- If you have the solution open in Visual Studio that contains the point where the exception was thrown it will take you to the code

- Your application execution is “rewound” to the point where the exception was thrown for further analysis

At this point you can review the call stack by clicking the “Call Stack” link, which will open the call stack window.

Expanding one of the ADO.NET events in the list provides both the query that was executed as well as the connection string that was used.

This can be especially valuable when trying to track down connection permissions issues or query problems. A huge benefit that many people have discovered is when you are using data access technologies like Entity Framework or Linq to SQL as this event will show you the SQL statement that was generated and executed based on your LINQ statements. Very handy!

People are often surprised when they examine the ADO.NET statements in the list of events. Frequently it is discovered that there are far more database calls being made than expected. The events list can also present duplicate calls that are executed. This can be a great opportunity to investigate caching strategies.

So how is this event collection done?

Each event in the events list is associated with some method in the .NET framework. When you execute your application within Visual Studio these methods have additional code injected that writes the data that you see in the events list to an IntelliTrace log. The impact to execution is completely dependent on how often the methods that have the additional instrumentation are executed. If you find that IntelliTrace is slowing down the execution of your application and you have only events collection enabled (see the first screenshot) take a look at the events list, you may discover that one or more events are being recorded many times. This may indicate redundant execution within a loop perhaps. For example if you have a loop that executes 1000 times and, unknowingly, each iteration performs a database query or a registry lookup you will find that IntelliTrace collection of that many events will impact performance. The benefit of all of this is that you will have discovered a great opportunity to refine your code and reduce potentially redundant code execution!

Hopefully you will see how IntelliTrace events alone can provide great value to your development cycle. There is a lot of valuable information to be mined from them. Take a look at the events that are available and turn on the ones that your code would encounter during execution. Take some time to examine how your code works and maybe you will find opportunities for improvement as well as fix your bugs faster.

I am always eager to hear about your experiences using IntelliTrace!

Visual Studio 2010 and .NET Framework 4 Training Kit

2011-07-01T09:28:00.000-07:00

The guys over in Developer and Platform Evangelism have release an update to the Visual Studio 2010 and .NET Framework 4 Training Kit. Full of lots of great training and best of all it's free.

Check out the kit here: http://bit.ly/auOAzR.

From the download page:

Overview
The Visual Studio 2010 and .NET Framework 4 Training Kit includes presentations, hands-on labs, and demos. This content is designed to help you learn how to utilize the Visual Studio 2010 features and a variety of framework technologies including:

C# 4
Visual Basic 10
F#
Parallel Extensions
Windows Communication Foundation
Windows Workflow
Windows Presentation Foundation
Silverlight 4
ASP.NET 4
Windows 7
Entity Framework
ADO.NET Data Services
Managed Extensibility Framework
Application Lifecycle Management
Windows Azure

This version of the Training Kit works with Visual Studio 2010 and .NET Framework 4.

Visual Studio ALM vNext Preview

2011-05-17T08:41:00.000-07:00

Cameron Skinner and Brian Keller demonstrated some of the new ALM features that the Visual Studio Ultimate team is working on at TechEd yesterday. Check out the out the video here: http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/FDN03

As the PM for IntelliTrace I am always interested in any feedback. There were some great questions at the end of the session. Do you have any others that you would like to share?

Windows 7 SP1, IIS and IntelliTrace

2011-05-03T15:12:00.000-07:00

Are you getting the following message when you really shouldn’t?

Begin Message:
IntelliTrace is not collecting data for this debugging session.

The project type may not be supported or the process you are debugging may have been either attached to or launched with IntelliTrace disabled. Restarting the debugging session within Visual Studio may solve this. Please note that IntelliTrace is not supported when attaching to a process that is already running.

If you have selected a custom location for IntelliTrace recordings, please make sure it is writable by the process being debugged.
End Message

Did IntelliTrace high (the setting that includes events and call information) used to work correctly and now it doesn’t? Are you debugging a web application on Windows 7 sp1 under IIS? Then this may be the solution for you.

Go to the your Windows installation location (typically C:\Windows) and drill down into System32\inetsrv\config open the applicationHost.config file. Find the following section

Within this section you should see all of the application pools that are defined for your IIS instance. In my default installation of Windows 7 SP1 with Visual Studio 2010 I have the following:

applicationPoolDefaults>

applicationPools>

The culprit is the setProfileEnvironment attribute on the processModel element. The proccessModel can be configured for any individual application pool. That is what you need to do by adding it to the specific pool that your application uses. You then need to set the setProfileEnvironment to “true”. Once that has been changed the environment variables that IntelliTrace relies on will not only be configured but will also be loaded by the application pool on execution. To get mine to work I changed it to look like this:

add>

applicationPoolDefaults>

applicationPools>

Once you have made that change reboot IIS. I like to use iisreset at the command line. After that you should be good to go and have the full event and call information available by using IntelliTrace.

Extra Info

So now the question is what’s up with setProfileEnvironment? This is a new attribute that was introduced to Windows 7 in Service Pack 1. As it turns out there are some applications that rely on certain environment variables to have certain values. For example, the value of the %TEMP% environment variable will change depending on if the default system environment variables are loaded or a specific user profile environment variables are loaded. In some cases %TEMP% may point to a location under the Windows directory and in other cases it may be under the user profile location (e.g. %userprofile%\AppData\Local\Temp). For IIS this is all dependent on the identity under which the application pool is configured (Network Service vs. custom identity).

In some situations that arise when using ASP Classic (yes, that’s ASP 3.0) coupled with an Access database (I remember well those days) having the %TEMP% location reside under the user profile causes things to break. So, the new attribute was introduced that will prevent the environment variables for the profile associated with the application pool account to load if setProfileEnvironment is set to “false”. This is the default configuration.

So, don’t try and use the same application pool, with a custom identity, for both an ASP classic application that leverages an Access database along with a .NET application in which you want to collect IntelliTrace logs. That’s not asking too much is it? J

IntelliTrace is All Mine!!

2011-04-14T21:06:00.000-07:00

Yes, you read me right, IntelliTrace™ is All Mine. And by "All Mine" I mean that me and an extremely talented and skilled group of people at Microsoft comprise the team that makes the magic that is IntelliTrace™ happen. I also mean that it is "All Mine" in the sense that my boss told me that if IntelliTrace fails he will hold me personally responsible. No pressure. :-)

Ok, let me expand on that a bit. I am the new Program Manager for the IntelliTrace™ feature that is delivered as part of Visual Studio 2010 Ultimate. I have the primary responsibility of working with the team to determine the direction that the product will take so that we can deliver the most valuable feature that we can. What does that mean? Well, really it means that I want IntelliTrace™ to be everything that you want it to be. I personally believe that Intellitrace™ is an extremely cool feature that, from my experience, is underutilized. For an introduction to the feature check out my blog post from a while back.
Since writing that post and the final release of Visual Studio 2010 I have been keeping a bit of an eye on how many people that have the Ultimate SKU either use or even know about IntelliTrace™. Surprisingly few.
So here are a few asks of you.

If you use Visual Studio 2010 Ultimate but don't know what IntelliTrace™ is let me know.
If you use Visual Studio 2010 Ultimate and know what IntelliTrace™ is but don't use it, tell me why not.
If you use Visual Studio 2010 and use IntelliTrace™ give me your feedback.

Comments to the blog are great or you can email me. My email is larrygug at well, you guess the rest... ;-)

It's been a while

2011-03-25T16:23:00.000-07:00

Ok, so it's been well over a year since my last post. It's been a busy time! Things are about to change significantly. I just left a position with Providence Health and Services in Portland and am moving to Redmond to work for Microsoft starting on Monday, March 28th.

I will be joining the Visual Studio Ultimate team as a Program Manager. This is certainly a big move in my career and I am really looking forward to it.

How much I will be able to blog about remains to be seen but I will try and share what I can when I can.

Stay tuned.

Microsoft Rangers Projects

2010-01-23T07:13:00.000-08:00

When I start talking to people about the Rangers project that I was working on last night or over the weekend I get a lot of blank looks. "You know the Microsoft Rangers". More blank looks. OK so maybe they're not as widely known to everyone as they are to me. The words on their home page state it well.

"Team System Rangers deliver out of band solutions for missing features and guidance in the Team System suite of products."

The Rangers themselves are Microsoft employees that are dedicated to working on these out of band solutions. The Rangers also leverage MVP members to contribute to these projects as well. That's were I come in.

Currently I am working on two upcoming projects that I am very excited about. Visual Studio Database Guidance and Visual Studio Architect Guidance.

I have felt that the database projects that are commonly known as the "Data Dude" pieces have been vastly under utilized by the development community. There are some really amazing tools there that will change the way you develop database solutions. I've been huge proponent of them since they were first delivered and I'm exceptionally pleased to be part of crafting this guidance.

The other project is also quite dear to me as I have been working quite closely with the team up in Redmond that has been building the Architect tools for quite some time. It has been very cool watching these tools evolve over the past many months. This guidance will be very relevant as the architecture tools the are being delivered with Visual Studio 2010 are all brand spanking shiny new.

So, that's what's been keeping me amused besides the ton of work that's involved when starting a new job as a a Software Engineering Manager for Sage Software. Phew....

Visual Studio 2010 TFS Upgrade Guide

2010-01-23T07:03:00.000-08:00

Visual Studio 2010 Team Foundation Server is no small change from 2008. It's big, really big. The team back at Microsoft really took to heart the feedback from the users and community and incorporated some great new features and capabilities. Of course, this means that a lot of stuff under the covers had to change. Which means that moving from 2008 to 2010 isn't necessarily an extremely straight forward experience, especially if you want to use some of those cool new features in your existing projects.

Enter the Guidance. This is yet another Microsoft Rangers project that was recently delivered to Codeplex here. Great work guys!

Visual Studio 2010 TFS Upgrade Guide
Welcome to the Team Foundation Server (TFS) 2010 Upgrade Guide. This guide covers scenarios which may be encountered during and after the upgrade process. It provides examples of most common and potential issues. It covers scenarios related to general Upgrade Process, Work Item Templates, Reports, and Enterprise TFS Management (ETM). Although this guide refers to TFS 2008 scenarios, almost all the concepts apply also to TFS 2005.

Visual Studio ALM Rangers
This guidance is created by the Rangers who have the mission to provide out of band solutions for missing features or guidance. This content was created with support from Microsoft Product Group, Microsoft Most Valued Professionals (MVPs) and technical specialists from technology communities around the globe, giving you a real-world view from the field, where the technology has been tested and used.

What is in the package?
A single document with the following contents:
1 Introduction
2 Upgrade Process
3 Scenarios
3.1 Upgrading Projects from Multiple TFS 2008 servers into one TFS 2010 server
3.2 Upgrading severs when SQL Mirroring is enabled
3.3 Recovering system if upgrade fails midway
3.4 Updating Team Project Portal for an existing Team project
3.5 Splitting Team Project Collection into Multiple Collections
3.6 When I move a Team Project Collection, how do I move the reports?
3.7 Bringing Workgroup Machine inside Domain
4 Frequently Asked Questions
4.1 Can I use a TFS2008 Process Template to create team projects in TFS 2010
4.2 How can I enable Agile Workbooks in upgraded Projects
4.2.1 Enabling the Product Backlog Workbook
4.2.2 Enabling the Iteration Backlog Workbook
4.3 How can I enable Test Case Management in upgraded project
4.4 How can I enable Branch Visualization in upgrade projects
4.5 How can I enable Lab Management in upgrade projects
4.6 What is WIT Admin Tool
4.7 What happens to my custom reports created in TFS2008 post upgrade?
4.8 Will my old TFS2008 reports work post upgrade?
4.9 Can I add a new Database to my existing TFS 2010 farm?
4.10 Error bringing cloned Team Project Collection online
4.11 Move Team Project Collection Database from one Database server to another Database Server
4.12 How to enable the TFS reports if the WSS server is upgraded to MOSS server?
4.13 How to Move Team Projects from one Team Project Collection to another
5 References

Team
Pramod Vasanth, Bijan javidi, Willy-Peter Schaub, Anthony Borton, Neno Loje, Bryan Krieger, Aaron Bjork, Mario Rodriguez

Visual Studio 2010 Team Foundation Server Requirements Management Guidance

2010-01-16T14:48:00.000-08:00

It has been a long time coming but on Thursday January 14, 2010 the "Visual Studio 2010 Team Foundation Server Requirements Management Guidance" was finally released. You can get this set of documents from codeplex here!

It is always exciting to see a project that you have been involved with come to a conclusion and see the light of day. I encourage everyone to take a look at the guidance. Bijan, Willy and Mike worked very hard on this along with me and several other Microsoft Rangers and MVPs. Here is the blurb from the codeplex site:

"This Ranger solution addresses the People, Process, and Technology guidance for Requirements Engineering (RE) using Team Foundation Server. The goal of this guidance is to provide formalized Microsoft field experience in the form of recommended procedures and processes, Visual Studio Team System and Team Foundation Server configurations, and skill development references for the Requirements Engineering discipline of your application lifecycle."

As one of the contributors to this project I am excited to hear any feedback that you may have and I hope that you find it helpful.

Database Already Exists Error Visual Studio

2009-12-04T09:22:00.000-08:00

I would like to thank Barclay Hill for passing this along:

I have imported a database into a project and when I try to deploy it back to the server as a new database it fails saying the database already exists even though I have changed the name. What am I doing wrong?

You are running into this issue because you are deploying to a server that has the previous version of the database and the names of the data and log files are clashing. The error you are getting is a duplicate file error. Most likely like this:

Cannot create file 'C:\Program Files\Microsoft SQL Server\MSSQL10.SQL2008\MSSQL\DATA\northwnd.mdf' because it already exists. Change the file path or the file name, and retry the operation.

To resolve this you simply update the files so that they will not clash.

Update the data file. This will be in your project under Schema Objects->Database Level Objects->Storage->Files

In the .sqlfile.sql update it to something like this:

ALTER DATABASE [$(DatabaseName)]
ADD FILE (NAME = [Northwind], FILENAME = '$(DefaultDataPath)$(DatabaseName).mdf', SIZE = 3328 KB, MAXSIZE = UNLIMITED, FILEGROWTH = 1024 KB) TO FILEGROUP [PRIMARY];

In the _log.sqlfile.sql update it to something like this:

ALTER DATABASE [$(DatabaseName)]
ADD LOG FILE (NAME = [Northwind_log], FILENAME = '$(DefaultDataPath)$(DatabaseName).ldf', SIZE = 1024 KB, MAXSIZE = 2097152 MB, FILEGROWTH = 10 %);

How is your VS 2010 Experience?

2009-11-01T06:21:00.001-08:00

The team back in Redmond is really interested in hearing your feedback on any experiences you are willing to share about Visual Studio 2010 Beta 2. To facilitate this they have created a survey that you can access here.

For more information refer to Jeff Beehler's blog posting.

Documentation Problem VSTS 2010 Beta 2

2009-10-25T10:02:00.000-07:00

During the install of Visual Studio 2010 Beta I ran into a problem when I tried to install the documentation. This would be the big blue button that comes after the product has completed installing. I didn't grab a screenshot but if you've installed the product you should know what I'm talking about. When I tried to install the documentation I received an error complaining about not being able to find the files despite them being exactly where I said they were. Harumph.

So after this I tried to correct the problem by selecting the "Manage Help Settings" from the "Help" menu in Visual Studio. I got the following error:

After clicking the "OK" button the "Help Library Manager" opened with only the top menu option available to me.

Clicking the "Choose Online or Local Help" option took me to the following screen which didn't really help me out at all. Neither option made any difference.

I was fortunate enough to have some other help available in the form of a Microsoft Help engineer that showed me a nice little addition. If you browse to C:\Program Files (x86)\Microsoft Help\v3.0 you should see a file named HelpLibManager.exe.config. This is the configuration file for the help manager. Open this configuration file and check the "FirstTimeRun" setting. If it's False change it to True and then run the HelpLibManager.exe found in the dame directory.

With the change in setting when I ran the HelpLibManager this time I got the fully enabled menu selection and was able select the "Find content on disk" option, point it to my installation file location and it ran to completion.

I now have the full help enabled in my shiny new Visual Studio 2010 Beta 2. It is a work of art!

Wireless Network on Windows Server 2008 R2

2009-10-24T07:11:00.000-07:00

Problems getting Wireless adapters working on Windows Server 2008 R2? Here's my story that might help.

This past week I was staying with my friends the Sterlings in Redmond WA while attending the

Development Tools Ecosystem Summit. After checking into Hotel Sterling I opened my laptop to install Visual Studio 2010 B2, which is AWESOME, and Chuck asked my why I was using Server 2008 and not Server 2008 R2! Good grief I am behind the times. Sheesh!

So that became another of my tasks while I was there. I downloaded the media for R2 and proceeded to install R2 on a new partition so that I could dual boot into my old OS as well as the new one. The installation went very well and we were eventually faced with an installed and mostly operative laptop (Lenovo W500) but I didn't have any wireless access.

These days, when not in the office, I work almost exclusively off of a wireless connection. At home I'm on a wireless network exclusively and at the conference and the Sterlings I was also on a wireless network. It's just the way things are now. So when I didn't have the right drivers for my wireless card that was priority number 1! Chuck was on the Lenovo/IBM site immediately and pulled down the driver for me and we installed it. Reboot. No Wireless. Hmmm, it shows up correctly when looking at the adapters but there wasn't any options to select any wireless connections.

So we tried a different driver. Same thing. Both drivers we tried identified the adapter exactly the same. We booted back into my other OS to check the settings and it was exactly the same. What's going on here? This went on for some time until I eventually called it a night.

The next day, always sleep on these things, it will help, Chuck came to me and asked if I had added the wireless service to my laptop. Wireless service? What I had been missing this entire time was the Wireless Lan Feature on my install! D'oh!

Once that was installed all was as it should be.

Visual Studio 2010 Beta 2

2009-10-20T12:47:00.000-07:00

Yesterday the Beta 2 of Visual Studio 2010 was made available to MSDN subscribers and tomorrow (October 21) it will be available to the world. Read the details on Soma's blog here.

I have been poking at it a wee bit over the past day and a half as I hang out at the Development Tools Summit, I was even brave enough to run my presentation demonstrations on it. And I must say this is a very sweet release! I can't get over how incredibly fast it runs. Beta 2 of VS 2010 runs faster in a virtual machine hosted on my laptop than VS 2008 runs directly on my laptop!

I ran into Rico Mariani at the conference and had to congratulate him on the amazing performance improvements in the platform. During his keynote he talked about his pleasure with the performance improvements that they've made and now they need to get the memory consumption under control for RTM. If the improvements that they've made in performance from Beta 1 to Beta 2 are any indication of what they can achieve I can hardly wait to see the final product. It should be a real zippy environment.

Congratulations to the entire Developer Division at Microsoft on this great release!

Development Tools Extensibility Summit Presentation

2009-10-20T11:31:00.000-07:00

I would like to thank everyone that came to my talk today on Team Architect Extensibility at the Development Tools Extensibility Summit in Redmond.

Despite some wacky display problems off the start, "I've never seen 4 displays listed on a laptop before" said the tech support... things went well and the demo's came off as I had hoped.

I have copied the sample project and code to my skydrive and you can download it here.

Visual Source Safe RIP

2009-10-06T03:05:00.000-07:00

Despite the fact that the end-of-life date (mid 2011) for Visual Source Safe (VSS) has been looming for a while now it has been hard to know where to go from there. Team foundation Server is a seriously robust source control system but is a bit of a leap from VSS in terms of both functionality and cost.

Well today the wait for the replacement is over! Microsoft has announced the replacement product, Team Foundation Server 2010 Basic. The announcement was to be made at VSLive keynote but Brian Harry leaked the news a bit early on his blog. Brian has some great details in his post as well as a nice history of VSS leading up to the TFS Basic announcement. With this announcement I believe it is much easier to bid farewell to VSS, for better or worse.

Rather than repeat the details here I would suggest you head over to Brian's blog for the nitty gritty. However some of the highlights are:

1. Price has not yet been announced
2. It runs on Vista and Windows 7, not just the Server OSs
3. The installation is a huge improvement over prior TFS installations.

Check out Brian's post for screenshots of the installation process.

Empty Create Unit Test Window

2009-09-25T20:42:00.000-07:00

Today a couple of the members of my team ran afoul of the "empty unit test window" problem that I had encountered a while back. there is a bug fix available here: http://support.microsoft.com/kb/962866 but I want to add something interesting to the story.

Just to clarify the problem manifests itself when you right click a method and select "Create Unit Tests...". The "Create Unit Tests" window opens with the content pane completely empty. I can't attest to which versions this all applies to but we are using VSTS 2008 SP1 with GDR 2 running on Windows 7 and Windows 2008.

When one of my team members came to me with this problem I had completely forgotten that I had encountered it myself and had previously found this hotfix and applied it to my system. Brilliant! So we proceeded to try a few things to get it working.

First we rebuilt the solution after performing a clean. No dice.

Next we had the developer exhibiting the problem shelve his code so that I could pull it down to my machine in case there was something funky in the changes he had just made. Nope. Worked fine on my machine! :-)

Next I asked him to clear his profile as I have seen a few problems resolved by doing that. Instead he simply logged onto his dev box with a different identity to try it out. Problem solved! OK it seems to be a profile thing we determine.

Well, not so fast. Of course, this other identity that we was working on had a feature enabled in Windows that he didn't like so he turned off User Access Control. Rebooted and, yes you guessed it, the "Create Unit Tests" window was empty again! To validate this behaviour we turned UAC back on and tried it again. "Create Unit Tests" window is populated!

Crazy times!

In the meantime I remembered the fix, we downloaded the patch and all is well in UAC deficient unit testing land.

Speaking at the Development Tools Ecosystem Summit

2009-09-25T20:35:00.000-07:00

I am very pleased and excited to announce that a session proposal that I submit ed to the Development Tools Ecosystem Summit in Redmond in October has been accepted! I will have the great honour of presenting at this very focused conference along with many of the Microsoft product team and Microsoft ISV partners.

I will be presenting on the extensibility features in the upcoming release of Visual Studio Team System Architecture. I have had the great pleasure of working closely with members of the Team Arch product group in the recent past and I hope that I am able to bring some degree of coolness of the extensibility features in this product to the attendees. There are a lot of very exciting things happening around the upcoming release of Visual Studio 2010 and I am very happy to be a part of it.

See you in Redmond in October!

Microsoft Development Tools Ecosystem Summit

2009-09-11T07:40:00.000-07:00

How's that for a title of a conference? Microsoft recently announced the 2009 event with the details on the Visual Studio Extensibility site here: http://msdn.microsoft.com/en-us/vsx/default.aspx.

I was at the last one and if you're into building plug-ins or extensions to Visual Studio then this is the must attend event. There is great information to be had in a small conference format, I believe there were about 400 attendees last year. There is great access to the product team members and the Microsoft campus in Redmond is always a beautiful place to hang out for a few days.

I will definitely be there! More about that later.

Historical Debugging in VSTS 2010

2009-07-19T20:37:00.000-07:00

One more of the very cool features that is coming with Visual Studio Team System 2010 is Historical Debugging. This is just one of those things that makes me go WOW! What this gets us is the ability to debug code that has already run. Perhaps it was even run by a tester. On another computer!

There are a few things that take a bit of poking at to get the hang of but once you learn the twists and turns of where to configure everything the technology does work exceptionally well. And this is on Beta 1!!!

The settings for the historical debugger are found within the Visual Studio options off of the Tools –> options menu selection. Scroll down until you see the root level Historical Debugging menu as shown in the screenshot below. Most of the options are reasonably straight forward. On the General settings tab is the option to enable or disable Historical Debugging as well as the option of how much information to track. The default settings enable Historical Debugging and track events only. To really see the power of Historical Debugging select the Events, Methods and Parameters option.

To test these features I have created a simple sample application using a single project that compiles to one assembly, however this process works just as well with larger applications that consist of multiple assemblies. Once you have set the options to meet your needs run your application. To demonstrate some of the interesting aspects my application creates a simple data transfer object in the UI class that is populated from user supplied data, passes the object to a controller class that then passes the object to a validation method on another class and based on the validation results passes the object to a data access layer for persistence. Not an uncommon scenario in a simple business application.

Running my application I enter and submit data however after I click the Save button all of the input textboxes are cleared. The application should have populated the fields with the values of the object after saving but instead a null reference exception is thrown and caught by Visual Studio.

The screenshot shows Visual Studio after it has caught the breakpoint. The Debug History window is displayed. The default view shows the significant events that the historical debugger has tracked ending with the Exception event that was thrown, the break that the debugger implemented and finally the option to return to the live debugging session. To view the details of the methods and parameters rather than just the events click the icon second from the left on the debugging window toolbar (Show Tree View).

A couple of things to note is the view of the call stack in the Historical Debugging window. The last entry in the window shows that the Person parameter that was passed to the DisplayPerson method was null. On the code editor window you can see the navigation gutter that displays the VCR style controls for navigating back through the code. Using the navigation controls we can navigate up the call stack to the point where we call the Controller.SavePerson method. From here we can step into the SavePerson method and inspect that values of the properties of the Person object that was supplied to the method. We can use the navigation icons in the gutter or the typical debug step commands (step into, step over, etc) to navigate about our code to determine what the problem is and where it occurred, all without restarting our application. There is no need to set breakpoints within the application to start a fresh debug session to find where the problem is, the Historical Debugger takes care of everything for us as we ran through the application the first time.

This is a great time saver that will make debugging problems much faster and easier. In my next post I will demonstrate how to leverage the new testing tools to capture historical debug logs that can then be passed from a tester to a developer to determine exactly what values were supplied by the tester as well as the exact path that they took through the code.

[Update: Oct 20, 2009: Historical Debugging has been renamed Intellitrace]

Detailing Use Cases (part 5 of 5)

2009-07-18T10:17:00.001-07:00

In this final post in my VSTS 2010 Use Cases series I have a few parting words about use cases and what this process is meant to achieve. I hope you have enjoyed these posts and find some value in them.

User stories provide a concise and agile means for understanding the high level desires of the user community. Expanding user stories into use cases and actors provides a means for examining the user stories from another perspective. Increasing the perspectives of observation will generally bring greater understanding to a problem space. By expanding the user stories it becomes easier to combine and re-arrange them into manners that add meaning to other actors than initially defined as well as see how use cases can relate to each other. The approach of combining user stories and use case modeling enables a robust and wide view of the system functionality. However it is rarely sufficient.

Each use case defined within the model should also include a text based use case. The recognized standard use case has been defined by Alistair Cockburn (Cockburn, 2001). The document form of a use case expands upon an individual UML use case by detailing the steps that are exchanged between the system and the user as well as alternate steps and exception cases as well as pre-conditions and post-conditions. A use case template should be established using MS Word and used to provide consistency. Each individual use case in the model should have a matching document which is stored in the SharePoint Portal site of the TFS project. Use case documents provide a depth view of an individual use case. Of course, expanding UML use cases and their corresponding user stories into use case documents does not need to happen completely up front prior to any development effort. In an agile approach the use case document is often the result of the conversation with the user about the user story.

For each use case document you may choose to create an artifact entity on a diagram and provide the path to the document in the SharePoint site. Since artifacts appear in the UML Model Explorer they become an integral part of the model and provide instant traceability between the model and the document. In addition to adding a reference to the use case document as an Artifact element in the model a hyperlink should also be created in the user story work item by adding a hyperlink in the links tab to the same SharePoint location.

So What Does This Get Us?

It may seem as though we are duplicating effort and information by creating use case diagrams and user stories since they both capture the same information. Creating use cases using UML Diagrams provides a very quick and easy way to view the functionality of the system in a visual manner. These diagrams can be printed and posted or copied into other documents for ease of reference. UML Diagrams are a concise format for conveying a significant amount of information as well as providing a means of relating user stories together to see how they relate. Diagrams can be created that reuse use cases that are displayed on other diagrams to provide distinct perspectives of the system under development. For example, creating a diagram that focuses on a specific actor provides users that fulfill that role a view of the system as it is relevant to them whereas a diagram that focuses on functionality as it spans multiple actors can provide a view into gaps in a process or missing steps.

Having the model tied to the user stories incorporates a link to an increased detail level that also provides links and traceability to the work that is performed to deliver the requested functionality. Since the user stories are Team Foundation Server work items they have all of the capabilities and integration that make work items such a powerful means for tracking, monitoring and managing a project while still providing a tie to the model and diagrams.

The benefits of tying these types of things (UML Model elements and work items) together is at the core of the integrated lifecycle tooling provided by Visual Studio Team System bringing traceability, flexibility and integration in a cohesive and powerful product.

Bibliography

Cockburn, A. (2001). Writing Effective Use Cases. Addison-Wesley.

Expanding on Use Cases and User Stories (part 4 of 5)

2009-07-16T08:49:00.001-07:00

As the development team begins to investigate the user stories they have conversations with the business users uncovering more details about how the system is expected to work. As the conversations uncover details the user stories expand and often result in new stories being created that help divide the initial story into more manageable pieces of work. These expanded user stories result in more use cases as well. Dependencies begin to evolve as more and more of the system needs are understood. For example the use case “Look up Order” when used by a “Call Center Worker” requires that the “Call Center Worker” has previously performed the “Lookup Customer Data” use case. As conversations are had about the “Lookup Customer Data” user story it may be determined that the initial user story can be broken down into the following two stories:

Search for Customer
Retrieve Single Customer Data (formerly Lookup Customer Data)

Once the Call Center Worker has performed the search they are able to retrieve the single customer’s specific data. There is a dependency between the two user stories. In addition to this relationship the “Retrieve Single Customer Data” may be intended to retrieve information about the customer’s contacts and primary address information as well as a list of the orders that they have currently active. This can create a relationship between “Retrieve Single Customer Data” and “Look up Order”. Understanding these relationships between user stories can be difficult. When user stories are created using index cards defining relationships between them is a challenge, especially as the relationships become more complex. Using Team Foundation Server work items the relationships can be managed using work item links but this is not ideal as the work item links are not displayed in a convenient graphical format for navigating that type of information. If you are mapping your user stories to sue cases using the UML Model Explorer creating and defining these relationships becomes very easy as this is one of the purposes of the UML. Let’s look at a more complex diagram and dissect the parts to fully understand both the capabilities of the use case diagram in Visual Studio Team Architect as well as the expressive capabilities of the UML

The above diagram includes all of the elements available for use cases within Visual Studio Team Architect as depicted in the screenshot of the toolbox below. We have seen examples of the most rudimentary elements the use case, actors and associations. The Subsystem is perhaps as common as the actor, use case and association elements. It is rare when a use case diagram is created without also including a subsystem element. This element denotes the boundaries of systems. There may be zero or more subsystems on a given diagram. The example above is using the subsystem element to denote the application that is to be developed.

Notice the actor to the right of the subsystem boundary, the Identity Management System. Although this is an external application that is called by the system under development since it is not part of the system that is being built it is represented as another actor that the Transportation system interacts. The association relationship between the Logon use case and the Identity Management System actor has a cardinality indicating that a single instance of the Identity Management System can interact with multiple instances of the Logon use case at once. The association relationships between the Customer actor and the Logon use case has a cardinality of 1 on both ends indicating that a single Customer may only interact with a single instance of the Logon use case at any given time.

The logon use case demonstrates many of the relationships that are possible with a use case diagram. The first type of relationship of interest is the Generalization. The Logon to Mobile and the Logon to Website use cases are both generalizations of the Logon use case. This indicates to the development team that there will be common functionality that can be reused between the mobile and web based logon use cases while also indicating the logging on to the system from either a mobile device or a website will require some specific details for each. The next relationship demonstrated by the Logon use case is the Dependency. The Logon use case is dependent on the Retrieve Permissions use case. Although the Retrieve Permissions use case is distinct without being able to retrieve a user’s permissions the logon will not be able complete. In comparison the Logon use case includes the Retrieve Customer Data use case. This demonstrates that the logon functionality will also include retrieving the customer’s data as part of the logon procedure. It is useful to break the Retrieve Customer Data out from the logon use case for a couple of reasons;

including it with the logon functionality would place too much functionality within a single use case to be developed in a meaningful manner
the logon and customer data retrieval are distinct capabilities and can be developed separately
the customer data retrieval will also be used by other actors as part of other processes that are not associated with the logon

The last relationship type is the extends relationship type. The Search for Customer Order use case extends the Search for Customer use case by adding an extends relationship with the arrow end of the relationship pointing to the use case that is being extended. The Search for Customer Order functionality will use the functionality of the Search for Customer use case while adding some functionality of its own to also find orders for customers at the same time.

The last two elements on the diagram are comments and artifacts. Comments can be associated with other elements as shown in the diagram or they can simply float on a diagram without a comment link. Comments are not a part of the UML model and do not show up in the UML Model Explorer. Comments are used to add short notes to the diagram. Artifacts are convenient elements to add to a diagram when it is helpful to provide a link to further documents. Looking at the properties for the artifact demonstrates the File Name property that can be configured to point to a file on a local file share. When working with Team Foundation Server it is helpful to have this location reference a document stored in one of the SharePoint document libraries that is part of the portal for the Team

Once the use cases have been created link them to the user stories. Link the Logon use case to the “As a user I want to logon to the application” user story by performing the following steps:

Right click the Logon use case and select “Link to Work item”
The standard Team Foundation Server “Work Items Picker” dialog is displayed. Expand the dropdown list by the Saved Query option and select “Open User Stories” from the “Team Queries” list.
Click the “Find” button and select the correct user story from the list and click the OK button

The next time you right click the Logon user story from any diagram the additional “View Work Items” option will be available. Clicking this option will display a list of all of the worked items that have been linked to this use case. You will have noticed that there is also the option to create a new work item from the context menu as well. This is particularly helpful as it is very common to identify new use cases and user stories as you work with the models. Unfortunately this is not a bi-directional link. There is no link back to the use case created from the work item and currently there is no way to create a link to a specific use case within the model. The best option available is to create a new link in the work item to a “Versioned Item” and reference the model file, a diagram or both.

Helping the Rangers

2009-07-10T07:02:00.000-07:00

The Rangers are a very interesting and cool bunch of guys that work for Microsoft as sort of evangelist/consultants. They work on creating guidance as well as help customers effectively utilize Microsoft products.

I have been very fortunate to be involved in one of their projects as they will occasionally reach out to the MVP community to assist them. Willy-Peter Schaub is a former South African MVP turned Ranger and has been kind enough to post a blog entry thanking the MVP and other non-Microsofties that have been helping out with the various projects on the go. I always like to see my name in print by someone else (especially when it's in a favourable way)!

If you don't currently follow Willy's blog it is a great read on the happenings in the Ranger camp at Microsoft as well as a general good read. Willy creates the best graphics and post quite frequently. I don't know where he gets the time!

Building out Use Cases from User Stories (part 3 of 5)

2009-07-10T06:46:00.000-07:00

The next step is to catalog into the model the user stories that we have captured as work items in Team Foundation Server. To begin each user story will be mapped to a use case. We will see how the model and the stories evolve as more information is learned in conversations with the users. For now simply map each user story to a use case by performing the following steps for each user story:

From the UML Model Explorer window right click the model project and select Add -> Use Case
Name the use case in a similar manner to the user story. For example the user story “As a customer I want to be able to look up my order to see if it has shipped” may become the use case “Look up orders” or perhaps “Look up shipped orders”

After entering several user stories, adding the roles from the user stories as actors and the actions and goals of the user stories as use cases a view of the UML Model Explorer and the user story list might look like the following:

Note that now the use cases match the user stories. For example the use case “Add New User” maps to the user story “As an application admin I want to add new users”. Coupling the use case with the “Application Administrator” actor provides the full fidelity of the user story. We will see how this is accomplished in a diagram shortly. One of the benefits of splitting the roles and actions apart into actors and use cases provides for the ability to demonstrate how multiple roles may benefit from the same use case as well as identify the common use cases between multiple roles.

The next step is to create use case diagrams to capture the user story intent between roles and actions as found in the title of the user stories. Do this by performing the following steps:

Select the We Transport modeling project in the Solution Explorer
Right click the We Transport project and select Add -> New Item…
In the Add New Item dialog window select “Use Case Diagram”
Name it “Orders.ucd” and click the OK button.

Visual Studio should now look similar to the following screenshot:

Now is a good time to check all of the artifacts that have been created into source control

Right click the solution icon in the Solution Explorer and choose “Check In…”
If asked, save any items that have not been saved
Enter a comment noting the actions that have been performed since the last check in and click the Check In button
Create the “As a customer I want to look up my order to see if it has shipped” as a diagram by first dragging the “Lookup Order” use case from the UML Model Explorer onto the middle of the use case diagram.
Next drag the Customer actor from the UML Model Explorer onto the diagram to the left of the use case
From the toolbox select the Association icon by clicking it.
Note that the cursor indicates the invalid symbol until it is moved over the actor at which point it becomes an endpoint connection icon. Click on the Customer actor on the diagram
Move the cursor over the use case on the diagram and click to associate the other end of the association with the use case.Your diagram should now look like the following:

Note the “+” icons that now appear beside the Customer actor and the Look up Order use case in the Model Explorer. Expand the “+” icons to see the relationships that were created in the diagram are reflected in the model.

You can add a comment to the use case diagram by either right clicking on the diagram surface or dragging a comment icon from the toolbox onto the diagram. You can association the comment with either an actor or a use case if the comment applies specifically to one of them. Associate a comment with an actor or a use case by adding a comment to the diagram and adding a comment link from the toolbox between the two or you can right click on either actor or use case and select Add -> Comment. This will create both the comment and the comment link association automatically. Although comments do not appear in the UML Model Explorer they are still added to the model xml file.

A benefit of presenting user stories as UML use cases in Visual Studio Team Architect is the easy view the UML Model Explorer provides to the list of available actors. As a use case is created using a single actor, such as the Look up Order example above it becomes easy to review the other roles to see if the same use case applies to any of them as well. In this example it is easy to see that the Call Center Worker is also likely to need to look up an order. When additional roles are identified that would leverage the same use case they should be added to the diagram.

Consider a user story titled “As a Driver I want to be able to log on to the application” this might translate into a use case called “Logon to Application” with an association between the use case and the actor “Driver”. It should become clear when this user story is defined that the same story will apply to each of the roles identified. Regardless of which role a user may belong the same user story would apply. To accommodate this situation a generic “user” role would be defined and the user story would read “As a User I want to be able to log on to the application”. “User” becomes an actor in the model of which all of the other actors inherit. This makes defining use cases that apply to all users of the application more concise and easier to read. Add a generic “User” actor to the system by performing the following steps:

Right click the UML Model Explorer and select Add -> Actor
Name the Actor “User”
Set the “Abstract” property for the “User” actor to “true”

As noted in the text at the bottom of the screen setting the abstract property to true indicates that this actor or element, “does not provide a complete declaration and can typically not be instantiated”. This means that further refinement is required to fully flesh it out and provide sufficient meaning.

The next step is to add a diagram to visually layout the associations between the various actors within the system. A new use case diagram will be used to hold this representation.

Right click the model project in Solution Explorer and select Add -> New Item…
Select Use Case Diagram and name it “Roles Relations.ucd”
Add all of the actors onto the diagram
Place the User actor towards the top center of the diagram with the remaining actors in a single row towards the middle of the diagram
Select the Generalization icon from the toolbox and click first one of the specific actors and then the abstract “User” actor creating a generalization between the two starting with the more specific actor
Repeat this association for all of the remaining actors. Your diagram should resemble the one below.

Note that the name of the “User” actor is in italics denoting that this element is abstract. The generalization associations are denoted by a line with an open arrow head at the end closest to the abstract, or parent, element. The end of the association without the arrowhead denotes the specialized element.

This generalization is also indicated in the UML Model Explorer by expanding the individual actor elements and further expanding the Relationships folder underneath each. Once the generalizations have been created a use case diagram can be created showing the abstract “User” actor associated with the “Logon to Application” use case. This shows that each of the actors in the system can log on to the system without cluttering the diagram with each of the specialized actors. Generalization is very useful for keeping the intent of a diagram clear by not cluttering it with all of the specialized actors that are users of the use case.

That's it for this entry. Next time I will explore ways of expanding on these ideas for greater depth and detail.

Beginning Use Cases – Identifying the Actors (part 2 of 5)

2009-07-05T15:38:00.001-07:00

Every project must understand, to some degree, what is to be built, at least at a conceptual level. There are many techniques that have been used over the years ranging from formal, lengthy requirements specifications to short concise user stories. To be successful one of the fundamental goals of requirements is the need to bring value to all members of the team including the project stakeholders. Requirements must convey the requested functionality of the users in a means that the development team can use as a starting point to create and validate software. So far in this series we have looked at establishing requirements using work items and SharePoint portals as they are incorporated with a Team Foundation Server MSF for Agile Software Development v5.0 based project. Using the user story work items established previously we will look at how the process can proceed by taking advantage of use cases and their support in Visual Studio Team Architect 2010.

As this series of posts is all about making the most effective use of VSTS Architect a very specific approach will be used for evolving requirements with use cases. Use cases have two distinct facets; one is the graphical notation as defined by the UML while the other is a textual format that describes the interactions between an actor and a system. The approach taken here will utilize both techniques and show how to leverage Team Foundation Server to tie the pieces together building upon the techniques discussed earlier.

We started our project by establishing the user stories that are currently known and have been identified as the features and capabilities that the application should support to meet the needs and desires of the users. The next step once the user stories have been entered into Team Foundation Server is to create a new Visual Studio solution to contain our models. Starting the project by creating a model in Visual Studio Team Architect first is also a very viable option. Building a model first can be a very quick and easy way to visualize the relationships between requirements ensuring that there is consistent view of the proposed solution. User stories can easily be created from the use cases as we will see.

1. Begin by open Visual Studio Team Architect 2010

2. Select File -> New -> New Project

3. Select Modeling Project from the list of available project types. In the sample the project is named Models, the solution is named WeTransport and both the “Create directory for solution” and “Add to Source Control” options are selected.

4. Once the project is created the “Add Solution to Source Control” dialog window is presented

5. Select the WeTransport project from the list of projects in source control and click the OK button.

6. Check your files into source control

Open your list of user stories that have been created for the project and list each of the roles that have been identified. If you have been creating titles for your user stories of the form “As a «role» I want to «action» to achieve «goal»” you will be able to easily identify the majority of the roles by simply reading the titles of the stories. As an example the user story “As a customer I want to be able to look up my order to see if it has shipped” identifies the role “customer”. Watch for user stories that have identified the role as “user”, this is too generic as all roles that interact with your software will be users. Look for more specific roles such as Administrator, Customer, Call Center Operator, etc. For each role create a new Actor in the model. Using “Customer” as an example, perform the following steps:

1. Open the UML Model Explorer window. View -> Other Windows -> UML Model Explorer

2. Right click the model project “We Transport” within the model explorer

3. Select Add -> Actor

4. Name the new actor element “Customer”

Your model should now contain a single element of type Actor named Customer as shown below.

Continue adding the rest of the roles identified in your user stories as actors to the model.

Once you have added all of the roles identified in the user stories to the model you have a concise single location to review the actors that are involved in your application development effort. Each of the actors within the model represents a role that an end user can assume as they use the software. A single person may easily assume multiple roles, for example a call center worker may also be a supervisor. The specifics behind each of the actors/roles should be captured and documented within the SharePoint portal site for the team project. A common technique for defining the roles and to bring them to life for the team is to use personas. Not only do personas define the responsibilities and duties of an actor but they also provide a personality with a background, name and description that bring the persona to life. Teams commonly provide pictures to go with the personas and hang them in the team room to help remind the team who they are designing the software for.

Use Cases and Visual Studio 2010 (part 1 of 5)

2009-07-02T13:12:00.001-07:00

The Beginning

I would like to introduce an approach to developing software in an agile manner that leverages some of the new capabilities introduced with Visual Studio Team System 2010 and in particular focusing on the Architect Edition to add modeling into the software development process while still maintaining an agile methodology. This first post is about setting the stage for the project and the initial setup that will drive a series of posts on use cases.

The Company

The fictional company that we will be dealing with in this series is the We Transport transportation company. We Transport is a company that provides logistics and shipping information for their clients. Their clients are any other company that needs to move goods from one location to another in an ongoing manner. We Transport owns and operates a fleet of trucks and warehouses and operates throughout North America. They employ drivers, warehouse workers and clerical staff as well as hold contracts with individual contract drivers. We Transport also provides expedited shipping on an as needed basis for their clients by acting as a broker for the top three courier services available today. We Transport can also coordinate and broker shipments that include rail transportation and some ship based transportation although that portion of their business not considered a profit center and so is only offered to their larger customers in certain situations.

We Transport’s customers are typically either retail based enterprises that require consumer goods to supply their stores or are the manufacturers themselves that provide and store large quantities of goods from off shore locations to distribution warehouses throughout the continent. We Transport maintains and negotiates contracts with their customers that establish shipping rates based on frequency and quantity as well as storage fees to provide warehousing services. Although there are standard contract types that are used, each customer can request specific deals as part of the negotiated contract and as such each contract will have some degree of variation with all others.

The Project

We Transport has recently identified a need for a new application to provide increased services to their clients and increases operational efficiencies. An exhaustive build versus buy initiative was embarked upon with the end result being an identified need for a custom developed solution. We Transport has decided to embrace Visual Studio Team System for their initiative. We will examine how Team Foundation Server and Visual Studio Team System Architect can fit into the software development lifecycle.

To begin the endeavor a new project is created in the We Transport Team Foundation Server. We Transport is using Visual Studio Team System 2010 and they work in an agile manner, therefore the new project in Team Foundation Server is created using the MSF for Agile Software Development v5.0 template.

One of the work item types created as part of the MSF for Agile Software Development v5.0 project template is the “User Story”. A user story is a light weight artifact that is used by several of the more popular agile methodologies and is well documented and described by Mike Cohn (Cohn, 2004). In most organizations a user story is nothing more than a very short description written by a business focused team member, preferably a target user of the application but it can be an analyst or user proxy. The user story is written on a 3x5 index card and posted on a cork board where it is managed and tracked throughout its lifecycle. The user story represents nothing more than conversation that must take place between the business user and the developer of the story or development team. An accepted form of a user story is a sentence structured like: “As a <role> I want to perform <action> to achieve <goal>”.

The user story work item type as defined within the MSF for Agile Software Development v5.0 template tracks much more information than just the sentence as defined above. I recommended that you continue to use the index card approach along with the cork board for tracking if that is what you are comfortable with and as long as the method has been successful for you. However, you should also duplicate the index card in Team Foundation Server as a user story work item using the sentence on the card as the title of the work item.

Writing quality and meaningful user stories is a book unto itself and the definitive resource is Mike Cohn’s (Cohn, 2004), it is highly recommended that you get a copy of Mike’s book for further details on user stories. Identifying and cataloging the user stories for the system under development should be your first action when starting a new project. In fact this step almost always happens well before the project team has been assembled because these light weight requirements generally need to be identified to determine if there is even a need for a project and more often than not, these same user stories are used for initial estimation to determine target budgets, team size, and other resources required to bring together the rest of the project team. Once you have created your user stories and entered them into the Team Foundation Server project you can start to track and use them to drive the development of your project. Using the MSF for Agile Software Development v5.0 template to track and manage projects is not the topic of this series. Using Visual Studio Team System Architect is though, so we will switch gears in the next post to look at how to leverage Team Arch as part of the SDLC.

Bibliography

Cohn, M. (2004). User Stories Applied: For Agile Software Development. Addison-Wesley Professional.

MVP Award!

2009-07-01T09:21:00.000-07:00

Today I was fortunate to be awarded the Microsoft Most Valuable Professional title. This is a fantastic award that I am very excited about.

I want to thank everyone that has helped me get to this position. I hope to continue to bring great value to the community regarding VSTS.

Event Snippet

2009-06-15T13:01:00.001-07:00

I am working on an event driven development sample to use as a basis for a presentation and perhaps a hands-on-lab for event driven design. Naturally this involves creating a bunch of events on a bunch of classes. Being the lazy programmer that I am after I started to write my second event using the standard event code:

public event EventHandler; Validated;

protected override void OnValidated(EventArgs e)
{
if (Validated != null)
{
Validated(this, e);
}
}

I looked for the snippet to make this easier, less error prone and consistent. Not finding one I wrote one myself and have posted it here for the taking.

In case you don’t know what a snippet is here’s a quick overview.

Starting with Visual Studio 2005 (I think…) Microsoft supplied a nice little code generation capability in the form of snippets. They are accessed via intellisense as well as a few other ways such as context menus. For example if I type cw in a C# code file the intellisense gives me this:

By next pressing the Tab key twice the snippet expands into this code:

Console.WriteLine();

and places my cursor between the parentheses so that I can add the text to be written to the console. There are a bunch of snippets that come with Visual Studio for things like for loops, properties, constructors, etc.

For more complex snippets variables are incorporated so that you can tab between the variables, which act as placeholders, replacing them with something that is meaningful to your code. In my snippet the EventArgs and MyEvent strings are variables. When the snippet is resolved, by pressing Tab, Tab from the intellisense window the variables are highlighted as shown below.

If I begin typing the snippet will replace EventArgs (highlighted in blue) with whatever I type. This lets me change the argument type of the event delegate. Once I type what I want the snippet takes care of replacing all instances of EventArgs as denoted by the outlining seen on the second line of the snippet with whatever I type. By pressing the Tab key the snippet moves to the next variable, “MyEvent”. When I type my own event name, such as “Validated” from the sample above, all instances of “MyEvent” are instantly changed to Validated so that the code reads just like the sample at the top of this post.

So to write an event routine like the top of the code I need to type “evt” (my snippet name) Tab, Tab, Tab (the third tab moves to the MyEvent placeholder because I am using the built in EventArgs type) and “Validated”, Enter. A grand total of 16 key strokes.

Super simple, very consistent.

To create a custom snippet the easiest way is to just modify one of the existing ones found in the “Program Files\Microsoft Visual Studio\<language>\Snippets\<locale>\<type> directory. They are quite easy to understand. To deploy a new one, such as the one I created, just copy the *.snippet file to the location above or to your user location: “C:\Users\<user>\Documents\Visual Studio 2008\Code Snippets\<language>\My Code Snippets” and Visual Studio will pick it up and away you go.

Happy snippeting.

MEF Tutorial

2009-06-11T12:26:00.001-07:00

You know that everyone’s doing it. MEF is everywhere. It’s on the streets, the kid down the block is using, it’s easy to make. It’s practically addictive.

Ya gotta wonder how much of this will go on, it’s just one of those acronyms that lends itself to abuse. I know I’m not the first and surely not the last. Well just in case you have no idea what I’m talking about, it’s the Managed Extensibility Framework from the folks in Redmond. It’s currently in preview 5 and can be downloaded from CodePlex here. It’s a very slick dependency injection/extensibility framework that is coming in .NET 4.0 and will be fairly core to extensibility in Visual Studio 2010.

To get a handle on it I worked through a simple sample of my own and then thought it might make a good one to share so I put together a real quick and dirty hands-on-lab. The document and code are available from my skydrive here. Check it out, first one’s free….

Software Craftsmanship Workshop - Olympia

2009-06-08T09:05:00.001-07:00

As any good geek would do I gladly spent my Saturday in a conference room attending the first Software Craftsmanship Workshop held by the Seattle Alt.Net guys in Olympia, WA.

This was a great event that holds a lot of promise to be repeated again in many locations. I chatted with the local coordinator for the event, Anne, for a bit about the workshop. It seems that she attended an Alt.Net event in Seattle one time and was so impressed with the openness and passion exhibited by the group that she wanted to bring some of that back to her home town of Olympia. Working with the Alt.Net guys they came up with the idea of the workshop. A half-dozen of the Alt.Net guys put together a program in which a typical RAD web application is created that serves the initial business needs but is hard to maintain with tightly coupled code. The day progresses as we explore why the application design is difficult to maintain and how to go about making it better.

A couple of different views were taken throughout the workshop. A discussion of various quality design and development practices were used in which topics such as Robert C. Martin’s SOLID principles, Test Driven Development (TDD) and many design/development patterns were examined. The guys did a very nice job of covering a wide array of topics in a short amount of time. The scenario that they established at the start of the workshop was very realistic while also adding a degree of humor to the event. Yes, the government is tracking the aliens as best can with the software they have… :-)

A great resource that they mentioned that I hadn’t stumbled across before is the Foundations of Programming website.

I am eager to see if this event takes off and is repeated in other locations. There is a lot of value to it and I would like to see more events of this nature occur. Now, what will it take to repeat the workshop in Portland…

Installing VSTS 2010 B1 - Caution

2009-05-19T07:52:00.000-07:00

There has been a bit of chatter in some of the lists about how to properly install the Visual Studio Team System 2010 Beta 1 bits.

The installation is now split into two distinct components; installation and configuration. Each of the two components operates separately. This provides a very flexible way of setting up a new server as you can install some of the subordinate components such as SharePoint and Reporting Services after a TFS install because the configuration is handled separately. HOWEVER, in the beta 1 release there is a problem that will be encountered unless you actually run the configuration directly after the installation from within the same process. Buck Hodges has explained it in detail which I copy below.

<Buck Hodges>

Here's a known issue with configuring TFS 2010 Beta 1 that we want to make sure folks avoid. If you follow the default process of configuring the server with the wizard after the MSI setup phase completes, you will not hit this issue.

However, if you choose not to follow the default path of running through the configuration wizard once the MSI setup phase has completed (i.e., if you choose to uncheck the box at the end that says to launch the configuration tool), you will need to run the following command line to avoid corrupting your SharePoint installation (TFS will install SharePoint 3.0 for you, unless you opt out of it).

"%programfiles%\Microsoft team foundation server 10.0\tools\tfsmgmt.exe" configure

You will end up with a corrupt SharePoint installation if you run the TFS configuration wizard from the administration console. You can find more details in the following blog post: TFS 2010 Beta 1: Don’t run initial configuration from the administration console (MMC).

Right now, the easiest workaround if you get into this situation is to uninstall SharePoint and TFS and install TFS again (TFS will then install and configure SharePoint for you). We're looking into whether there is a simpler way to recover.

So heed the advice and have a successful install!

VSTS 2010 Beta 1 Released!

2009-05-18T07:44:00.001-07:00

How sweet it is. The beta 1 for Visual Studio Team System has been released! Soma Somasegar made the announcement this morning on his blog here. This is a very exciting release from the gang in Redmond and I am quitre excited to get my hands on it and start exploring the changes since the CTP that was released waaaaaay back at last year's PDC.

Work Items Hands-on Lab

2009-05-08T08:48:00.000-07:00

One of the topics that I talk about a lot with clients that are using Team Foundation Server for only source control is the power of the work item system. Many users are unfamiliar with work items and how they can be used effectively to help manage and control projects. Demonstrating the different ways of interacting with work items from Excel, Project, Team System Web Access portal as well as Visual Studio inevitably illuminates a few light bulbs regarding the capabilities of the work item tracking system in TFS.

To help out with the understanding I have created a hands-on lab for exploring work items. It is built upon the VSTS 2008 virtual image that is available from Microsoft. This provides you with a pre-configured ready to go environment that you can safely experiment with.

You can get the hands-on lab document with full instructions here: Work Item Hands On Lab

Scrumban

2009-04-18T21:51:00.000-07:00

I read Corey Ladas’ book Scrumban a little while ago and he has some very interesting thoughts that made me contemplate the ideas he presents. There has been a reasonable amount of chatter these days about lean practices in software development. Naturally the seminal work on the subject was written by Mary and Tom Poppendieck back a few years ago. Corey takes a different approach. The first half of the book (or so) is a theoretical look at lean as it applies to software development with the second half being a more practical approach to running a lean project.

He makes some convincing arguments and I am eager to try them out on the next opportunity that presents itself. One of the challenges that I have seen organizations struggle with when it comes to many of the agile methods is the ability to achieve “done” at the end of an iteration. Naturally it is extremely difficult to predict exactly how much work a team can accomplish in a four week, or even two week, sprint. So the goal is to accept as much work as the team is willing to commit to over the iteration. Some of the problems are:

Not accomplishing everything that was committed to can be demoralizing
Over committing can lead to overly hard pushes towards the end of the sprint leading to a uneven pace
Under committing for fear of failure can lead to sub-optimal performance
Truly achieving “done” while trying to fit into a specific time box is very difficult

Taking the continuous flow approach as described by the lean methodology makes a lot more sense to me. I believe that the team can, and really must, take time to review the backlog (such that it is in lean), hold regular retrospectives and maintain solid agile development practices but forget the time boxed commitments to done and start a sustainable, continuous flow of product value that really meets the definition of done. I mean like “done done”.

I highly recommend Corey’s book and would like to hear anyone else’s comments and opinions on it.

Workspaces in Team Foundation Server - Part 2

2009-04-18T20:31:00.001-07:00

Building on the workspaces introduction that I wrote here I’m going to discuss a few more ways that workspaces can go sideways on you and how to deal with it.

Last time I discussed how workspaces can get out of control simply by being created so easily for you behind the scenes. Well now you know better and you will use a little more caution next time you create a workspace. Ya right, that’s what I keeping telling myself as well. If nothing else at least you have the ability to manage the workspace mess that has been created and you can sort it into a more meaningful structure.

One of the things that I briefly touched upon was the impact of multiple users on a single workstation. There can be several reasons why this can happen. One of the reasons I presented last time was having another developer try executing your code on your machine under their login credentials while trying to debug a security problem. In large organizations I have seen workstations get reassigned on a regular basis as people come and go or get upgraded to new machines. This easily results in a propagation of workspaces on the server. Imagine if you have 5 workspaces on a particular workstation and are then assigned a new machine. You then go and create 7 new workspaces on the new machine as well as one or two on co-workers machines and a few on the laptop you borrowed to do a code demo. Every single one of those workspaces is captured and stored on the server whether you ever use that computer again or not. An extra challenge comes when the user leaves the company leaving 13 workspaces behind, each one of them reserving disk locations on various computers. Add to the challenge an organization that standardizes on the location that developers store their source code locally.

It’s time to go workspace spelunking.

Begin by opening a Visual Studio command prompt (Start-> All Programs -> Microsoft Visual Studio 2008 -> Visual Studio Tools -> Visual Studio 2008 Command Prompt).

Type tf /?

This should get you a nice long list of everything that you can do with Team Foundation Server from the command prompt. As you will see this is a very extensive list of commands. TFS has incredible command line support and is well worth spending some time exploring the capabilities provided here. What we are interested in for this article are the last two commands in the list, workspace and workspaces. We will begin with the workspaces command. The description taken from the help listing says:

“Displays information about workspaces in the system and updates cached information about a user name or computer name change on Team Foundation Server.”

Typing “tf /workspaces” at the command line will give you the same listing as you see when viewing your workspaces in Visual Studio Source Control Explorer. However, by modifying the parameters a bit we can get a wealth of information about all of the workspaces tracked by all TFS servers on your network. For our purposes we want to see all of the workspaces that currently exist on our server so we type the following:

tf workspaces /computer:* /owner:*

This command will return all of the workspaces on the server for all users and all workstations.

With this snapshot of all of the workspaces managed by the server it is easy to see if there are any workspaces that should be removed, perhaps for users that are no longer with the team or for machines that have been retired or for any other reason, of which there can be many!

In the screenshot above there are four workspaces listed however in a real environment there will be many more, quite easily hundreds depending on the size of your development team and the number of projects. To make working with the output easier I will often export the results to a text file and use excel to make managing the data easier. At the end if the command above I export the results to a file named workspaces.txt as shown below:

tf workspaces /computer:* /owner:* > workspaces.txt

Opening the resulting workspaces.txt with excel results in Excels import wizard taking over to determine how to import the data. Using the defaults gives us a spreadsheet that looks like the following:

It may not have gotten the comments data quite right but the rest is perfect. It is now easy to sort and filter by Owner and Computer. Using the spreadsheet you can identify workspaces that need to be removed.

Now that the errant workspaces have been identified it is time to clean them up. This is where the workspace command is used. As a side note you may notice that the workspaces command has a /remove switch. This switch removes the workspace from the client cache only not from the server.

Using the tf workspace command lets us not only clean up errant workspaces on the server but it can also be used to modify existing workspaces or create new ones. Refer to the documentation for the full capabilities (http://msdn.microsoft.com/en-us/library/y901w7se.aspx). Right now we are only interested in the /delete option.

If the user named tfsSetup was no longer part of our company and we needed to remove their workspaces from the server we would use a command like the following:

tf workspace /delete TFSRTM08;tfsSetup

One caution when using this command is the need to use the Owner name along with the workspace name. If you were to issue the command below:

tf workspace /delete TFSRTM08

The command would execute fine because the Owner is an optional parameter, however if the Owner value is not provided the default is to use the name of the user executing the command. This means that the workspace that would be deleted would be yours. If you didn’t have a workspace with that name the command would fail.

Another caution regards any pending changes that may be outstanding within the workspace being deleted. They will be undone! The command does warn if there are any outstanding pending changes and does give you the option to cancel though so it's not without a safe guard.

Hopefully this helps you better understand and manage the workspaces on your TFS installation.

ALT.NET Heads to the Great White North

2009-04-16T20:22:00.000-07:00

Ah, my motherland is getting an alt.net conference this summer just a few short hours north of where I now hang my hat.

Vancouver, Canada will be playing host to the ALT.NET Canada conference this June 12-14. Check out the specs here: http://altnetconfcanada.com/home/index.castle.

How cool is that, eh?

Workspaces in Team Foundation Server - Part 1

2009-04-16T20:00:00.001-07:00

Workspaces are one of the magical elements in TFS that can sneak up and bite you when you least expect it. One of the reasons they can do this is because they are somewhat out of sight, out of mind and can be created without any intervention of the user.

First a primer on what they are and how they work. A workspace represents a user (Larry) working on a specific computer (Workstation1) with a selection of files from Team Foundation Version Control (TFVC), maybe it is all of the files stored in the “BigApplication” project ($BigApplication), that are copied to my workstation in a specific location, perhaps to D:\DevelopmentProjects\BigApplication. This data represents four distinct pieces of information; who, what workstation, which server files/directories, where are the server files mapped to on the workstation.

All of this information is stored on the Team Foundation Server.

When a user first connects to TFVC and gets files from the server to their workstation the user is asked where to copy the files on the workstation. This creates the “which” and “where” elements of the four pieces of information, by simply connecting to TFS the user and workstation (“who” and “what”) are identified to the server. Once the user has told TFS where to copy the files TFS automatically creates a workspace with the relevant information. Using the example above I would have a workspace with the following information:

Who: Larry
What Workstation: Workstation1
Which Server Files: $BigApplication
Where on the workstation: D:\DevelopmentProjects\BigApplication

You can also think of the “which” and the “where” as a single piece of information that is a mapping from the server to the workstation.

This is all fine and good as long as you stay working within the constraints of this workspace. Challenges can be encountered in numerous ways, I will describe two scenarios next that can cause confusion and then I will look into how you manage workspaces effectively.

Involving other Developers

With large complex distributed applications coupled with complex development environments security rights and permissions can often be a challenge to resolve and debug. There may be cases where a developer is unable to connect to all aspects of the TFS environment or when executing code under development that runs against distributed web services and/or remote databases errors may be encountered that may or may not be security related. When attempting to resolve security related concerns logging onto the same workstation as a different user is a common tactic.

So now Anne, my team architect with increased permissions, comes to help me resolve my problems. She logs onto my machine to run the application under his credentials. She fires up Visual Studio, connects to TFS and performs a “get” on the latest version of the code and says that she want to store the code in D:\DevelopmentProjects\BigApplication. This results in an error from Visual Studio because TFS knows that I have already mapped source code from the server to that location on my workstation.

TFS will not permit another user to overwrite the files that I may have already copied to the workstation. In this new scenario the workspace contains the following data:

Who: Anne
What Workstation: Workstation1
Which Server Files: $BigApplication
Where on the workstation: D:\DevelopmentProjects\BigApplication

Because this conflicts with the workspace that I had already created TFS will not permit it. This same error will be encountered if I get a new workstation and my old workstation is given to a new developer. Even if the workstation is formatted if the workstation name remains the same and the new owner tries to copy source files from TFS to the location D:\ DevelopmentProjects\BigApplication it will fail because of the conflict with the previous workspace which is stored on the server.

Where did those files come from?

After working on the Big Application for a while I am asked to help out with an urgent bug fix on another project that has a looming deadline. I still have a few files checked out from my work on Big Application, but that’s okay as I will only be working on Important Application for a day or two. I connect to TFVC and get the source code for “Important Application”. When TFS asks me for the location to download the code I provide the path D:\DevelopmentProjects\ImportantApplication.

I then make a few changes fixing the bug and proceed to checkin my code. I am surprised to see that the checkin window is listing all of the files that I have checked out from Important Application as well as the files I have checked out from Big Application even though I don’t have the Big Application solution open in Visual Studio.

This all comes back to workspaces. The Pending Changes window displays all pending changes (check outs) that I have for the workspace I am working in. When I performed the “get” for Important Application TFS added the source mapping to the same workspace. My workspace definition now has the following data:

Who: Larry
What Workstation: Workstation1
Which Server Files: $BigApplication
Where on the workstation: D:\DevelopmentProjects\BigApplication
Which Server Files: $ImportantApplication
Where on the workstation: D:\DevelopmentProjects\ImportantApplication

Managing Workspaces

Workspaces can be managed from Visual Studio by opening the Source Control Explorer and selecting the dropdown list of workspaces.

By selecting the dropdown list you will see the list of all workspaces on the TFS for the current user, enabling you to choose which workspace you want to set as your current workspace context. The last entry in the list is “Workspaces…” by selecting this list value you will open the “Manage Workspaces” window. This window displays the same list of workspaces as the selection list presented but rather than using this to set the active workspace you use this selection to manage the selected workspace. Additional information available from this window is which workstation the workspace is associated with along with any comment that may have been provided with the workspace.

If you have never worked directly with workspaces and have let TFS create and manage them for you then you will most likely only see one workspace for each workstation (Computer) that you have used to connect to TFS. The default name that TFS uses for workspaces is the name of the workstation. In the screenshot above you see 3 workspaces that were each created from the same workstation (TFSRTM08). The default workspace that TFS created is also named TFSRTM08 (the second one in the list). Selecting the TFSRTM08 workspace and selecting edit takes us to a screen like this:

You can see in the top section where the workspace information for who (Darren), what workstation (TFSRTM08 [Computer]) as well as on which server this workspace is tracked (TFSRTM08 [Server]). The center section for the comment is just an arbitrary text field that can help remind you of what the workspace is for (I added “Default workspace” in this example). The bottom section has the mapping from which server files to where they go on the local workstation. This workstation is mapping the contents of the “$/BuildProject/Main/WindowsFormsApplication1” location on the server to the workstation location of “C:\MSLabs\VSTS 2008\Work\Team Build\WindowsFormsApplication1” as well as the contents of the “$/BuildProject/TeamBuildTypes” to the workstation location of “C:\MSLabs\VSTS 2008\Work\Team Build\TeamBuildTypes”.

As you can see the mapping is not keeping the relative locations from the server layout equal to the relative locations on the workstation. There is no requirement to do so. However if you happen to create any sort of relative relationships from the contents of one directory to the contents of the other, perhaps for external file based assembly references or other file references this relationship may not match how other users create their workspaces. Use caution!

There is also no reason that you need to restrict your workspaces to a single TFS project. You can map folders from any project to almost any workstation location you care to all within a single workspace. The reason I say almost is because you are not permitted to create a mapping that would cause a workstation collision in which two different server projects would end up mapping different files to the same workstation location. In other words you can’t do this:

Attempting to do so will generate this error:

You are not permitted to map two different source directories to the same workstation directory as this would cause a collision.

Another interesting thing that you can do with workspaces is cloak a location. In the sample below the “$/eBanking1/TFRobotUnitTestSampleSolution/TFRobotTest” server location is cloaked.

As you can see the “$/eBanking1/TFRobotUnitTestSampleSolution/TFRobotTest” location is a sub folder of the “$/eBanking1/TFRobotUnitTestSampleSolution” location. By setting the status to “Cloaked” the contents of the “$/eBanking1/TFRobotUnitTestSampleSolution/TFRobotTest” folder are not downloaded when performing a “get” from the server. This can be particularly handy when you need to work with a subset of the information contained in source control and the other information can be of significant size. The catch is forgetting the you have the location cloaked and experiencing frustration when trying to figure out why some of the files don’t download for you!

In my next post on this subject I will look at managing workspaces from the command line as well as some recommended best practices.

Portland Code Camp

2009-04-15T10:04:00.001-07:00

Things seem to be progressing well with the planning for the Portland, OR 2009 Code Camp. Reed College has been secured for the event and the web site is up and running and eagerly awaiting your presentation submission!

Go here to find out more: http://portlandcodecamp.org/

See you there!

Visual Studio Team Test Guidance!

2009-04-01T20:47:00.000-07:00

In my opinion the tester edition of Visual Studio Team System is one of the most underutilized editions of the product suite. To address some of the challenges that people have had trying to figure out how best to use the product the Microsoft Rangers have come to the rescue again!

Two days ago the Rangers released the Visual Studio Team Test (VSTT) 2008 Quick Reference Guide. Don't be fooled by the title this guide is 83 pages long! The topic areas in the guide are:

Setup Considerations
Web Test Considerations
Web Service Test Considerations
Unit Test Considerations
Load Test Considerations
Load Test Rig Consideration
Performance Data Collection and Usage
Load Test Results Store Information
Test Customization
Items Changed or Fixed in VSTS 2008 SP1
General Commands and Tricks (Not VSTS Specific)

As you can see there is a lot of information to be had. So go and grab a copy on CodePlex at http://vstt2008qrg.codeplex.com/ and get testing.

Boise Code Camp

2009-03-28T17:11:00.000-07:00

Another code camp complete. These are always such great events and the Boise Code Camp is certainly no slouch. There were tons of great presentations and great people.

I promised to post the code to my last presentation on Events and Delegates and you can get it here:

MOSS TFS Development Guidelines

2009-03-16T08:28:00.000-07:00

Great news from the VSTS Rangers! Last week they shipped the guidance packages for developing MOSS solutions using TFS. I quote:

The two whitepapers are:

VSTS Rangers - SharePoint Server Custom Application Development: Document Workflow Management Project
Read about the real-world design, construction, and deployment of a custom SharePoint Server 2007 application to a mid-market enterprise customer using Team Foundation Server as an ALM platform.

VSTS Rangers - Using Team Foundation Server to Develop Custom SharePoint Products and Technologies Applications
Learn how to use TFS to support your SharePoint application development, and provide an integrated development environment and single source code repository for process activities, integrated progress reporting, and team roles.

The first article is created during a real world customer engagement and answers dozens of frequently asked questions and how-tos in a real world context vs. theoretical discussions. The 2nd package addresses very common questions around setting up and using TFS features for a MOSS development project.

Combined with the following guidance from P&P posted here, we have a good and almost complete story for our customers and partners. The two teams worked together to align these stories.

patterns & practices: SharePoint Guidance
The SharePoint Guidance contains a sample implementation of an intranet application based on SharePoint Server 2007 that demonstrates solutions to many ALM challenges.

VSTS Big Event!

2009-03-16T08:21:00.000-07:00

Coming to Portland, OR May 5th the Team System Big Event! Along with Caroline Williams and Charles Sterling both from Microsoft, I will be presenting on various topics featuring the power of Visual Studio Team System.

How do you take an idea from conception to completion? How can you truly do more with less?

Please join us for this unique, invitation-only event to discover how both product and processes help your organization succeed in today’s environment. We will explore how Team System assists teams across the board to be successful in today’s tough times. This "break through" event will not only provide you with best practices around development and testing, but will demonstrate key capabilities of both Visual Studio Team System 2008 and the upcoming 2010 release. It’s a day that promises to have something for everyone!

SESSIONS

Test Driven Development: Improving .NET Application Performance & Scalability
This session will demonstrate how to leverage Test Driven Development in Team System. We’ll highlight both writing unit tests up front as well as creating test stubs for existing code.

"It Works on My Machine!" Closing the Loop Between Development & Testing
In this session, we will examine the traditional barriers between the developer and tester; and how Team System can help remove those walls.

Treating Databases as First-Class Citizens in Development
Team System Database Edition elevates database development to the same level as code development. See how Database Edition enables database change management, automation, comparison, and deployment.

Architecture without Big Design Up Front
Microsoft Visual Studio Team System 2010 Architecture Edition, introduces new UML designers, use cases, activity diagrams, sequence diagrams that can visualize existing code, layering to enforce dependency rules, and physical designers to visualize, analyze, and refactor your software. See how VSTS extends UML logical views into physical views of your code. Learn how to create relationships from these views to work items and project metrics, how to extend these designers, and how to programmatically transform models into patterns for other domains and disciplines.

Development Best Practices & How Microsoft Helps
Sometimes development teams get too bogged down with the details. Take a deep breath, step back, and re-acquaint yourself with a review of current development best practice trends, including continuous integration, automation, and requirements analysis; and see how Microsoft tools map to those practices.

"Bang for Your Buck" Getting the Most out of Team Foundation Server
Today’s IT budgets are forcing teams to do as much as they can with as little as possible. Why not leverage Team Foundation Server to its full potential? In this session we’ll highlight some capabilities of TFS that you may or may not already know about to help you maximize productivity.

Scrum Sprint Planning with Team Foundation Server

2009-02-18T08:21:00.000-08:00

Ok, it’s really easy to “do Scrum” using Team Foundation Server (TFS) as is out of the box. No special Scrum templates required. Really. In a previous post I showed how to create a burndown chart using the data that is available within TFS and in another post I talked about how the terms given to fields in TFS can cause undue confusion . Those two posts feed into the means for using TFS for Scrum as I will elaborate here.

Whether you use the Agile template or the CMMI template from TFS doesn’t matter they will both work just as well. Refer to my post on getting hung up on labels if you think that creating a project using the CMMI template will suddenly doom you to a waterfall method. Usually I tend to use the Agile template to try and keep people comfortable but in this case I will use the CMMI template for the examples just to show that it won’t burn.

First things first, you need a backlog. Open Excel and using the Team ribbon connect to your project in Team Foundation Server using the “New List” icon and select to “Input list”. Since I am using the CMMI template I add the “Requirement Type” and the “Estimate” to the displayed columns. Using Excel create your backlog by entering new work items into the spreadsheet. If you typically use story cards then enter the title from the story card into the title column, set the “Work Item Type” to “Requirement”, “Requirement Type” to “Scenario” and provide an estimate value in whatever measure you desire, whether that is story points, hours or days it doesn’t matter. I like to add a column of my own called “Priority” to use for sorting the backlog. Save this spreadsheet to the TFS project portal. You now have a product backlog that is accessible to everyone and feeds into TFS.

Sprints

The way I use TFS to manage sprints is quite simple and has proven to be very effective. I use the Iterations field. Edit your iterations by removing the default ones that come with the template. You edit iterations by right clicking the project name in Team Explorer and selecting “Team Project Settings -> Areas and Iterations…” from the context menu. Select the “Iteration” tab, and remove the Iteration 0, Iteration 1 and Iteration 2 values. Next create an iteration named “Current Sprint”

Assuming that your product backlog is prioritized you are now ready to begin your first sprint planning session.

Begin by choosing the work items from the product backlog that the team feel s they can commit to within the upcoming sprint. On the teams that I coach we usually find that 2-3 requirements are all that will fit into a single sprint. At that size we need to break them down into smaller sized tasks to get a better grip on them. We do this by decomposing the requirements into tasks and estimating the tasks. We link all of the tasks to the associated requirement for traceability.

Once the tasks have been defined for the sprint they are all assigned to the “Current Sprint” iteration. You may choose to add the related requirement to the “Current Sprint” as well depending on how you wish to report on these things. There are several benefits to this approach:

It is easy to query on everything in the current sprint by filtering on the iteration regardless of links or area.
Reports are easy to generate that always filter on “Current Sprint”. The report is always reflective of the current sprint whether it is the first, third or last sprint of the project.

Create a query in TFS that retrieves all work items for the project filtered by “Current Sprint” .

Sprint Review

Before starting the sprint review meeting create a new iteration with the name “Sprint x - - ” replacing the “x” with the number of the sprint, replacing the with the actual start date of the just completed sprint and replacing with the actual end date of the just completed sprint. For example “Sprint 2 Feb 2 2009 – Feb 13 2009”.

During the sprint review open an Excel spreadsheet (I use a projector so everyone can see it) and run the query for the current sprint work items. We usually filter by each person on the team and review the items they worked on to ensure the remaining time is accurate and the state is correct (is it still open or should it be closed). Each work item that has been closed is assigned to the iteration for the just completed sprint. In this example you would move the work item from “Current Sprint” iteration to the “Sprint 2 Feb 2 2009 – Feb 13 2009” iteration.

After all of the work items have been reviewed any remaining items in the sprint represent those tasks that were not completed. What you do with those items is up to you but the approach we take is to either keep them in the “Current Sprint” iteration because they will be completed in the upcoming sprint or to move them to the root iteration for the project. Moving them to the root is a place holder bucket for us. Any tasks in the root represent work that still needs to be done but is not targeted for the current sprint. Essentially these items become part of the product backlog.

After the first sprint has been completed when planning for the upcoming sprint you need to review the work items in the root to see if they should now be included in the current sprint. Depending on how you are managing your backlog you may have work items in the root iteration that aren’t in your product backlog. I usually encounter this when the product backlog contains only Requirements work items but the root may contain Task, Quality of Service or other non-Requirements work items.

Using this technique coupled with creating a burndown chart as I described in my previous post you have the ability to support Scrum using the templates that come with Team Foundation Server. By using Scenarios from the Agile template you can easily duplicate the steps outlined here. As you can see there is nothing stopping you from being as agile as you like while still using the CMMI template.

Benefit and Risk of Team Foundation Server

2009-02-17T08:10:00.000-08:00

Today I was sent an email asking me if I could share some of the benefits and risks of using Team Foundation Server. That’s a tall order and without knowing anything about how the person’s organization works, their skills and processes it could become either an exercise in futility or simply generically irrelevant. However, I am always up to the challenge and will answer as best I can.

First the easy part, benefits. Start by reviewing the following links:

http://www.microsoft.com/visualstudio/en-us/products/teamsystem/default.mspx

http://teamsystemrocks.com/

In particular check out the tutorials section on the Team System Rocks website. There are plenty of reasons for using Team foundation Server to be found there. The Microsoft site has a nice concise bullet list of the features.

I am a huge advocate of Team Foundation Server, it is a very solid product with a ton of great features that add to the entire application lifecycle management process. One of the key benefits is the interaction mechanism based on web services. Having the product built on a core set of web services for interaction with the server makes this product truly cross platform compatible and extremely extensible. Look at products like TeamPrise (www.teamprise.com) for java developers and the eclipse product as key evidence. I could easy go on about the benefits of Team System and Team Foundation Server but I think that there is plenty of information on that already.

I think a key thing though is to look at all of the features; source control is the obvious one, SharePoint and Reporting Services is fairly obvious, build system and work items require a bit more care, application lifecycle management, Excel, and Project integration are subtle and Team System Web Access should never be missed. But look at how it all works so well together!

Let’s move on to the risks.

First and foremost I believe that the biggest risk that I see with TFS adoption is failing to get adequate training with the product. Team Foundation Server is big. There is a lot going on within the product and it is a system. By that I mean the product is highly integrated and brings the entire application lifecycle together in a very meaningful and cohesive manner as long as you use it as it was intended. Understanding how workitems relate to code, which relate to source control (change sets) which relate to builds which feed test execution and tie to bugs which connect to unit tests which all feed the data warehouse that automatically feeds a bunch of reports can be a bit of a challenge!

Too many times I have seen organizations using TFS for nothing more than source control. This is a huge waste of a serious amount of functionality. Even still, with just source control, a risk that I encounter all too frequently is a lack of grasping how workspaces function. I feel that there should be better upfront, in your face, dialogs about workspaces when a new user connects to TFS using source control for the first time. Several times I have found users getting tripped up by workspace problems. Learn how they are defined and stored and the implications to getting code from the server to the workstation.

The next risk that I find very common is not understanding how the information for the reports is fed into the warehouse. Spend some time getting to understand where the information comes from. With that understanding comes the knowledge of what needs to be done during the process to be able to utilize the reports effectively. Also understanding exactly what the information in the reports represents is worth some time and effort.

Work items are too easy to modify! This risk shows up when a new team starts adding or changing fields to fit how they work without understanding the repercussions. Go at this carefully! This also ties back to the previous risk with the reports. Changing the work items by altering, adding or removing fields may easily invalidate a report or two (or three, or four). Many of these fields are required to drive the data in the provided reports, get an understanding of this before making changes!

Excel and Project integration are very useful! Create an excel spreadsheet that leverages the data from TFS and store that spreadsheet in the project portal. The spreadsheet is now reusable by anyone with access. The data can be refreshed and utilized on multiple sheets within the spreadsheet to drive all sorts of charts and graphs. The risk here is that these capabilities are underutilized.

I could probably keep going without too much trouble but you may see a common thread here. In a nutshell I feel that there are two primary risks with Team Foundation Server:

Inadequate training. This is a big product with a ton of features that requires a bit of understanding. I strongly encourage all teams to get some training on this product so that you can really leverage all that it has to offer.
Too easily customized. Early customization of the work items by teams that don’t fully understand how the system ties together has caused loss of functionality, especially with reports. Nothing worse than losing built-in functionality due to over eager customizations.

I hope that helps.

Tracking Progress in a Sprint with TFS

2009-02-03T11:48:00.000-08:00

One of the most common situations I encounter with clients and attendees at my presentations on using Team Foundation Server (TFS) for agile development is how to generate a burndown chart. In some ways there is already one provided in the Remaining Work report, granted it is not a true burndown as defined by the Scrum method but it does provide one view into the process. Throughout this post I will assume that the MSF for Agile Team template for TFS 2005/2008 is used.

The challenge with the Remaining Work report is that it aggregates at the work item count level rather than at any relative size measure. Let me explain using an example. Let’s say you have a project backlog that consists of 20 Scenarios and you filter the Remaining Work report by Scenario. Unless the Scenarios are of equal effort then the Remaining Work report does not necessarily give you a true sense of velocity. If the first 10 Scenarios are complete and half the duration of the project is consumed it would appear as though everything is on track. However, if the 10 Scenarios that were complete happened to be the 10 smallest ones, perhaps making up only 10% of the total effort, then the warm fuzzy feeling of having half the scenarios complete would be woefully misleading. One thing that you may notice is the Scenario work item type has a field named “Rough Order of Magnitude” which is intended to be used precisely for incorporating the sizing aspect. There are two challenges with this field as implemented. The first challenge is it is limited to 0,1,2, or 3 however these values can be changed by editing the work item type definition. The second challenge is the field is defined as a dimension type which means that it is more difficult to work with for aggregation purposes out of the data warehouse.

Given these challenges I am going to propose a different method that was proven quite successful and is easily done without modifying any work item types.

The first step is to utilize the Iteration field of work items to track the current sprint. Create an Iteration named “Current Sprint”. This iteration will always represent the current sprint in progress. You move work items in and out of this iteration during the sprint review and planning meetings. The work items assigned to the Current Sprint iteration always represent only those items that are currently planned for the sprint in progress. I will discuss managing this process in detail in a later post.

The second step is to use only Task work items to represent the work to be done in the sprint. During sprint planning the work to be done during the sprint should be identified and added to the Current Sprint iteration.

Assign each task a remaining work value. Although the task work item has this filed listed as hours there is no need to enter a value representing hours, if you use story points you can use those instead. You should now have the initial state of the sprint backlog represented as all of the tasks assigned to the Current Sprint iteration. The sum of the remaining work field is the start value of the burndown chart.

As work progresses throughout the sprint the values of the remaining work field should be updated with the new value as work on the task is complete. Providing the values are updated in a timely manner the current sum of the remaining work will represent the total remaining work for the sprint. You now have all the information you need for a burndown chart.

There are two ways of reporting on this information and both require a bit of extra work.

The first method is to run a query for all tasks filtered on Iteration Path for the Current Sprint. Using the TFS integration with Excel it is easy to sum the remaining work column. In fact the easiest way to do this is to save the spreadsheet with the query and summation in SharePoint and refresh the spreadsheet every day and log the sum of the remaining work. This is a very easy way to determine the daily value and plot it on a big chart on your burndown wall chart.

The second way is to create a burndown report in SQL Reporting Services and post it to the team project reporting site. Creating this report is very easy.

Create a new report project in Visual Studio using the wizard project type. Create a database connection named TfsOlapReportDS and connect to the Sql Server Analysis Server for your Team Foundation Server installation. Create a query by dragging the “Cumulative Remaining Work” from the measures (Work Item History) into the “levels and measures” window and the Date field from the dimensions into the “levels and measures” window. Add Iteration, Team Project and Date as parameters by dragging them into the dimensions window. Set the Date parameter to be Range (Inclusive). Be sure to check the parameters checkbox for each of these parameters. Choose the Tabular report type with Date as the group and Cumulative Remaining Work as the detail, this is essentially irrelevant as we will be creating a graphical representation of the data and removing the generated table anyway.

Once the report designer appears delete the table from the report and add Chart from the toolbox. Drag and drop the Date field from the dataset to the category section of the chart and the Cumulative_Remaining_Work field to the data section. Right click the chart and choose Chart Type -> Line -> Simple Line.

The steps described above assume some familiarity with creating custom reports using SQL Server Business Intelligence Development Studio (aka Visual Studio) and do not cover every little thing that needs to be done but should be sufficient if you have any experience creating custom reports.

Done.

Don’t get hung up on the label!

2009-01-30T10:11:00.000-08:00

This is the first of a series of posts that I am going to write that talk about how to use Team Foundation Server out of the box or with minimal modifications to match your methodology. This first post is going to focus on the power of labels.

This is a recurring theme that I can tend to harp on when I am talking to people about work items in Team Foundation Server (TFS). I believe that it is important for people to understand the flexibility available within the work item constructs that come with any given Team Foundation Server template and not to get hung up on what labels are applied to different things.

Assuming that you are using the MSF for Agile template to create a new project in TFS two of the core work item types that are created are the Scenario and the Task. The task is an easy one and everyone understands them well enough, however the Scenarios have caused some grief. I believe the reason is simply the name given to it. Not a lot of organizations that I have worked with use the term Scenario not do many of the agile practices. Immediately there is some confusion as to what a Scenario is meant to represent.

Organizations usually have a term that they use for identifying some chunk of functionality with a system under development such as Requirements Specification, Use Case, User Story and others. Whichever term you use to denote a functional specification for the system under development you can think of the Scenario work item type as analogous. This can be hard as names of things can carry a lot of subtle, and not so subtle, meaning with them and it can be a hard thing to associate different titles to things.

As an example, I often encounter organizations that are using Scrum as the project methodology in combination with User Stories for identifying and tracking requirements. In these situations each User Story becomes an entry on the product backlog that is used to track and drive the product development effort. It is a simple thing the assign the Scenario work item type from TFS to the exact same role as the User Story. One of the largest barriers to entry that I have found is simply the name given to the thing “but we have user stories, not scenarios”. If you can get your team to get past the name of the thing it can become much easier to use the work items as they are out of the box.

Presenting in an Agile Manner

2009-01-29T19:28:00.000-08:00

Last Tuesday (January 20th) I presented a full day seminar entitled Leveraging Visual Studio Team System to Enable Scrum. The event was a Microsoft hosted event at their offices in Portland. The first thing that I took away from the event is to not book an event for a Tuesday following a Monday holiday. The second thing that I took away was to not book an event for one of the most momentous inaugurations in American history. Sigh. The upside to the lower than hoped for attendance was high degree of interaction that a smaller group affords.

Although I thoroughly planned the days topics including scripted demonstrations, well at least as scripted as I get (bullet points of key steps), and an agenda with time values for each agenda item I was determined to be agile. Practice what we preach and all that. There was a certain level setting that needed to be done as it was a bit of a mixed experience crowd with some attendees being well practiced and certified Scrum Masters and others having never worked with Scrum at all. Likewise the experiences with Team Foundation Server and Visual Studio Team System were varied. Therefore I stayed with the plan for the first two topics, An Overview of Agile and Scrum and then and Introduction to Using Team Foundation Server.

From there I opened it up. I listed the balance of the planned topics on the whiteboard and asked for any other topics of interest within the constraints of the days overall theme. Once we had a backlog on the whiteboard I asked each attendee to select their top two topics of interest and based on the tally of votes that became the prioritization for the backlog. Each “sprint” consisted of the top two topics from the backlog after which we re-prioritized and ran another sprint of the newly prioritized backlog.

During one of the retrospectives between sprints we decided to allot each attendee two points that they could use to assign to the prioritization (one point per topic or two points to a single topic if they wished).

I really enjoyed this approach as it added some fun as well as practicality to the event while also trying to ensure that the audience (customer) received the highest value items first. Based on the feedback from the event this approach was well received and I am certainly encouraged to try it again given a full day event.

A New Year and new presentations

2009-01-09T08:26:00.000-08:00

Happy New Year!

Here we are in a new year with new goals and fresh objectives ahead of us. One of my goals this year was to kick of a series of seminars on SOA, SaaS and S+S. Naturally I should be including Cloud Computing in there as well but it all kinda leads to the same place despite not having the latest buzz term included.

So to begin the series I have scheduled a 2 hour presentation that I will be holding at the wonderful Living Room Theaters here in downtown Portland (http://www.livingroomtheaters.com/) for February 11 at 8:45.

I am particularly excited about this series because I believe that there is a lot to explore and share on the topics. I am hoping to have plenty of interaction and dialog as part of the experience. I hope to see you there.

F# for Scientists Book Club

2008-11-17T16:16:00.000-08:00

So here is full blown geekiness at its finest!

http://groups.google.com/group/f-for-scientists-book-club

This is a group that I am in with a few others that are interested in learning and harnessing the power of F#. Check it out!

Team Foundation Server Collaboration Deep Dive

2008-11-17T16:09:00.000-08:00

Next month I am presenting a free seminar on the collaboration features and capabilities provided by Team Foundation Server. The official blurb is below:

Online Business Systems would like to take you on a journey into the depths of Team Foundation Server beyond the usual sights and sounds. In this session we would like to discuss and demonstrate the features of Team Foundation Server that go beyond just source control.

Team Foundation Server is a full application lifecycle management tool that provides extensive project management and tracking capability. In this session we will examine how Team Foundation Server can be used for full collaborative application development.

During this event we will explain how the collaborative side of Team Foundation Server fits into the developer side of TFS and share the vision that Microsoft has for TFS as a tool for every stakeholder in a project.

The topics covered will include:

Requirements tracking and integration
Bug tracking and integration
Relating code and check-ins to requirements
Tracing bugs to the code that fixes it and the unit tests that prove it
Making the most of work items
Making the most of TFS Project Templates
Using TFS from Linux and Eclipse with Teamprise

Join me December 10 at 9:00 am at:
Microsoft Corporation
10260 SW Greenburg Rd
Suite 600
Portland, OR 97223
USA

Register: https://www.clicktoattend.com/invitation.aspx?code=133563

Published in Redmond Developer

2008-11-03T10:52:00.000-08:00

I'm all a tingle! One of my short articles has been published in the Redmond Developer Magazine. http://reddevnews.com/books/article.aspx?editorialsid=181

Windows Explorer from Visual Studio

2008-10-10T08:27:00.000-07:00

It's the simple things that bring the most pleasure sometimes. Like when the first person into the office makes the coffee.... :-)

Today it's browsing to the file system from within Visual Studio. I have no idea how many times I have needed to get to the files that Visual Studio either uses or creates from Windows Explorer. Often I need to copy an assembly to somewhere or I want to open the project file using notepad or maybe make a file folder or something. Whatever it happens to be I find that I need to work in the file system plenty. This has always been one of those moderately annoying things, especially when I haven't been paying that much attention to where I created my project.

I'm not even sure when this was introduced (it wasn't that long ago) but the good folks at Microsoft have made it much easier to deal with this in two significant locations. The first is from solution explorer. Simply right click on the solution, project, or folder icon within the solution explorer and you will see a "Open Folder in Windows Explorer" option.

The other place that this has been added is to Source Control Explorer. Right at the top of the details window we now get a hyperlink that opens the mapped location in Windows Explorer.

Like I said, it's the simple things that bring the most pleasure. I love these two little features. Now it's off to make the coffee...

Hosting a WCF Service Library in IIS

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

What does it take to host a service library in IIS? I have been asked this often enough that I thought that it was about time to contribute a post on it. It is actually extremely simple.

First, create your service library project and code up your service. I am assuming that you know how to do this. For my example I am simply going to use what comes out of the box when you create a new service library project in Visual Studio 2008. To follow along create a new service library project in Visual Studio 2008 and name it HostingServiceLibraryIIS.

Second, create an svc file (use text file as the type) in the project named whatever you like. I will name mine “sample.svc”. Add this single line to the top of the file:

where your class that holds your service implementation is listed in place of "HostingServiceLibraryIIS.Service1".

Third, add a configuration file to your project and name it web.config. Paste the contents of the "system.serviceModel" section from the App.config file that was included by default in the library project into the web.config file between the opening and closing "configuration" tags.

Fourth, create a new application in IIS and point it at the folder that contains your project files. Make sure that your project is building to the bin folder and not bin/Debug or bin/Release.

That’s it! You should now be able to browse to your svc file in IIS and see your service in action.

Creating Update Scripts with DataDude

2008-10-03T12:28:00.001-07:00

Often when developing an application there comes the need to create reference data that is stored in the database. This reference data is generally read-only with the occasional insert.

For my example I am going to use a database that supports a leasing application. The current production version of the application contains a table named LeaseType that is used to populated drop-down lists of the different lease types that are available. Currently the application supports two types of leases, “Long Term” and “Short Term”. A new requirement has been introduced that requires two new lease types, “Temporary” and “Extended”.

As the new features for the application are developed a script will need to be written that will insert the two new values into the database. It is possible that there are maintenance screens that are used to update this type of information but for the sake of example we will assume that in this case the data will be scripted with the scripts executed as part of the upgrade.

With Visual Studio Team System Database it is very easy to generate the insert scripts rather than writing them by hand.

A couple of assumptions are being made:

The developer has access to a copy of the production version of the database. I generally prefer to have a version of the production database available on a development server or on the develop workstation to use for testing and comparisons.
A Visual Studio Team System database project has been created.
The new values have been entered into the development database on the local developer workstation.

Rather than writing the insert script you can follow these steps to have it generated for you:

1. Select “New Data Comparison” from the Data -> Data Compare menu in Visual Studio

2. Select your development database as the source and the production version as the destination
3. Choose only the tables to which you have added values and select “Finish"

4. The DataCompare window opens showing you the differences between the two database tables

5. Select the “Export to Editor” button on the Data Compare toolbar

6. Presto, you have the scripts!

It’s not FitNesse but…

2008-10-02T11:26:00.000-07:00

Many Test Driven Developers (TDDers) are familiar with the Fit and FitNesse tools for testing. These tools bring a lot of value to the testing process, particularly in the ability to push testing to earlier in the development cycle. In particular, tools like FIT and FitNesse have the ability to move testing into the requirements elaboration stage before coding even begins. These tools are also able to put the test definitions into the hands of the business users, analysts and testers where they may more rightfully belong.

Fit and FitNesse have a bit of a learning curve and require a bit of infrastructure to setup. These are not huge problems and they add great value, don’t get me wrong, however Visual Studio also has the ability to perform “Fit-like” testing. The features that provide these capabilities in Visual Studio are part of the unit testing framework and are nowhere near as extensive as those provided by FitNesse. However, if you are looking to get something that provides the ability for an analyst or tester or business user to create test data as requirements that can be used by Visual Studio keep reading.

As part of the unit testing framework that Microsoft introduced with Visual Studio Team System 2005 Developer Edition and available in Visual Studio 2008 Professional Edition there is the ability to define data driven unit tests. These tests can leverage either a SQL Mobile database, Excel (csv file) or an xml file as the source of the test data. The easiest option is generally the Excel spreadsheet as this is the most familiar to all parties involved.

To begin we will create the ubiquitous Add method that is used in unit test examples.

public static int Add(int a, int b)
{
return a + b;
}

A unit test of this method looks like this:

[TestMethod()]
public void AddTest()
{
int a = 1;
int b = 2;
int expected = 3;
int actual;

actual = MyMath.Add(a, b);
Assert.AreEqual(expected, actual);
}

Writing this unit test is all well and good and validates one set of inputs but as we know, with real world code the methods that we test are never as trivial as my Add method and more variations of the input values need to be tested. In particular we need to ensure that boundary conditions are tested, values such as very large, very small and both positive and negative. A common approach to this is to copy and paste the unit test and change the values, however the data driven approach makes this much easier.

We will next convert the existing test into a data drive test.

Start by creating an Excel spreadsheet and placing it in the test project folder, save it in csv format. I named mine MathTestData.csv. I then created some test data as shown below:

Open the Test View window (Test -> Windows -> Test View) and select AddTest from the test list. With the AddTest selected open the properties window for the test. You should see something like the screenshot below.

By selecting the button with the ellipses in the Data Connection String input field you will be presented with the following window:

Select the CSV File option and click the next button, browse to where you saved the csv file and select it. Visual Studio reads the contents of the file and should present you with a view into the data.

As you can see it took the first row from my file and interpreted this as column names. Clicking Finish should result in a prompt to add the file into your project and add it as a deployment item. Your unit test is now decorated with two more attributes, one describing the data source for your test data and another indicating that you csv file should be a deployment item.

[
DataSource("Microsoft.VisualStudio.TestTools.DataSource.CSV",
"DataDirectory\\MathTestData.csv",
"MathTestData#csv",
DataAccessMethod.Sequential),
DeploymentItem("MathTestProject\\MathTestData.csv"),
TestMethod()
]

We can now alter our unit test to read values from the data source using the TestContext property

public void AddTest()
{
int a = int.Parse(TestContext.DataRow["a"].ToString());
int b = int.Parse(TestContext.DataRow["b"].ToString());
int expected = int.Parse(TestContext.DataRow["sum"].ToString());
int actual;

actual = MyMath.Add(a, b);
Assert.AreEqual(expected, actual);
}

When running the unit test now Visual Studio will iterate over each row in the data source executing the test for each. The test results will indicate success only if every row in the test data results in a passing test. If any row fails then the test is considered a failed test. For my simple example I added a row to my test data that supplies 3 for the value of “a”, -1 for the value of “b” and 6 for the “sum”. Obviously this will result in a failed test. Not because the code is wrong but rather the test data is faulty.

You will see that the Results indicates that 2/4 tests passed. This count is a bit misleading as there are three rows in my test data. The framework considers the one failing row as one failure and the test as a whole as the other failure. Double clicking on the failed test will open the test results window giving you a view into the results of each run.

Visual Studio automatically executes the rows in the test data file so that anytime more rows are added more tests are executed. Although this is a trivial example hopefully it demonstrates the potential. It is easy enough to represent property values of complex objects in the csv file as well as have multiple results being tested. The developer needs only to map the individual values into the individual properties of the objects under consideration. For example a row in the test data could contain as many columns as are required to represent a purchase order as well as the resulting values from submitting a purchase order. The potential is huge.

The real benefit of this is the ease in which a tester, business user or analyst can add and modify this test data using Excel. In fact, having the test data created in advance of the code for both the tests and the application will provide increased clarity and purpose for the developer moving towards a richer test first approach to application development.

In our approaches the test team has been crafting most of these spreadsheets and utilizing Visual Studio to check them in and out of source control to ensure that they are part of the automated test cycle. To support analysts and business users a method needs to be crafted that provides an easier means of accessing the file rather than source control while also ensuring that any changes are pushed to the project based instance of the file. Integration with SharePoint is the first option that springs to mind such that any changes to a SharePoint copy of the document is pushed to the source controlled copy using a plug-in. Sounds like a good CodePlex project….

Using this approach provides the very base level of functionality that FitNesse provides. As your team becomes increasingly comfortable with these techniques and realizes the value of pushing testing earlier and earlier in the cycle I strongly urge you to take a close look at FitNesse and the increased functionality that it provides. The learning curve is steeper but the capabilities far exceed what is available out of the box with Visual Studio.

wsHttpBinding and IIS Integrated Security

2008-09-18T08:05:00.000-07:00

There are two bindings provided with WCF for communicating SOAP over HTTP, basicHttpBinding and wsHttpBinding. BasicHttpBinding is used for communicating using the WS-I Basic Profile 1.1 (SOAP 1.1) while WsHttpBinding is used for SOAP 1.2 along with the more advanced protocols such as WS-Addressing.

SOAP 1.2 also defines a more robust security model for authentication than was available with the 1.1 version. However the difference between the two SOAP implementations influenced how Microsoft addresses how the two bindings are hosted in IIS. It is expected that if you are using wsHttpBinding and have advanced authentication requirements then you will be using the SOAP defined methods for providing that authentication as specified in WS-Security 1.1. Because of this WsHttpBinding is not supported when hosted in IIS with only Integrated Security enabled. You must have anonymous security enabled.

With BasicHttpBinding the service can be hosted in IIS without anonymous identity and with Integrated Security. Unfortunately this means that if you want to take advantage of some of the newer SOAP standards (like reliable messaging) then you will not be able to use integrated security in IIS for authentication and authorization.

If you are used to using Integrated Security with your web services then this newer model can be a bit of a pain point although in the name of interoperability it is a better model. However it would have been nice if you could have your cake and eat it too.

So, if you want to use the newer SOAP stuff and had been planning to use integrated security in IIS you will need to look into the new way of doing things. This isn't a bad thing as it does make your services more interoperable.

Parallel FX

2008-09-04T14:26:00.000-07:00

Tuesday was the local .NET User Group meeting (padnug.org). Nick Muhonen gave a great demonstration of the Parallel FX library from Microsoft. Included in the demo of using the library to execute parallel actions directly Nick also demonstrated the extensions to LINQ (aptly named PLINQ) for executing LINQ queries in parallel. (Isn't PLINQ a children's game...)

All in all it was very slick and super easy to achieve. Now naturally there was a constant caveat that Nick repeated several times and that was the requirement that the code that is being executed in parallel does not share state with any of the other code. This is, of course, one of the key components of multi-threaded application development. Once you start sharing state across threads there is no telling for sure what the end result might be or whether you may enter a race condition and end up in a deadlock situation. One difference of note that makes the Parallel FX stuff different than spinning up your own thread and waiting on an event is that the Parallel FX stuff blocked until all of its threads completed. If this is okay, and for complex calculations that you need to wait on maybe it is, you're fine, otherwise you may still need to handle threading yourself. So, essentially, it is a blocking multi-threading library. Wow, weird, eh?

This made me think of some of the fundamentals to F# that Microsoft is working on as well wherein the language is designed (as far as I know) to address some of those concerns by not having much of a concept of shared state between objects. Everything starts to become immutable in the same way as strings are today in Java and .NET.

Another interesting aspect that Nick brought up by way of his introduction was regarding processor speeds and how they have leveled off. In fact in some cases the actual speed of a processor in a computer today may be less than it was a few years ago. Multi-cores are now the way to go but unless your application can take advantage of a multi-core chip it may actually run slower than before.

So now that we are facing a world of multiple core computers rather than simply faster computers do we need to start to rethink how we right code? If F# shares little (if any) state between objects (and I really don't know enough about it to say) and yet still compiles to the same CLR as C# does can we not start to gain some of these benefits in other .NET languages (C# and VB) by using more static classes and singletons? Should we be considering passing new instances of our objects in and out of every method making everything available to parallel execution much more readily? I know what you're thinking, "Holy cow! My memory usage will go through the roof!" Maybe, maybe not, is the garbage collector running on it's own thread? Is it cleaning things up just as fast as we are disposing of them? (Well, not a single core machine for sure...)

As we move towards more service orientation and stateless services doesn't this fit the same model?

These are some of the considerations that have been jumbling around in my head since Nick's presentation. Interesting stuff that is going to require a bit of time and effort to determine the approaches that will work in our ever changing technical world.

Here's the address of the Parallel FX team's blog: http://blogs.msdn.com/pfxteam/

VS Extensibility Developer Conference

2008-07-10T13:27:00.000-07:00

How sweet of a deal is the Visual Studio Extensibility Developer Conference at only $100.00? Very sweet I say.

This looks to be one of the best deals available to the general public that I have ever run across. It's almost on par with Code Camps, which are only better because they are completely free.

The topic line up looks really good with coverage of all of the VSTS skus including Team Foundation Server. I haven't been to one of these events before but I have been to a few of the small MS conferences held at their conference center and they certainly know how to put on a good event. The center is a very nice venue and since it is located on the Redmond campus there are always lots of access opportunities to the product teams.

See ya there.

TFS SDK Samples

2008-07-09T13:29:00.000-07:00

Brian Harry just posted about a new set of TFS Extensibility samples that his team is putting together. I just downloaded them and took a quick run through to check them out.

It is a nice concise set of samples that demonstrate techniques for plugging into the Visual Studio TFS source control experience.

Check them it out here.

SOA and Systems of Record

2008-06-17T06:42:00.000-07:00

I have written another short paper that discussing service orientation and systems of record. The approach in the paper discusses the needs of an application that may be considered the "single source of the truth" for a set of data and therefore should be considered the owner of that data. But what happens when there is more than one owner of a set of data given a different business context?

How do you develop an application to act as one of many systems of record while ensuring that all systems get the latest updates?

These are the concerns that I address in the paper entitled "Service Orientation and Systems of Record". You can download it here.

Keeping Database Lookup tables and enumerations in sync

2008-06-12T16:34:00.000-07:00

A common challenge encountered when developing applications is the synchronization between enumerated values in the codebase and static lookup table values in a database. This is an old problem that no good solution has been brought to light that I have found.

Today I was working on yet another implementation of this. I needed to create a lookup table in the database that contained the values for industry sector types. The entries in the table in the database each had a key and description. Within the code there was a matching enumeration where the numeric value of the enumeration matches the key value in the database. My concern is always about maintaining the two of them together, it is far too easy to update one without updating the other.

To try and alleviate this I used a unit test to keep them equal, at least in the most simplistic sense.

I used the Enum.GetValues(typeof(MyEnum)).GetLength(0); method to retrieve the number of values in the enumeration and then a COUNT(*) query on the table. Comparing the two results confirms that there are at least the same number of values in both the enumeration and the database. If an entry is added to either without the other then the unit test will fail.

This is a very simple solution that makes a rudimentary check, probably good enough for many situations and certainly better than not having a test at all. It wouldn't be too much more work to actually iterate over the values from each to ensure that the keys are a match as well. In our case though the descriptive field in the database is not quite the same as the string value of the enumeration so we can't take it any further.

If anyone has any other suggestions or experiences with keeping database lookup table values in sync with enumerated values I would love to hear them.

Data Dude Data Generation Plans

2008-06-11T18:51:00.000-07:00

Recently I added a new table to a database along with a new column in an existing table which was a foreign key to the new table. This led to the needed to update a few stored procedures as well as create a couple of new ones as well.

I created the procedures and started developing the database unit tests using the new database unit testing capabilities available with the Visual Studio Team System for Database Professionals. To support the unit tests I needed to create some test data. I created a new data generation plan and selected a couple of simple tables to populate. When I attempted to run the data generation plan I ran into the following error: “An error occurred while generating data and the operation has been terminated. See the Error List window for information.” Here’s what the Error List window had to say:

So I started digging. The tables that I was trying to generate data for were “ProvinceState” and “CountryInfo”. The “ProvinceState” table contains a listing of provinces and states within North America and the “CountryInfo” table contains data about countries in North America. The “ProvinceState” table also has a foreign key to the “CountryInfo” table. This is a very simple tables and relationship, with no other foreign keys in either table.

When I ran the data generation plan I choose to delete all the existing data from the tables.

This is actually where the problem arose as I will explain in a bit. After the failure the data generation plan placed red x’s in the status column for four other tables. I then set the “rows to insert” value for each of these tables to “0” and selected them as part of the data generation plan. Running the plan again produced slightly different results. For each of the tables that had a red x in the status column I now had an error in the Error List window.

This was much more helpful, however I was left scratching my head a bit as to why these tables had errors when I wasn’t trying to generate any data in them. I came up with an idea and ran the data generation plan again except this time I selected not to delete the existing data. Success!

The problem was with the attempt to delete existing data. When I asked Visual Studio to clear the contents of the selected tables it performed a recursive search through all tables that had foreign keys to the ProvinceState and CountryInfo tables. For each table that had a reference to either ProvinceState or CountryInfo it recursed to find any tables that had references to that set of tables and so on until it ran into a circular reference among the four tables identified with the red x’s. Despite the fact that none of the identified tables had any data to delete, they were already empty, the failure still occurs because the relationship search is performed at the schema level in order to build the execution order correctly.

So this means that there are two options that leap to mind. First, create static data to populate the tables using a script. In my case this is acceptable since both tables contain static lookup data anyway, however this may not work in all cases. The other option is to continue to add generated data each time without clearing the tables. The latter comes with obvious problems concerning columns with constraints and lack of repeatability.

Another concern that this raises is with the database design. Perhaps there are better ways of designing the database to avoid the circular relationship (perhaps not) but I’m also not interested in designing a database schema just to support a tool. That’s just no right in my book.

Perhaps I will pursue this further, perhaps not. In the mean time I’m off to write a script to populate my tables with static data as part of the deploy.

Service Orientation vs Object Orientation

2008-06-10T15:37:00.000-07:00

I have just written a whitepaper discussing some of the challenges when trying to reconcile object oriented code against services developed to support a service oriented architecture. These two concepts do not mesh well, the purposes of the two do not align well as they each aim to support different goals.

Download the paper from my skydrive here.

Careful with those Burndown Charts Eugene

2008-06-06T08:38:00.000-07:00

Tracking the progress of a project using a burndown chart is an easy, visual means of communicating whether a project is tracking towards targeted completion or not. The total amount of effort is tracked against a target delivery date. The effort can be in days, hours, story points or any other unit that makes sense.

As work is performed the remaining effort is updated on a regular basis (daily, weekly or at the end of an iteration). A perfect burndown would indicate that the work is being completed exactly as estimated and all work will be completed on the targeted completion date as indicated in the following diagram.

The amount of effort is represented on the y axis and time is represented on the x axis with x representing the target delivery date and y representing the initial estimated effort.
For this example we will assume that updates to the burndown chart are made at the end each iteration. At the end of the first iteration the work completed tracks perfectly against the estimates. At the end of the second iteration the amount of effort remaining increases from the previous iteration. This can occur for a couple of reasons

Additional work has been identified and has been added to the total backlog of effort
Initial estimates were wrong and the remaining effort has been re-estimated

For our example we will assume the former. The product owner has identified additional functionality and has added it to the product backlog. This causes the total remaining effort to increase from the prior iteration. At the end of the third iteration the remaining effort has decreased at an increased rate over the first iteration. The burndown chart looks like the following diagram with the dashed line representing the estimated completion date.

This chart indicates that the project will not complete until well beyond the target date. What is not shown in this chart is the reason for the slip. In the example that we are working with the reason is due to additional requirements added to the project. However, our burndown chart is wrong. What the burndown chart in diagram B is indicating is the amount of effort remaining at the end of each iteration given the initial scope of work. That is to say given the amount of effort identified by “y” how much work is remaining but the fallacy arises due to the additional scope that was added during the second iteration.

An accurate representation of the burndown is shown below.

The additional scope is represented by the distance from “y” to “z” on the y axis. If the amount of effort remaining is the final point on the burndown then the actual slope of the dashed line should begin at “z” not “y”. This results in a more favourable looking burndown chart that actually indicates that the project is still tracking to the original completion date despite the additional scope.

Of course the opposite condition has just as dramatic effect. If the team does not look like they are going to meet the target date and some of the scope is removed from the project (and assuming that we do not remove scope from the completed work) then the slope may very well look like the chart below.

This chart would indicate the amount of effort remaining after the last iteration based on a revised scope of “z”. The project is still in trouble and the real indicators are that the velocity of the team is actually much slower then is indicated.

In either case it is important to ensure that after adjusting the scope of a project that the projected completion date line is re-adjusted to track from the new scope against a revised “estimate to complete” point on the graph as shown in figures C and D above. Care must be taken to accurately track burndown against changing scope.

BizTalk Expert Training

2008-06-04T07:04:00.000-07:00

I just got an email from Ginny at QuickLearn. They just announced a new series of BizTalk Expert training. These are focused 2-3 day courses that deal with a single facet of BizTalk such as EDI, BAM and BRE.

I have heard very favourable things about their offerings and am quite excited about these new focused offerings. Check them out here.

TFS 08 Build

2008-06-04T06:58:00.000-07:00

While configuring the build server at a client today I ran across an error when executing the unit tests. The build result was a partial success with an indicator that there was a failure with the tests.

Looking at the log showed that all of the unit tests passed successfully but there was a permission failure when the server tried to record the test results to the file drop. The thing to note here is that the server that is actually responding with the test results data file is the TFS server itself and not the build server. This means that you need to grant permissions for the TFS server identity to write files to your file drop share.

With this particular client we are using a different identity for the build server than we are for the TFS server. It was a minor hiccup that caused a wee bit of head scratching but didn't take too long to figure out.

Agile Development with VSTS - Workshop

2008-05-14T20:59:00.000-07:00

Today I presented at Online Business Systems "Agile Development with VSTS/TFS" workshop that was held at the Governor Hotel in lovely downtown Portland. The event was attended by several senior IT folks from the area, we had a great lunch and I was able to talk to these folks about Agile development, Visual Studio Team System and Value Up software development practices.

Naturally being the good developer that I am I opted for reuse over re-invention and did a bit of a mashup of slide decks from the likes of Sam Gukenheimer and Clementino de Mendonça both of Microsoft Corporation. These guys craft great slide decks and I suspect have a decent graphic department behind them.

We had the pleasure of having our senior usability consultant, Kevin Higgs, from the Online office in Calgary come down to talk to us about innovation techniques for developing software as well as the great honor of having Andrew Kass the former General Manager of the Visual Studio Team System team come down and talk to us about the vision that Microsoft has for developing this tool set. Andrew informed us that he has recently moved on to work in the competitive strategies group at Microsoft. This sounds like a great position with plenty of excitement and challenges. I am sure Andrew is up for it.

I have posted a copy of my (well really Sam and Clementino's) slides to my sky drive. You can get a copy of them here.

I sincerely want to thank everyone for attending and I hope you had an entertaining time.

Team System 2008 Licensing

2008-05-13T14:13:00.000-07:00

New info on Visual Studio Team System 2008 licensing has appeared! it is a confusing thing that causes pain all over the place. To address this pain Microsoft was put together a paper explaining the entire thing. How difficult could it really be, right? Well I will let you download the document and see for yourself but just so you know it does take 13 pages to explain it. :-)

Get it here. And read Jeff Beehler's blog post here.

Product Backlog

2008-05-10T10:55:00.000-07:00

I am an advocate of Scrum based project management, I have used it successfully on several projects and I believe that if it is used well by people that understand its principles as well as its intentions and mechanics it can bring much value to a project. As with any methodology there are concepts that can be difficult to deliver on if the are not well understood. Product backlogs are easily one of those things. I aim to help bring some clarity to the concept in this post.

One way that I hope to bring clarity is by avoiding all references to building software. Scrum can just as easily be applied to many other project based endeavours and I hope that a non-software based approach will help bring the ideas home.

So let's use an example of building a house. I have decided that I want to build a new house and my wife and I have come up with a huge list of features that we want our house to have, things like 3 bedrooms, a kitchen, a garage, a gold bathtub, gas range, elevator to the third floor, sauna, hot tub in each bedroom, etc. You can see that some of the items on the list may be more important to us than some of the others. Hmmm, perhaps a roof may be more important than the elevator... We also have some constraints on what we are willing to invest. We have a price cap that we are not willing to exceed as well as an end date by when the house must be complete.

So the first thing that we do is determine the order of priority for the features we are looking for. Walls, rooms, roof are all very high on the list with elevators, hot tubs and exotic hardwood flooring somewhat lower on our list. The builders look at our list and we agree to a time and a price. Construction begins.

As the contractors are preparing the land to pour the foundation they discover that the soil does not drain as well as the initial samples had led us to believe and so they recommend that we do some additional work preparing the site for good drainage. Since we live in the Pacific Northwest we agree that good drainage is a high priority and ask that they perform that work. Naturally this will impact our product backlog of features. We have added a feature and asked that it be prioritized rather highly. This impacts our project in a couple of potential ways. To get everything that we initially asked for as well as better drainage it will cost us more money, also depending on whether the contractor has enough resources to add to the project it may also push out the timeline of completion. A further example of altering the priority comes when it is time to purchase the flooring materials.

This is just a single example of things that can change as the project progresses. Perhaps after a couple of months of construction a new high efficiency furnace in introduced to the market and we wish to take advantage of it. This will impact both some of the design of the home as well as the costs and timelines. It is up to me and my wife to determine how we want to prioritize this work in relation to all the factors.

As you can see it is not only software that can take advantage of agile project managements techniques. As we progress through the project our ideas on what is important may change as well as when we wish to get things done. Once we have the basic house that is livable we can ask the contractors to stop working at any time, maybe leaving the garage unfinished for now is okay and I will get the wiring and insulation for a fancy woodworking shop in a couple of years as those things were lower on my priority because that elevator is way cool!

A well run product backlog is a changing flexible thing. In my example my wife and I meet with the contractor every month and agree to the priorities of the backlog as well as what features his team will work on for the next month. There needs to be a flexibility with both parties to be able to accomplish this, key to this working successfully is trust and understanding in the process. In the end I may not end up with what I initially asked for but I do end up with what I want. If I choose to end the project when my budget is consumed (the initial agreed upon amount of the contract) but before I have everything that I want then so be it. That is my call as the home owner. If the contractor did good work and was trustworthy and worked with me as I changed my mind then I will be that much more enticed to use that same contractor to continue working on my backlog on a future project. We all win.

This can be a challenging mindset for both customers and contractors and requires trust, understanding and constant collaboration and communication!

So you're bought in to the idea and you wonder how it fits with software development and how what tooling is required to make it successful? Well stay tuned and in a future post I will take this example and implement it using Team Foundation Server to run a successful Scrum based home construction project. Maybe you'll even see how it fits into a software project.

Connected Systems Division - Software Design Review

2008-05-10T10:38:00.000-07:00

I had the great honour of spending the majority of last week in Redmond with folks from the Connected System Division, those would be the BizTalk, WCF, WF, type of folks. I was one of fifty attendees that were invited to hear about the latest and greatest that the good folks in Redmond are working on to help make our connected world a better place. The event included a lot of open dialog between very influential people, I was quite pleased to be in such notable company.

During one of the keynotes a funny thing happened, let me set the stage a bit. Don Box and Chris Anderson were giving a talk and demonstration about some new ideas that they are working on. We were gathered in a decent sized lecture theater. Up front was a lectern with the MS logo spelled out in brushed steel letters on the front. As Don is explaining a concept to us the lower binding of the second letter "o" in Microsoft came loose and swung down colliding with the "f" making that very cool metal on metal noise that movies use to represent sword blades sliding against each other. Naturally the crowd started to snicker and Don and Chris looked up wondering what we were all laughing about because neither of them could see the logo. Don being the good sport came out and fixed the logo amongst questions regarding the fore-shadowing of the event! As this is all happening me and the fellow beside me are scrambling for our cameras. Alas, Don was to quick for us and had it fixed before we could snap a photo.

So that was a fun start to the event. The rest of the event was full of interesting lectures discussions and working through labs of the new Oslo bits. Microsoft has put in a lot of effort and thought into the direction that they are taking things are there is a lot to be excited about in the coming months and years. Unfortunately this is still hush-hush but they promised to make it all public at PDC this fall. What I can say is that there will be plenty of very interesting things to hear about at PDC and it should be an exciting event.

Team Foundation Server Custom Policy

2008-04-20T21:46:00.000-07:00

Custom check-in policies for team foundation server are very simple to author. I wrote a quick one the other day and thought that I would share it here. On one project that I had been working on we had a bit of a problem when a sql script file was checked into our repository with "GO" being the last command in the file. You see we were automating the execution of the sql scripts in a batch processes during a deployment and if any script was missing the "GO" statement then we would encounter errors deploying the database scripts and it would take a while to track down.

Well after running into this a few times I thought that a policy that enforced that there were two little letters that comprised the entire last line of any sql file would help with this. So I created a policy to check for "GO". It's quite simple and you can download it here:

http://cid-3ab375fd781e1f47.skydrive.live.com/self.aspx/CodeSamples/SqlScriptPolicy.zip

Enjoy.

Great article on Scaling

2008-04-16T07:51:00.001-07:00

I just finished reading an excellent article on scalability written by Udi Dahan and posted on InfoQ. Udi describes a real world scenario in which scaling and performance were considered from the very start and the system was tested for scale and worked well. Once the application went live and the real world inserted its ever nasty head into the equation things went seriously wrong.

This article is a a great read with excellent advise and insight into what can go wrong and what things need to be considered. Go read it now: http://www.infoq.com/articles/scale-with-service-contracts

New Rosario CTP Coming Soon

2008-04-09T14:45:00.000-07:00

Word has it that a new Rosario CTP will be released soon. This month I hope. The currently available CTP was released last November and I am anxious to see the progress that was made.

Although Microsoft has indicated that the mini-stories required a fair amount of effort to put together I am hopeful that enough of us have indicated their value that the powers that be will continue to include them with the upcoming releases.

On request that I made was to have Project Server installed as part of the VPC that they put together. I suspect that it is a bit late in the game for this upcoming release but it would be nice to see it appear in future images. This is one area that I ssupect could use a bit more attention than it has seen in the past.

With a little luck I will have some opportunities to spend some time working on that integration point in the near future.

Visual Studio 2008 SP1 News

2008-04-06T11:31:00.000-07:00

Attending the Visual Studio Team System chat today I learned of a couple of very cool features coming to the debugging scene with SP1 for Visual Studio 08.

On the context menu you will have the ability to skip properties during the debug session without needing to add the attribute , they are also adding an option to jump to a point to begin debugging. Granted this was all gleaned from a chat and I may have some of the intent off by a bit but it should be reasonably close.

Unfortunately no one on the chat was willing to give a time frame for SP1 and Jeff Beehler was there so if anyone has an idea I would expect he would be one of them but he was keeping quiet.

So keep an eye out for SP1 there are a least two things in it that I'll be looking forward to.

Visual Studio Team System Chat -April 9

2008-03-20T21:03:00.000-07:00

I met Charles (Chuck) Sterling earlier this week while at the VSTS Inner Circle airlift in Bellevue. He is a very interesting man and I'm sure he will liven up the Chat greatly. check out his posting here: http://blogs.msdn.com/charles_sterling/archive/2008/03/21/visual-studio-team-system-chat-april-9.aspx

Time Tracking from Team System Data

2008-03-20T20:58:00.000-07:00

One request that I have had from customers is to use work items for time tracking. Often when new project managers see the work remaining coupled with the work completed fields on the Task work item type they feel that it is a prime candidate for time tracking.

There are a couple of reasons why I try and discourage this:

Tasks were not designed to be used as time tracking mechanisms. The goal is quite different. A task has a workflow associated with it that really should include flowing from one user to another as the state of the task progresses. Time tracking is generally associated with a single user.
Work completed is a cumulative value that is not designed to be associated with a particular date as time tracking generally must be.
Although the information is contained within the warehouse it isn’t designed to be retrieved in a person-date-time entered manner.
A separate record must be kept somewhere if you need to determine how much effort was spent on a particular date or a custom report needs to be developed.
Leave workflow and task tracking in one system and time tracking in another. Hours spent on any given day for a specific task is generally not useful information unless you are billing.

Oh, but I am billing you say! That is exactly what the managers that have asked for this feature are doing as well. Okay, so maybe that is a bit of an exception, however I don’t feel that it is neither a particularly reasonable exception nor a particularly strong one to go about breaking the intent of Tasks.

Despite my misgivings I do try and be a helpful person. That is when I’m not grousing about the perversion of the tool.

So here’s my thought. I am going to build a helpful service that tracks work item changes to provide time tracking information. The outline of the solution will go like this:

Subscribe to every work item change for work items of type Task
Extract the new and original values for time completed
If the values have changed the extract the assigned to user
Using a provider pattern load a time recording module
Submit the assigned to user value and the delta value between the new and original time completed values to the time recording module.

The design of the time recording modules would go like this:

Time recording modules would be based on the ITimeRecording interface
A method would be provided on the interface that accepts the pertinent data
Each module that implements the interface would be specific to the target time tracking system.
Once the module received the time tracking information from the Task it would submit it to the target system.

Currently I am planning on implementing a module that submits to an xml file with a configurable location.

Inner Circle Airlift

2008-03-16T19:48:00.000-07:00

It's been a while since I've blogged and I needed to make a bit of an effort to get back to it. It's not that I don't have anything to say it's just a matter of getting to it.

Well I just arrived in rainy Bellevue, Washington for a Visual Studio Team System Airlift. I was told when I checked in that I was the first American to check in for the event so far. Everyone else was from another country. That's cool, it's always great to meet and mingle with people from all over the world, you can get such an interesting perspective on things.

So what's an airlift you might be asking? Well it's an invitation only event that Microsoft hosts for clients and partners to help them understand certain technologies to a deep technical depth. For the next three days we will be diving into VSTS. Since we have actually been using the 2008 version for a while now I am hoping that we will gain some fresh insights into Rosario (http://msdn2.microsoft.com/en-us/teamsystem/bb725993.aspx). Even if the content is restricted to 2008 I am sure that I will pick up on a few nuggets of value.

On a slightly different tangent I just downloaded and installed the Web Service Software Factory Modeling edition (http://msdn2.microsoft.com/en-us/library/bb931187.aspx). It looks very slick, it brings the modelling aspects to Visual Studio that I thought were lacking with the 2008 release. I was disappointed to see that you could still only model asmx services with VS08 despite the inclusion of .NET 3.5, I mean really now, WCF was out with .NET 3.0! Where's the tool support? Maybe I will have some answers for that this week...

Orchestration Designer crashes Visual Studio

2008-01-21T18:31:00.000-08:00

Off and on over the years I have encountered a problem when working on BizTalk 2006 Orchestrations in Visual Studio 2005. Whenever an orchestration is opened in Visual Studio it causes Studio to crash. Instantly. Irrevocably.

I ran into this problem again recently and it wouldn't stop. Every single time I opened an orchestration Visual Studio would simply vanish. No "report this problem" option, no "your program has encountered a problem", not even a blue screen of death for old times sake. Nothing, simply gone.

Previously I had dealt with the occasional crash as part of the way it was but this time it wouldn't stop which meant I couldn't progress at any pace.

Solution? Delete my profile. Yup, as simple as that. Thanks to MS tech support for pointing that one out. I logged on as another admin user, deleted my profile, logged back on as me and the problem was gone.

.NET 3.5 Breaking Change

2007-12-24T08:00:00.001-08:00

We had been using Paul Stovell's very nice and simple implementation of an error provider for WPF (http://www.codeproject.com/KB/WPF/wpfErrorProvider.aspx) when we installed Visual Studio 2008 (VS 08). We went with a side-by-side install with the plan that the development team would install VS 08 as they had time and as soon as everyone had it installed we would switch our project over.

This meant that some developers had VS 08 installed while others did not, therefore the early installers kept working on the code base in VS 05. No worries. Well actually there was one. The error provided quit working correctly! Rather than highlighting the textbox with the error in red and providing the error message right away it would wait until you had moved on past two more controls. In other words it was a control behind! If control one had an error and you moved to control two and it had an error and you moved to control three at that point would control one display the error! Egad!

What we found was that Microsoft recognized the deficiency that they had left in WPF 3.0 and provided the error provider capabilities in 3.5 (I suspect it was simply one of those features that didn't make it in time for 3.0 RTM). The problem is that they broke Paul's implementation.

It was an easy enough fix, we simply switched to using the 3.5 built in version, not a big deal but it did make us think a bit. So I tried to set our config file to target the 3.0 framework explicitly so that we could continue to use Paul's implementation but I couldn't get it to work. The reason we tried this was to avoid any end-user upgrade surprises in the future. You see, if we had stayed with VS 05 for this application and delivered to the client then at some point in the future when 3.5 got installed on their machines the application would have stopped working correctly. This scared us so we tried framework targeting in the config file. No luck. This leaves us a little scared!

Happy holidays everyone!

Visual Studio Team System Inner Circle

2007-12-06T21:49:00.001-08:00

I was very pleased to be nominated and accepted into the Inner Circle for Visual Studio Team System (https://www.vstsinnercircle.com) the other day. This is a real exciting opportunity that me and the rest of the MS-oriented folks at Online Business Systems are jazzed about.

We were recognized for the evangelizing that I have been doing as well as our years of Gold Partnership and dedication to the Microsoft platform. I am looking forward to diving deeper into the program and becoming increasing proficient with Visual Studio Team System.

As part of the program we will be expected to assist Microsoft with further evangelizing the product and helping clients and customers understand and implement VSTS and TFS to best take advantage of everything it has to offer.

If any of you have seen me present on TFS in the past you know that I am a real fan of the product but like any product of this size it takes a bit to really understand how it was meant to be used and how it was not. Getting around some of its limitations while taking advantage of its strengths are what make it both challenging and exciting.

Rosario Features

2007-12-06T21:20:00.001-08:00

I was on the Visual Studio chat the other day and one of the Microsoft folks asked if anyone in the crowd had been poking at Rosario (http://msdn2.microsoft.com/en-us/teamsystem/bb725993.aspx). Since I have been playing around with it a bit I mentioned I had. Naturally this lead to a bit of a discussion which I finally am getting around to para-phrasing here.

So the first thing that I looked at was the Architect goodies that they've added. Now I really like the enhancements that MS put into Visual Studio 2008 (VS08) but I was a bit disappointed that I still couldn't model WCF services. Well it's all there in Rosario. It is sweet! I can now create the skeleton of a nice structured WCF based architecture with method signatures, the full ABCs (Address, Binding, Contract) in a modelling tool. code gen it and we're off to the races. That's where I want the Architect tools to be at!

Next I moved on to the TFS tools cuz I have always been a huge fan of TFS and love what the team is doing with those bits. So I'm looking at the sample Agile project and it's work items and all I can say is WOW! This is a major overhaul. They have renamed things and the language is much more aligned with typical agile language. I will be so glad when I can stop saying "Well, Scenario's are really just User Stories so just think of them that way". Now I can just call them Stories. That's cool but the reports have been completely reworked and are also a much better agile fit. Oh, and they've added these cool new dashboards to Sharepoint. I know that the dashboards are real early workings and don't have much meat to them yet but what a nice addition. I hope that have the cycles to finish them off. Oh, and the work item hierarchies! Love them!

After TFS I took a peak at the WiX project. Not much there yet really. I can see where they're heading but until they make it much more graphical I will still want to push that stuff off to someone else on my team. Sorry, dude but getting down and dirty with the WiX xml just doesn't work for me...

So, back to the VS chat. The MS Expert must be part of the Test edition team cuz he was asking me about that stuff. Unfortunately I hadn't gotten to it yet. So tonight I started looking at it and all I can say is "way cool guys"! There's this stand alone tool that they've put together called Camano that gives a great, concise workspace for testers. Build your tests, lists, group them, schedule them, all that great stuff and then execute them. Now I'm not talking about unit tests here, nor automated tests, but rather manual tests. But when you go to run them you click the fancy record link, go about your test, fill in results, file bugs, append to bugs, and complete your test. Then go check out the bug in Team Explorer. I dare ya. You'll love it. There is this tab named "Repro Steps" that has a full list of everything I did, with times and full video! Nice!

How the stand alone tool is going to fit into the package will be interesting to see but it was slick.

So now tomorrow I have to go back to work and "suffer" with VS08. ;-)

VS 2008 - initial comments

2007-11-25T11:06:00.000-08:00

So now that it has been released and I have had a chance to play with the RTM version for a wee bit I have a few observations and comments to make.

The first being that it did indeed install! this was a huge relief, I had tried to install the Beta 2 with no luck. I hadn't given up easily either, trying to remove the nasty hotfixes and manually installing certain bits, all to no avail. Fortunately the RTM installed just fine beside my 2005 install on my Vista machine.

As has been mentioned in a few other blogs, as well as on MS newsgroups, BizTalk is not supported on VS 2008. This is quite disappointing. The word is that it is up to the BTS team to release a service pack to enable BizTalk projects on 2008. I mean , come on, did this release of Visual Studio come as a surprise to the BizTalk team? To make working with many of the .NET 3.0 features really productive (especially WPF) I will be moving to VS 2008 as soon as possible however I need to maintain a 2005 install for the BizTalk projects. Hopefully the service pack is not far behind, although there has not been any official word yet.

One of the other things that I tried out that was a bit of a disappointment was the lack of WCF support in the architecture tooling. I was really expecting to have full .NET 3.0 integration into this release, which in my mind includes the ability to model out WCF services not just asmx services in the Architect edition.

I tested out the Team Foundation Support between 2005 and 2008 in a few configurations and am very happy with how it all fell together. The scenarios that I tried out were:
1. VS 2008 against TFS 2005. This worked very well. I tried out a few simple scenarios and everything worked as I would expect it to. So this means that you can upgrade the developer tooling while leaving the existing TFS in place.
2. VS 2005 against TFS 2008. This also worked well. I made no changes to a previous VS 2005 install other than pointing it to the TFS 08 server. It worked perfectly as well.
3. Upgrade and existing TFS 05 install to 08. This also worked well. I did have some custom templates and work items in the 05 version which moved seamlessly over to the 08 version.
4. Builds. The builds capabilities in 08 are much more extensive than what was available in 05. A very welcome addition which includes continuous integration as well as monitoring, queueing and other features. However if you are running VS 08 against an 05 TFS you simply get a 404 error when trying to work with the builds. This makes any builds that were created with 05 unavailable with 08. Now even if you weren't truly enamoured with the 05 build capabilities the fact that they are now completely lost is even less attractive. Such is progress....

One thing to keep in mind is that VS 2005 requires the TFS 05 version of the Team Explorer while S 08 requires the 08 version of Team Explorer. The Team Explorer is tied to the Visual Studio version not the Team Foundation Server version. Hence the build problems mentioned above.

All in all I am welcoming VS 08 with welcome arms and eagerness.

I welcome your feedback and I will continue to share my thoughts here.

Method Overriding

2007-11-17T14:28:00.000-08:00

Confusion often reigns when a developer new to .NET encounters the world inhabited by the C# method related keywords "new", "override" and "virtual" when working with inheritance. To help explain how these words all relate to each other and the impact that they can have I put together a very simple example demonstrating things.

The structure of the code is quite simple and you can see it at the end of this post. The purpose is to demonstrate how methods are resolved at runtime.

I have created an abstract class that contains a single abstract method call Action. Action takes no arguments and returns void. It simply writes to the console window the name of the class and the name of the method. A concrete class inherits from the abstract class and implements the Action method. Two other concrete classes inherit from the first concrete class, both of them contain an Action method, however one of them uses the "override" keyword while the other uses the "new" keyword. The differing behaviour when using variables of the abstract class is where the confusion often comes in.

These problems are most likely to be encountered when there is a minimally or greater inheritance structure in place and polymorphism is used. Another sample is also provided that demonstrates inheriting from a concrete class that contains a non-virtual method and a virtual method where the inheriting class uses "new" on the non-virtual method and a varialbe of the base class type is assigned an instance of the inheriting class.

To the right is a graphical representation of the in memory representation of these scenarios. It is important to note that the classes that implement a method using the "new" keyword contain, not only the implementation as was implemented in that class but also the implementation of the base class.

The code can be downloaded here: http://cid-3ab375fd781e1f47.skydrive.live.com/self.aspx/CodeSamples/MethodOverriding.zip

Continuous Integration with TFS 2008

2007-11-13T21:36:00.000-08:00

Continuous Integration was conspicuosly missing from the first release of Team Foundation Server. Microsoft got slagged a fair bit for this, perhaps rightfully so. I have been using CruiseControl.NET to perform my CI against TFS 2005 for almost two years now and it has worked just fine. this has always been a fabulous tool and should be a stable in most every developers toolset by now.

I recently had the chance to try out the CI that comes as part of TFS 2008. It was very easy to configure and ran very nicely. I really like the ability to configure a build from within Team Explorer rather than having to head out to my build server to do it. However, the lack of a tray icon is still a sad thing. I know that they wanted to add it but ran out of time. I certainly understand that dilemma. However for those of you that feel that this may be a deal breaker and simply can't live without it then you will have to get the power tool version that is available.

It works very well and now makes me very happy with the TFS build offering.

A couple of things that don't seem to be working for me are the links to the associated changesets and work items as part of the build report. Both of these were empty despite having both a changeset and a work item associated with the build. Perhaps a mis-configuration on my part. We'll see.

SOA & BPM Conference PostMortem

2007-11-04T19:33:00.000-08:00

Well, the conference is over and I'm back home. I took the train back from Seattle to Portland, it's nice to see the train being utilized as much as it is. It was packed, they had to overflow people into the dining car. I was just reading this morning that the ridership in the US is continuing to increase over the past few years. Although the schedule isn't as flexible as the every 30 minute flights, I find that taking the train isn't any longer than flying given that I live really close to the train station (5 minute walk), I can arrive 10 minutes before departure time and it ends right downtown in Seattle instead of 30 minutes away from downtown. That and I get to open my laptop as soon as I sit down and keep it going the entire time makes me far more productive.

Anyway, about the conference. The big announcement was Oslo (http://www.microsoft.com/soa/products/oslo.aspx). What a huge endeavour this is going to be, new BizTalk, new .NET, new System Center, new Visual Studio, and simply net new tools! It will be a crazy time over the next couple of years. Like the past few haven't...

Oh, they also let slip, and I really beleive it was a slip, that VS 2008 will most likely be available in RTM this month.

Plenty of buzz about the new features in BizTalk 2006 R2, RFID and WCF taking most of the spotlight, but EDI got a bit of mention and BizTalk Services received their fair share as well.

I've been playing around with the WCF LOB SDK (http://www.microsoft.com/biztalk/technologies/wcflobadaptersdk.mspx) a bit and it certainly looks interesting. I beleive that there is some very good potential there that I will blog about more as I work with it.

I was also extatic to find a full VPC of a BTS R2 configuration on the DVD set that came with the welcome package. I had been checking the VPC site every couple of days for it as I didn't feel like creating my own.

Time to Value

2007-10-30T13:11:00.000-07:00

Here I am at the SOA and BPM Conference in Redmond. Good times. It's always fun coming to these things because I get to hook up with folks that I haven't seen since the last conference. Oh, that and the stuff you learn... ;-)

I was attending a session by Kris Horrocks of MS titled "Increasing Business and IT Agility with SOA and Microsoft". I have seen Kris speak before and he always has a good message to deliver. In this particular session he used a phrase that I really latched on to: "Time to Value". So much is possible with this statement that it is going to take me a while to fully digest it, toss it around and see what sticks. Immediately it strikes me as something that make for a great metric. What is/was the "Time to Value" of a particular initiative?

Determining how to gather the required metrics may be a tough thing, not so much for the "time" part but for the "value" part. How does one measure value? Decreased time to market? Reduced human interaction? Faster process time? I believe that all of theses would make for valid measures but to be able to reuse the "Time to Value" metric everything will need to be using the same values in the same context. In other words, in some situations it may be processing time while in others it may be time to market. Even once the "value" metric has been identified you will still need to quantify it over the time taken to deliver that value and from there identify where the line is that determines with the "Time to Value" was good, bad or something else.

I'm definately going to be thinking about this for a while.

Problem with Daily Standups

2007-10-14T12:00:00.000-07:00

Daily standup meetings are the best thing ever. Everyone says so, I say so, it must be true.

Lately, though, I've been feeling a bit disillusioned with the daily standup of one of the teams I am on. My mind starts to drift a bit as we move around the circle with everyone saying what they did since the last meeting, what they are going to do today and whether they have any issues or not. Why is this? Well, some of it is because this particular team has multiple focuses (focii?). We are divided into two subteams wherein each subteam is working on quite distinct parts of the application. Not feature sets but more like back-office versus client application, each with their own feature sets. Within that division we are also divided into distinct camps: business analysts, quality assurers and developers. Unfortunately within these groups it is quite waterfall although with short iterations. I'm not convinced it is all that agile but it is at least better than full waterfall, it is only waterfall within a feature set. This can be one of the challenges that is very difficult to overcome when trying to do agile development within a fixed price contract.

So anyway, I find myself zoning out as we move around the scrum, partly because of the divisions but also partly because of what is being said. Most of the reports go something like this:

"Yesterday I was in a meeting with Joe and Anne to discuss feature set X and then I worked on the specs for feature set Y. Today I have a meeting with Rupert and I will continue to work on feature set Y. No issues."

Not a lot of info that does me any good as a developer really other than I know that neither feature set X nor Y are complete.

On another team I have been trying to be more informative. For starters we hold our daily standup in the project room, the other team moves to a separate room with no project information on the walls. When it gets to my turn to talk about what I did yesterday, what I plan to do today and whether I have any issues I tend to take a more informative tack. Rather than saying "Yesterday I had a meeting with Andrew about feature set Z" I have been trying to convey the results of my day. I will try "Yesterday I talked to Andrew about feature set Z and discovered that...and so today I'm going to try doing this to see if I can achieve results A." It takes more time (not much) but conveys more information. I have also started asking some probing questions when others state just what they did rather than what they learned or accomplished. It is a fine line but one worth making.

One of the challenges I have found is with the first team, where we are much more segregated than the second team, if one person starts asking probing questions then about two thirds of the team doesn't care and you get squeaked at for "going down a rat hole" and told to take it off line. Granted in some cases this is justified but in others it is good information that those that are on that subteam should all care about, whether they be BA, QA or Dev. This brings me to my personal dilemma, perhaps the daily standups with the first team has too many people? Maybe the group is too large (14 active participants) and it needs to be better focused. The second group is only 5 active participants. Maybe we need to learn to communicate better information.

It has taken the second team, which has just only recently formed, to help me figure some of these things out. Now the real challenge is to integrate my learnings from the second team into the first...

On Meetings

2007-10-14T10:08:00.001-07:00

I recently picked up the book "I.M Wright's "Hard Code"" written by Eric Brechner of Microsoft (http://www.microsoft.com/MSPress/books/11437.aspx). It is a decent read, not quite on par with Joel http://www.joelonsoftware.com/ but so far it's a good read none the less.

Anyway, I just finished reading his article "The day we met". A rant on meetings. I couldn't agree with him more! I feel the same frustration with meetings as he expressed in that article. They can be such a waste of time, yet I understand that they are also a necessary evil and I have called more than my fair share of them.

My frustration with meeting led me to another book that I read a while back, "How to make meetings work" (http://www.amazon.com/Make-Meetings-Work-Michael-Doyle/dp/0425138704/ref=pd_bbs_sr_1/104-7001423-1042361?ie=UTF8&s=books&qid=1192382080&sr=8-1). It's an older book but the concept of meetings is far older and as such the words of wisdom are as valuable today as they were when the book was written.

One of my goals when I enter a meeting is to try and establish what the meeting organizers goal of the meeting is. Naturally if it is my meeting then I try and communicate the goal up front so that everyone else knows it as well. However, I often find myself in meetings where the goal was not apparent by the meeting title and so it requires some clarification by the organizer before I even know what I'm supposed to be thinking about. I have few enough spare cycles in my brain to have them spinning on the wrong topic if you know what I mean.

Getting the goal nailed down early is one of the crucial elements of a meeting in my book. That and keeping the meeting focused on that goal. Oh, how meetings can wander! Keep it focused, keep the eye on the prize.

So if you have ever found yourself in a meeting or you believe that you may, at some point in the future, find yourself in a meeting I strongly recommend you read both of the above mentioned books and keep them goal oriented and topic focused.

Good luck and productive meetings!

Datetime across the wire - redux

2007-10-10T20:11:00.000-07:00

A nice twist was added to the datetime problem that I discussed in my last post. As a couple of developers on my team were testing this feature out they tried altering the timezone on their local machines and running a few scenarios only to find that it wasn't working as expected.

It seems that IIS caches the datetime information. You see the developers would alter the timezone on their machine and test out their services, which were hosted in IIS. Things weren't working as expected, same old time zone. As it turns out IIS needed a bit of a kick in the way of the classic iisreset before it picked up the OS timezone changes.

.NET DateTime across the wire

2007-10-09T09:43:00.000-07:00

We ran into a bit of a problem with DateTime objects an serializing them across the wire using WCF services. According to the documentation the serialization uses the W3C spec for format which includes timezone information.

I created a simple client app that sent an object to a service. The object contained a single field of type DateTime and another field of type int.

When I sent the object to the server I read the value from the hour field and set the int field to that value and then sent the entire object back to the client. The client is in one timezone while the server was in another (one zone away).

Surprisingly the hour value on the server was exactly the same as the hour value on the client when I was expecting it to be different by one hour (as that is the difference in timezones between the client and the server).

It took a bit of digging but I found that the DateTime object that I was creating on the client was not timezone aware and therefore was not sending any timezone info to the server. Where I was expecting something like: 2007-10-07T07:00:00-08:00 I was seeing 2007-10-07T07:00:00. naturally when this value was received by the server it created a DateTime object with an hour value of 7 rather than 8, which is what the time difference would actually be on the server if it was 7 on the client.

It turns out that I was missing the "Kind" information. when I created a DateTime object like this:

DateTime dt = new DateTime(2007,10,7,7,0,0);

I would get a DateTime object with a "Kind" of undefined. The options being "undefined", "local" and "UTC". To get a "Kind" of "local" solves the problem and requires a constructor like this:

DateTime dt = new DateTime(2007,10,7,7,0,0, DateTimeKind.Local);

With this added bit of information the DateTime object that is created now knows that it should included the timezone information based on the local OS and sends the appropriate format across the wire and the server then treats the deserialized DateTime object as expected and it takes on the value according to the timezone on the server.

Problem solved.

A Few Good Books

2007-09-30T11:40:00.000-07:00

Here are a few good books that I have read lately and highly recomend.

Joel on Software
I had been meaning to read Joel's book for quite some time (years really) but only just got around to it. In a way I'm quite glad that I hadn't gotten to it sooner. Don't get me wrong, it's not that Joel doesn't have a lot of great things to say that I wouldn't have found valuable but rather I don't believe that I would have gained as much from them. I guess another approach would have been to read his book a few years ago and then gone back and read it again. You see, as I gain experience and move up in the senior ranks of software development I find that his words carry more weight and increased meaning. I find more similarities in what I have experienced with some of the stories he tells and find that I am in a better position to apply his words of wisdom (or dispute them) then I would have been a few years ago.

All in all, Joel's book should be a must read. Well worth it!

Dreaming in Code
I picked this up because it sounded interesting and I find that I do indeed dream in code. What a great book! Everyone that works in software, lives with someone that works in software, or knows anyone that works in software should read it.

I know the pain that the team is/has experienced and I completely sympathize with the challenges they face. I also found it somewhat surprising that a team built on such industry luminaries could still face the problems that they faced. In a lot of ways I'm not sure if I'm comforted, frightened or relieved by the tail.

The 12 Simple Secrets of Microsoft Management
This is an older book that I stumbled across as I was perusing the shelves at Powell's recently. It's a small, easy read that provides great tips on managing a successful company. Even though it's an older book the lessons are timeless and it also provides interesting insight into an extremely successful corporation.

If you can track down a copy I would suggest you spend a weekend and read it. Great advice is contained in its pages.