A Developer's Life

Tech-Ed '08 Birds of a Feather Session

noreply@blogger.com (Jeff B.) — Sat, 12 Apr 2008 03:55:00 +0000

I have been planning on attending this year's Tech-Ed "Developers" conference for a while now. This will be my 3rd trip to the Tech-Ed conference so this year I decided to see if I could become more involved and submitted a couple topics for Birds of a Feather (BOF) sessions. I just found out a couple of days ago that my submission, Using Team Foundation Server in your Organization, has been accepted. This will be my first time moderating a BOF session and I am looking forward to it. I have no doubt that we will be able to learn a lot from each other regarding the use of TFS within our organizations. So, if you have an interest in discussing TFS in your organization, plan on attending this BOF session on Wednesday, June 4th, from 10:15am - 11:30am. I look forward to meeting new people and learning new things.

PowerCommands for VS 2008

noreply@blogger.com (Jeff B.) — Sat, 01 Mar 2008 03:57:00 +0000

A short while ago I wrote a post about the MSDN Code Gallery. For all intents and purposes I liked what I saw with a few exceptions (nothing major). I even posted a simple Send Email Message snippet just to try it out.

Today, I noticed a new post that I think will prove to be very useful to many Visual Studio 2008 users - PowerCommands for Visual Studio 2008. This is a set of extensions for the Visual Studio 2008 IDE that offer various types of functionality, including:

Collapse Projects
Copy/Paste Class
Copy/Paste References (this will be hugely popular in my opinion)
Copy As Project Reference (another popular one)
Edit Project File
Open Containing Folder (very nice!)
Open Command Prompt (also very nice!)
Unload/Reload Projects
Remove and Sort Usings (C# only)
Extract Constant
Clear Recent File/Project List (yet another popular one)
Transform Templates
Close All

You can download the MSI, a Microsoft Word 2007 "read me" document, and/or the source code. I installed the MSI, ran Visual Studio, and was able to access the new functionality without any issues.

This set of extensions will no doubt become popular among Visual Studio users. With any luck, new features will be added along the way :-)

Click here to visit the PowerCommands for Visual Studio 2008 home page.

TFS 2008 Setup/Admin FAQ

noreply@blogger.com (Jeff B.) — Sat, 01 Mar 2008 03:20:00 +0000

A new forum post has been added to the Team Foundation Server - Setup forum titled TFS 2008 Setup and Administration FAQs. The intent of this forum post is to deliver commonly asked questions and answers relating to the setup, configuration, and administration of Team Foundation Server 2008. The post has been "pinned" to the top of the forum so it's easy to find.

Here is a list of questions that are answered in the post as of the time of this writing:

When installing a new Team Foundation Server, is there a way to use an existing SharePoint Web Application?
When creating a new TFS Project, is there a way to use an existing SharePoint site collection?
When creating a new TFS Project, is there a way to create a sub-site under an existing SharePoint site collection?
Why is it important to uninstall Team Foundation Server 2008 beta releases prior to installing Team Foundation Server 2008 RTM release?
Why is it important to uninstall Team Foundation Server 2005 from the data-tier server prior to installing Team Foundation Server 2008 in a dual-server configuration?
Is Team Foundation Server 2008 supported on Windows Server 2008?
Is Team Foundation Server 2005 supported on Windows Server 2008?
Is Team Explorer 2005 compatible with Team Foundation Server 2008?
Is Team Build 2005 supported on Windows Server 2008?

See the post for answers to the above questions and be sure to bookmark the site as it's surely going to grow.

Also, while you're there, check out the other post that's "pinned" just below the FAQ - TFS/Team Explorer 2008 Troubleshooting Guide. This post contains some good tips and workarounds.

So, what's the deal with $, @, and % anyway?

noreply@blogger.com (Jeff B.) — Mon, 18 Feb 2008 16:11:00 +0000

So, you've decided that the default build script that's built by the "New Build Type" wizard doesn't quite do everything that you need it to do. So, you click on over to the Version Control Explorer, check out the TFSBuild.proj file, and dive in!

At first glance, everything looks simple enough, you have various combinations of Targets, Tasks, and Properties. Things start to get a little interesting as you explore the concept of Item Groups. However, you start to notice a subtle difference with how various properties (or at least what look like properties) are accessed - e.g. some begin with '$', some with '@', and yet others with '%'. What's going on here? What's the difference? Before we can answer this question, we need to take a look at Properties and Items.

Properties
You can think of properties as MSBuild's version of a variable (as you might use it in some programming language such as C#). Once you declare a property, you can use it throughout your build script to reference whatever value it may hold. You create a property by defining an element within a PropertyGroup element. For example:

<PropertyGroup>
    <WebBinSource>Binaries</WebBinSource>
</PropertyGroup>

In the above example, the property is named "WebBinSource" and can be referenced in your build script as $(WebBinSource). You can create as many properties within the PropertyGroup element as you like. You can also create as many PropertyGroup elements as you like.

Aside from the obvious advantages of using properties within your build script (i.e. so you don't have to hard-code values in multiple places) another nice feature is that you can pass in custom property values on the MSBuild command line. For example:

MSBuild.exe MyProject.proj /p:WebBinSource=Bin

These properties can also be specified in the Team Explorer "Queue Build" dialog:

You can also reference environment variables using the same syntax. For example, you can reference the environment variable PATH using the syntax $(Path). If you declare a custom property with the same name as an existing environment variable, the custom property will override the environment variable and its value will be used when referenced.

MSBuild defines several reserved properties that you can utilize in your build scripts. There are also several customizable properties available within Team Foundation Build for use within your TFS build scripts.

Items
Items allow you to create user-defined collections which can then be used an input arguments for MSBuild tasks. The task can then act on the individual items within the collection as needed. You create an item collection by defining elements within an ItemGroup element. For example:

<ItemGroup>
    <SourceFiles Include = "default.aspx"/>
    <SourceFiles Include = "register.aspx"/>
</ItemGroup>

NOTE: You can also include multiple items within a single element by separating each item with a semicolon. For example:

<ItemGroup>
    <SourceFiles Include = "default.aspx;register.aspx"/>
</ItemGroup>

In this example, the item list is named "SourceFiles" and can be referenced in the build script as @(SourceFiles). For example, you may have a custom task that deploys a collection of files to a web server:

<Target Name="AfterBuild">
    <DeployWeb Sources="@(SourceFiles)" />
</Target>

Depending upon the task using the item collection, it may support the use of wildcards in the item definition. You can also change the item delimiter to be something other than the default semicolon for custom processing.

Although items are a useful feature, they're even more useful if you can associate metadata with them.

Metadata
Each individual item contained within an item collection may also contain metadata information. For example, a collection of files to be copied may contain the attributes of each file (e.g. read only, archive bit, etc.) or possibly the creation and last updated date/time.

You can associate metadata with individual items by adding child elements to the individual item elements. For example:

<ItemGroup>
    <SourceFiles Include = "default.aspx">
        <Copy>true</Copy>
    </SourceFiles>
    <SourceFiles Include = "Web.config">
        <Copy>false</Copy>
    </SourceFiles>
</ItemGroup>

Using this example, the following task will copy all web files that have a metadata item of Copy with a value of true:

<Target Name="AfterBuild">
    <DeployWeb Sources="@(SourceFiles)" Condition=" '%(Copy)' == 'true' />
</Target>

Also, any time a new item is created, there is a set of "well-known" metadata created and assigned to each item.

Putting it All Together
So, now when you see items prefixed with a '$', you'll know that it's referencing a property whereas items prefixed with a '@' are referencing a collection of items to be processed. If a task (or condition) needs access to the metadata for an individual item (or collection of items) then you will see the metadata items being prefixed with the '%'.

Hopefully this has cleared up the differences between the different types of "variables" in MSBuild and your Team Foundation Build scripts.

References

MSDN Code Gallery

noreply@blogger.com (Jeff B.) — Fri, 08 Feb 2008 20:11:00 +0000

Although it's been about two weeks since Microsoft launched its new MSDN Code Gallery, I am just now getting around to checking it out.

At first glance, it appears there are quite a few similarities between the MSDN Code Gallery and Microsoft's CodePlex site (another open source site provided by Microsoft and hosted on top of Team Foundation Server). So, what are the differences between the two sites? Basically, it boils down to project management: Microsoft's CodePlex site is suited for open source projects requiring some level of project management whereas the MSDN Code Gallery is mainly an on-line repository of code snippets and example projects (without any of the project management functionality).

What I like:

The MSDN Code Gallery is a visually pleasing site.
Quick and simple site for accessing code snippets (without having to pull down entire projects to get at a small snippet).
"Tagged" resource pages allowing for simple categorization of code snippets and examples.
Creating a new resource page is relatively easy.

What I don't like:

Not a lot of content. As of a few minutes ago, there were only 75 "resources" available for download on the site. However, this is still a new site and I'm sure it will grow a lot over time.
Figuring out the navigation and search features takes a little getting used to. It's nice once you figure it out but is not intuitively obvious.
You must have a Windows Live ID (formerly known as Microsoft Passport) to create new resource pages. The CodePlex site does not have this "limitation" (possibly due to the integration issues with TFS).
The instructions for setting up the resource page (correctly) and publishing it are not clear. I followed the instructions and published my first code snippet (for sending e-mail messages in C# or VB.NET) only to receive an e-mail message a few hours later telling me that my resource page "appeared" to still be in testing - which it wasn't. I've sent an e-mail asking for specific details as to what the actual problem is so I can get that corrected.
The only license model available is the Microsoft Public License (Ms-PL). This license is fairly permissive (no pun intended) but what does it hurt to have a few more choice (similar to the CodePlex site)?
The search functionality is fairly basic. Having some extended search features such as language choice (e.g. C#, VB.NET, JavaScript, etc.), submission date, etc. would be beneficial. The krugle search engine does a good job in this area (as an example).

I've always tried to make use of example source code snippets as I develop software just so I don't have to re-invent the wheel. However, a lot of the source code resources on the web tend to have an abundance of poorly written/tested snippets or the snippets are out of date. I will be interested in seeing how Microsoft deals with this issue over time (if at all). Until then, I'll enjoy yet another snippet repository.

Follow Up: I received some more details about why my resource page "appeared" to still be in testing... Basically, I was told that my resource page needed to be "spruced" up with a little more information. I must admit that my initial page was pretty sparse, but let's face it, a simple "send e-mail" snippet doesn't take a lot of explanation. However, I can understand Microsoft's viewpoint that they do not want a lot of mostly-empty (or "ugly") pages comprising the MSDN Code Gallery. So, I've updated the SendEmail resource page to hopefully meet the (not-so-well-documented) publishing requirements.

Working with the BuildStep Task

noreply@blogger.com (Jeff B.) — Thu, 07 Feb 2008 02:46:00 +0000

One of the new convenience tasks added to Team Foundation Build 2008 is the BuildStep task. This task allows you to add custom messages to the build reports created when you run a team build. For example, you may want to display the message "Publishing web site" while your build script is updating some files on a web site. Having the ability to "see" what your build script is currently executing is not only useful but can also be a great debugging tool (the messages are also logged as well as being displayed).

The BuildStep task accepts the following parameters:

TeamFoundationServerUrl - specifies the Team Foundation Server URL. For example: $(TeamFoundationServerUrl).
BuildUri - specifies the build URI - for example: $(BuildUri).
Name - specifies the name of the build step added by this task. NOTE: this parameter appears to be optional - i.e. it works just fine with or without a Name being specified.
Message - specifies the text of the message to be displayed within the build report.
Id - specifies the optional input/output parameter. If specified, this is the ID of the build step that is updated. If not specified, a new build step is created.
Status - specifies the status for the build step. For example, Succeeded, Failed, or Stopped.

There are several variations in how you can implement the BuildStep task. I've listed two of the more common scenarios below:

Simplest Scenario - Add a Message
The simplest scenario involves just adding a build step message to the build report with a status of "Succeeded". To do this, use the following pattern (note: the target "PackageBinaries" is used for illustration purposes only - the task can be utilized from within any target you wish):

This will display the text "Publishing web site" in the build report:

You can leave off the Status parameter, however, the icon displayed next to the build step will not indicate a completed task. If you leave the Status parameter in, then the status icon will indicate a completed task as soon as the build step is displayed, even if the task has not yet completed. To present a more accurate indication of what's currently executing, use the next template.

Complete Scenario - Display Actual Status
Ideally, you would want to display the icon that indicates a build step is executing until the step has completed and then change the icon (and optionally the message) to a "completed" status. To do this, use the following pattern:

<BuildStep TeamFoundationServerUrl="$(TeamFoundationServerUrl)"
             BuildUri="$(BuildUri)"
             Id="$(MyBuildStepId)"
             Message="Web site published"
             Status="Succeeded" />
</Target>

In this example, we're tracking the ID of the newly created build step (in the property MyBuildStepId) so we can use it in a subsequent BuildStep task to set the status icon to "Succeeded" and update the build report text.

NOTE: You can leave the Message parameter off in the second BuildStep task in the above example if you want to leave the original message text unchanged.

Although this is a new addition to the TFS 2008 release, you can get similar functionality for TFS 2005 by using a custom build task. One example of such a custom build task is available here.

10 Reasons for TFS with Small Teams

noreply@blogger.com (Jeff B.) — Wed, 06 Feb 2008 04:27:00 +0000

Over the past year or two I've read and heard, on multiple occasions, comments along the lines of "our team is not big enough to justify Team Foundation Server" or "we don't have the need for TFS". Contrary to these perceptions, Team Foundation Server can provide a lot of benefits - even for small development teams.

Here is a list of ten reasons for using TFS with small development teams (in no particular order):

Version Control - no matter how small or big your development team and/or project is, everyone eventually loses source code for one reason or another (e.g. power/network outage, hard drive crash, human error, etc.). Along with the ability to backup source code (and other project "artifacts") a good version control system (like the one built into TFS) allows you to version your source code, apply labels, and perform branching/merging operations. The version control system built into TFS utilizes Microsoft SQL Server as its data store which allows for easy backup and restore operations.
Automated Builds - a lot of time is spent on the actual development of a product. However, unless you "package" your product for deployment/publishing, then you're only half way there. TFS allows you to create automated build scripts that will build the latest version of your source code, in a clean environment, and (optionally) perform various tests against the source code, build installation packages, deploy files (e.g. web sites, MSI packages, etc.), publish build reports, etc.

With TFS 2008 you also have the option to setup Continuous Integration with the click of a button or schedule a specific build type to run at a pre-designated time (e.g. "nightly" build). Frequently running an automated build script provides a certain amount of assurance that you can deploy/ship your product with limited notice.
Work Items - anyone that's ever been involved in the software development process (no matter the size) has created various types of lists. For example, a list of requirements, a list of defects, a "wish" list, etc. There are at least two down-sides to these lists: lack of tracking and lack of workflow.

TFS allows you to create Work Items which, out of the box, are things like Bugs, Tasks, Scenarios, Risks, etc.. You can also modify existing work item types and/or create your own (e.g. to more closely match your development practices). These work item types also have the ability to define a workflow so that the work item can move from one state to another in a controlled fashion.
Documentation Management - regardless of the size of your project or the type of software development methodology you're using, you will no doubt create some documentation along the way (even if it's as simple as installation instructions). TFS utilizes Microsoft Office SharePoint Services (MOSS) to store and manage documents related to your project. In fact, the Team Explorer Client that integrates with Visual Studio gives you direct access to your SharePoint documents directly from within Visual Studio.
Unit Test Integration - although you can create and run unit tests in Visual Studio without the use of TFS, by automating your unit tests within a TFS-based build, you can track the progress of unit tests over time and publish each test run to TFS (e.g. so that it can be viewed within various reports and/or the TFS SharePoint site).
Code Coverage Integration - like unit tests, you can get code coverage manually within Visual Studio. However, by including code coverage in your TFS-based builds, you can track code coverage over time and view the results within various reports and/or the SharePoint portal.
Integrated (Static) Code Analysis - again, like unit tests, you can run static code analysis manually from within Visual Studio (e.g. via FxCop). However, having the ability to enforce code analysis rules at the time your source code is checked in and/or built, you can add another level of quality control to your project.
Distributed Development - you may end up on a project, even with small teams, where the team is physically distributed - e.g.. home vs. work, work vs. another country, etc. This physical separation can introduce many challenges for developers (e.g. source code concurrency/consistency, updating documentation, modifying work items, performance issues, etc.). TFS was built from the ground up with this challenge in mind. You may have TFS installed at your company's office but can still connect to it using the Team Explorer client from your home (assuming the TFS server is accessible via the Internet or VPN).
Overall Integration - all of the features listed above can be cobbled together using other Microsoft, open source, or 3rdparty products. However, what this type of environment would lack is the overall integration provided with TFS. For example, you could use NUnit for running unit tests and possibly utilize CruiseControl.NET to implement your build process. However, how would you publish the unit test results to a web site for later review? How easy would it be to provide a history of those results?
Cost (sort of) - one of the more common reasons you hear when justifying the use of open source software is the price - i.e: free. However, "free" doesn't always come without cost. Without the integration provided by TFS, you will no doubt be spending a good amount of time "wiring" various technologies together to gain similar functionality.

With TFS, you spend a lot less time on integration issues and more time concentrating on developing and increasing the overall quality of your product. If the features listed above can save your several hours of manual effort a week or possibly reduce the defect rates of delivered products, what's that worth?

There are basically four Team Foundation Server products:

Team Foundation Server Trial Edition - this is a fully functional 90-day trial edition. If you want to give TFS a try, you can download the trial edition here.
Team Foundation Server Retail Edition - this is the "full" version of TFS with a price starting around $2,000 (and going up, depending on your specific needs).
Team Foundaiton Server Volume License Edition - this is basically the same as the Retail Edition, only it's obtained differently.
Team Foundation Server Workgroup Edition - this is a 5-user version of Team Foundation Server with the same functionality of the full version. This version is included with the "Team System" editions of the MSDN Premium subscription. So, if you (or your company) already has one of the "Team System" MSDN Premium subscriptions, then you already have this edition - so why not use it?

For more details about the different versions of Team Foundation Server, check out this post.

This list only scratches the surface of what's available within Team Foundation Server and the benefits it can provide to teams of all sizes. As TFS matures and approaches the next release ("Rosario") the features will only improve and the benefits will increase.

Displaying Quality Indicators

noreply@blogger.com (Jeff B.) — Tue, 05 Feb 2008 14:32:00 +0000

A few days ago, I put an article together for Paul Hacker's TFSTimes. The article, Displaying Quality Indicators on your TFS SharePoint Site, discusses usefulness of the Quality Indicators report that ships with Team Foundation Server and how to add it to your project's SharePoint Site. The article also describes how to modify your build types to automatically run all unit tests as well as how to include code coverage statistics with your build.

You can read the article on-line here until the next issue is posted. The archived PDF version is available here.

Omaha Team System User Group

noreply@blogger.com (Jeff B.) — Sat, 26 Jan 2008 04:22:00 +0000

The first Omaha Team System User Group meeting is, as they say, history! The feature presentation, What's New in VSTS 2008, was presented by Bill Maurer (a Microsoft Developer Technology Specialist). He also covered some of the new features coming in "Rosario". The presentation was very interesting and information and was well received.

Our first meeting was held January 22nd and was sponsored by Farm Credit Services of America. It was very well attended with 75 attendees. Our next meeting has not yet been scheduled but I am looking forward to working with fellow Team System enthusiasts in the Omaha area.

If you happen to be in the Omaha area and have any suggestions for user group topics, please visit the OTSUG site and drop send me a message.

Links:

TFS/MSBuild Sidekicks Updates

noreply@blogger.com (Jeff B.) — Fri, 11 Jan 2008 18:59:00 +0000

The Attrice corporation has been hard at work updating their set of Sidekick Utilities for VSTS/TFS 2008 (I know I'm excited!). I've been using these tools for quite some time now and have been waiting for the upgrade ever since we updated to VSTS 2008 a month or so ago.

First in line are the Team Foundation Sidekicks which includes the following features:

History Sidekick - provides various functionality for viewing the history of items within version control.
Status Sidekick - (I use this one a lot) - allows you to search and view pending changes for items based on user name, project name, and/or a given date range. Based on the current status of an item you have the option to undo a pending change or lock.
Workspace Sidekick - provides functionality for managing TFS workspaces - e.g. deleting, updating, or copying.
Labels Sidekick - provides functionality for managing labels within version control.
Shelveset Sidekick - provider functionality for managing shelvesets.
Code Review Sidekick - allows you to select and compare changesets and save the results for later use. This also shows up in the context menu for the source code explorer (SCE) window in Visual Studio. I haven't had a chance to use this Sidekick yet but it looks like a nice time saver.
Visual Studio Search Items Add-in - by default this option is turned off because there is now search capabilities built into VSTS 2008. However, if you're still using VSTS 2005, this can be a real time saver (turn it on via Tools->Options->Team Foundation Sidekicks).
Visual Studio Build Type Add-in - this used to be a separate add-in but is now part of the TFS Sidekicks package and is one of my favorite features. This add-in gives you the ability to right-click on a build type within the Team Explorer pane (in Visual Studio) and select "Check Out for Edit..." which will then check out the build type's TFSBuild.proj file (or whatever it may be named) and open it for editing. Accordingly, there are also menu options for checking the changes back in or rolling the changes back.

If you spend any time at all administrating a TFS server or editing build types then these tools are a MUST HAVE. Even if you only use them once in a great while, they're still a huge time saver over the command-line utilities that ship with TFS - besides, they're free!

They also offer a product called Microsoft Build Sidekick which gives you various editors/views for your MSBuild scripts. One of the coolest features of this tool is the "Targets Diagram" which gives you a graphical view (similar to something you might see in Microsoft Visio diagram or a class designer) of the targets contained within your MSBuild script (and how they related to each other). This product is downloadable as a trial version that expires after 30 days.

These tools just keep getting better and better with each release. You can read more about these great tools here:

TFS 2008 Power Tools Released

noreply@blogger.com (Jeff B.) — Fri, 21 Dec 2007 21:31:00 +0000

The Team Foundation Server 2008 Power Tools has been released and is available for download here. There are several tools/features included in this release - some new, some old:

Team Foundation Power Tool command-line tool (TFPT.EXE) - contains some new commands for configuring Team Explorer connection settings (tweakui) and for destroying Work Items and Work Items Type Definitions (destroyWI, destroyWITD).
Process Template Editor - updated for use with Visual Studio Team System 2008 Team Foundation Server. It also has several improvements, including: the ability to launch standalone without a Visual Studio installation, performance improvements, improved discoverability and bug fixes.
Custom Check-In Policy Pack - a set of custom check-in polices including:

Custom Path Policy - provides a mechanism that lets you specify the source control path or paths upon which a particular policy acts.
Forbidden Patterns Policy - allows you to specify a file extension or a regular expression that you can use to keep certain file types from being checked in to source control.
Changeset Comments Policy - allows you to verify that the Comments text box in the Check In dialog box is not empty.
Work Item Query Policy - allows you to specify a team query to which the work item associated with a check-in must belong.

Team Foundation Server Best Practices Analyzer (BPA) - updated for TFS 2008 deployments.
Work Item Templates - adds additional menu items to the Team Work Item Templates menu.
Find in Source Control (NEW) - an addition to the Team Explorer menu that provides the ability to locate files and folders in source control by the item’s status or with a wildcard expression.
Quick Label (NEW) - allows labels to be easily applied to a given selection of files and folders in the Source Control Explorer.
Build Notification (NEW) - runs in the Windows task bar notification area monitoring the status of the build definitions you have specified. It can be configured to show notifications when builds are queued, started, or completed for multiple build definitions spanning multiple Team Foundation Servers.

You can read more about what's included with the TFS 2008 Power Tools release here.

Build Type Settings Changes

noreply@blogger.com (Jeff B.) — Mon, 10 Dec 2007 13:20:00 +0000

I've fielded a couple of questions lately about where some of the settings for build types in TFS 2008 are stored. In the new version of TFS (2008) some of the build type settings have been moved from the TFSBuild.proj file to the TFS databases (mostly the TfsBuild database). So, even though you see the settings within the XML file (TFSBuild.proj) the XML settings have no effect on builds within TFS 2008. However, if you still have VS 2005 (or other "version 1") clients accessing your TFS 2008 build types, you should keep the XML settings in sync with the TFS 2008 database settings.

The settings that have been moved to the database include:

Description - the build type's description.
Build Machine - the default build agent.
Team Project - the Team Project the build type belongs to.
Build Directory - the directory where the files involved in the build are built.
Drop Location - the network location where the build files are "dropped".

If you create a new build type, you will see comments within the XML file noting the change in settings location. For example:

<Description>This is my build type's description.</Description>

TFSInfo Updated for TFS 2008

noreply@blogger.com (Jeff B.) — Fri, 07 Dec 2007 03:44:00 +0000

A few months ago I created a simple command line utility called TFSInfo that can be used to display various bits of information about a Team Foundation Server 2005 installation. I have now updated this utility to work with TFS 2008 as well as TFS 2005.

You can see from the screen shot which information is displayed. In case you can't see the image, the following information is displayed by TFSInfo:

AT server name
AT Version
AT Edition (e.g. Standard, Workgroup, or Trial)
DT server Name
DT Server Version (not available for TFS 2008)
SQL Server Version
Reporting Server URL
TFS Installation Date
TFS Product ID

You'll notice in the list above that the Data Tier schema version is not available for TFS 2008. This is because the column that's used to determine the schema version in TFS 2005 does not exist in TFS 2008 (at least not in the same table). I wasn't immediately able to locate a replacement column to retrieve the same information. If I am able to determine how that information is stored (assuming it is) I will release an update.

The new version can be downloaded here.

NOTE: The Team Explorer Client 2005 or 2008 needs to be installed for TFSInfo to work.

VS 2008 Add-Ins

noreply@blogger.com (Jeff B.) — Tue, 04 Dec 2007 03:39:00 +0000

As I (like many others) make the full-time transition from VS 2005 to VS 2008 I find that I'm having to update several add-ins and utilities that I've grown accustomed to. Here is a short list of what I've updated so far:

Visual Studio 2008

GhostDoc 2.1.2 - I've become very accustomed to pressing Ctrl+Shift+D to fill in the XML comments for my code. I'm glad to see that VS 2008 is now supported.
Project MRU Cleaner - This is a very handy utility for removing orphaned or otherwise unwanted solutions from the Recent Projects list in VS 2005/2008.
ReSharper - Although ReSharper does not fully support the .NET Framework version 3.5 yet, Jeffrey Palermo has published some instructions on how to get the latest version of ReSharper working with VS 2008.
Silverlight 1.1. Tools Alpha for VS 2008 - Nothing new here - it's just been updated to work with the final release of VS 2008.

Team Foundation Server

VSTS Web Access Power Tools for Team System 2008 - with the new license modifications in TFS 2008 this tool is even more useful than before. Now all of your company's employees can create work items (e.g. using VSTS Web Access) without requiring a CAL.

I'm still waiting on the full release of Team Foundation Server 2008 Power Tools as I've grown accustomed to using those tools on a regular basis as well - it shouldn't be long. I also have a couple of add-ins that I've written that I need to get updated for VS 2008 as well.

Omaha VSTS User Group is Coming

noreply@blogger.com (Jeff B.) — Mon, 03 Dec 2007 04:55:00 +0000

A co-leader (Tim Kelsey) and I have been planning on starting a Team System Users Group in Omaha for several months now. The initial web site is finally up at www.otsug.org and we are excited to have our first speaker, Bill Maurer, scheduled for January 22nd, 2008. Bill will be presenting on the new features and updates in VSTS 2008. Time permitting, he will also cover some of what's coming in "Rosario".

With the addition of the Team System Users Group, there will now be no less than four Microsoft technology-oriented user groups in the Omaha area, including:

Omaha Team System Users Group
Omaha .NET Users Group
SQL/BI Users Group - SQL Server/Business Intelligence
BizTalk Users Group

We will be holding the initial meeting at Farm Credit Services of America (my employer - and a user group sponsor). Depending upon the preferences of the user group attendees, we will either continue having the meeting at this location each month or we will move the meeting around Omaha (much like the current .NET Users Group). I will be placing a survey on our site in the next few days to get everyone's feedback and preferences.

I am looking forward to the inaugural meeting and all that follow. I have no doubt we will have some great speakers presenting on some great topics and will learn a great deal from each other about all things Team System.

If you are in the Omaha area and would like to join the Omaha Team System Users Group, please visit our site at www.otsug.org and click on the "Join the group" link. Also, if you're in the Omaha area or are just passing through and would like to present at one of our user group meetings, please submit the User Group Speaker Proposal document located in the Shared Documents section of the web site.

Power Tools for TFS 2008 Roadmap

noreply@blogger.com (Jeff B.) — Tue, 27 Nov 2007 21:27:00 +0000

Brian Harry has posted a time line of which power tools will be released over the next month for TFS 2008. In summary, these will include:

VSTS Web Access - the "final" version for TFS 2008.
MSSCCI Provider - will allow access to TFS 2008 from VS 2003, VS 2002, and VS 6 as well as other IDEs.
TFS Power Tools - the same basic TFS Power Tools that shipped for TFS 2005 but compiled against the TFS 2008 object model.

Process Template Editor - mainly bug fixes and small improvements.
Build Notification Tray App - this is a new Power Tool application that will allow you to monitor TFS builds via a Notification Tray application.
WI & WIT Destroy - support for the deletion of work items and work item types has been added to the tfpt command line utility.
Best Practices Analyzer - has been updated to work with TFS 2008.

It's nice to read that these updates will be released soon as they have definitely become a necessity in the day-to-day operations using TFS.

You can read the full details, including the timeline, here.

TFS 2008 License Changes

noreply@blogger.com (Jeff B.) — Mon, 26 Nov 2007 13:44:00 +0000

Brian Harry recently posted details regarding a change to the newly released TFS 2008 licensing model. In short, the new license structure will allow anyone in your company to perform the following actions against a TFS server (Standard Edition only - does not apply to the Workgroup Edition) within your organization without the need for a CAL:

Create work items
Query work items they've created
View work items they've created
Update work items they've created

I suspect this type of activity has probably been going on quite a bit in the past with TFS 2005 - it's just that it hasn't been all that easy to track. This new change will at least remove some of the worry associated with trying to keep these types of users (i.e. the ones that fit the above profile) in compliance.

The downside (as Brian points out) is that there is no built-in tools to help you determine (or enforce) compliance. It appears that they plan on providing some enhancements over the next year to address this issue.

What I like about this change is that it will give development shops a little more leverage on how they might choose to make use of the work item features within TFS. For example, I'm currently finishing up a blog post on how to create TFS work items directly when an exception is caught within your application. Previously, in TFS 2005, your end users would (legally) need to have a TFS CAL to utilize the exception handler. Now, in TFS 2008, any end user in your company is automatically covered - no CAL is required.

What I don't like about it (I suppose I shouldn't be complaining - at least it's a start) is that it's overly restrictive. Does it really hurt to allow full work item access to your employees? If they can create and manage their own work items, what does it hurt to allow them to manage other work items (not created by them) as well? Maybe that's a change that will come in the future as Microsoft works out the best fit for their TFS license model. At any rate, it's a good start.

You can read more in the original post.

NDiagnostics - Beta Release

noreply@blogger.com (Jeff B.) — Fri, 16 Nov 2007 04:36:00 +0000

Any of us that creates software on a day-to-day basis, that's actually used by someone other than yourself, has undoubtedly had to answer technical support questions about your software and/or troubleshoot why it's not working. In a lot of cases, you may have a dedicated support team that interacts directly with your customer base and they only contact you if they come across something they can't resolve or explain. Over time, the support teams tend to become very efficient at resolving application-specific issues regarding setup and configuration. However, when an application is first released, the process isn't so straight-forward and you may have to field a lot of questions.

Now, don't get me wrong, I'm more than happy to answer any questions I can about the software that I produce. However, I'm also interested in maximizing everyone's time (mine, the technical support staff's, as well as the end-user's). That is why I decided to create NDiagnostics. The purpose of NDiagnostics is to allow for the easy creation of a self-diagnostics utility customized for a specific application. For example, if your application requires certain files and/or folders to be present, a specific version of the .NET Framework, and possibly access to a SQL Server database, then you can create a custom configuration file that can quickly and easily scan a user's machine for compliance. Here's a sample screen shot of what NDiagnostics might look like after scanning a user's workstation:

In this example, the SQL Server Service's Startup Type was not set to Automatic as expected. However, you can quickly ascertain that the required .NET Frameworks are installed, the SQL Server service is running, Visual Studio is running (yet another strange requirement), my blog is available (yeah!), and the application's database is accessible.

This isn't necessarily a real-world example but it does demonstrate how easy it can make troubleshooting certain tasks. It only took a few seconds for the above tasks to run - it would have taken several minutes to verify these tasks manually (possibly hours if the technical support staff had to determine what to verify to begin with).

NDiagnostics is completely configurable via an XML-based configuration file. The configuration file defines the groups of diagnostic tasks to be run as well as the order of the tasks. NDiagnostics currently ships with the following tasks:

File Task - checks for the existence of a specific file and can also (optionally) check the version number.
Folder Task - checks for the existence of a specific folder.
NETFX Task - checks for a specific version of the .NET Framework.
Process Task - determines whether a specific process is running.
Registry Task - allows you to verify registry settings.
SQL Server Task - checks for connection to specified database; optionally check for table existence and/or query result.
URL Task - determines whether a specific URL is available (can verify web page or web service).
Windows Service Task - determines whether or not a specific Windows Service is installed, and optionally, the current status (e.g. running, stopped, etc.).

Being that this is the first release the set of tasks is somewhat limited. There are several new tasks currently in the works that will be made available in future releases. Also, the project just went "live" tonight so I'm still getting the on-line documentation up to speed.

So, if you have a need for a quick-n-easy diagnostics tool, give NDiagnostics a look. Please provide any feedback as I would like to make this utility as useful, friendly, and simple as possible. If you have any suggestions for new tasks, please post a comment here or leave feedback at the NDiagnostics site. Also, the source code is fully available so you can customize this application to your liking.

TFS Book Wish List

noreply@blogger.com (Jeff B.) — Wed, 14 Nov 2007 01:45:00 +0000

Have you ever found yourself saying something along the lines of "If only I had more time, I'd write a book about such-and-such"? Well, I've found myself saying that several times over the past year or so about Team Foundation Server. Now, don't get me wrong, there are several good books currently available for TFS but none of them quite match what I'm looking for.

I'd like a TFS Automation for Developers book that covers the details for:

Programmatically creating new work items.
Programmatically querying work items and modifying them.
Creating custom check-in policies.
Creating custom build tasks.
Programmatically accessing and utilizing published unit test and code coverage data.
Programmatically accessing related SharePoint documents.
An in-depth explanation of the web services architecture and how to use it.
An in-depth explanation of the TFS Object Model and how to use it.
All of the above for both TFS 2005 and TFS 2008.
Anything else I happen to think of :-)

Granted, I can find examples for most (if not all) of the above items on the web today. However, what I don't have is a comprehensive explanation of each of them and how they all relate and work together.

Searching Amazon.com for "Team Foundation Server" turned up 18 items (17 books and 1 TFS software package) of which only three appeared to focus on Team Foundation Server. The most promising book out of these three is not yet for sale (although I've added it to my wish list so I don't lose track of it). Just based on the title (Visual Studio Team Foundation Server [Microsoft .NET Development Series]) it may be close to what I'm looking for.

In the meantime, I still don't have the time (or necessarily, the skill) to write a reference book so I thought I'd start an on-line version of the tasks I outlined above. The basic purpose of the new site would be to consolidate and organize the information necessary for working with TFS programmatically. I also realize that MSDN already has a lot of information on it as well but it's not necessarily the easiest to traverse nor does it always have good examples to follow.

So, if you're interested in seeing anything specific, or if you've come across some great sites with great coding examples, please leave a comment. I'll be posting back soon on the progress.

SafetyTip - My First Mobile App

noreply@blogger.com (Jeff B.) — Wed, 07 Nov 2007 01:17:00 +0000

A co-worker recently sent me a link about calculating checksums for tips (i.e. the tip you leave your server when paying for a meal at a restaurant). Without getting into the crux of the poster's original argument ("thieving restaurant servers" - I don't know how often this happens) I found the idea of creating checksums for tips intriguing.

That same night, at one of my family's favorite restaurants, I decided to put the checksum into practice. However, I quickly realized that mentally calculating checksums for tips wasn't all that fun :-).

So, what's a software developer (with a Windows Mobile-enabled phone) to do? Develop an application, of course!

I decided to build a simple Windows Mobile application that supports the following features:

Allows the entry of the total net amount (i.e. the amount on your bill)
Allows you to select a level of service (e.g. Ok, Good, or Excellent) with an associated tip percentage.
Allows you to select the tip calculation method (e.g. standard, checksum, or palindrome).
Calculates the appropriate tip amount.
Allows all default values to be modified.

Notice that I also implemented the "palindrome" method based on a comment on the original post.

The application has two screens. The first screen allows you to select the tip level and calculation method and also allows you to enter the net (bill) amount. As you enter the amount, the tip will be calculated based on the method you've selected.

The second screen (invoked by selecting the Preferences menu option) allows you to modify the application's default values.

Granted this is a simple but it's also my first mobile application so it's been a good experience (plus it's something that I'll make use of). However, even though it's simple, I've learned a lot about the differences in controls between the .NET Framework versions and how to use the Pocket PC emulators as well how mobile applications are deployed. There's still lots to learn but we all have to start somewhere :-)

If you're interested in the application, you can download the CAB file here. The application is compiled against the .NET Framework Compact Framework 2.0 which must be installed on your PDA and targets Windows Mobile 5.0.

Getting Ready for Patterns & Practices Summit 2007

noreply@blogger.com (Jeff B.) — Wed, 31 Oct 2007 02:47:00 +0000

It's almost time for this year's Patterns and Practices Summit and I'm excited for many reasons. There is a list of great speakers lined up along with some great sessions. One thing I'm looking forward to with this summit over the typical conference (e.g. TechEd or PDC) is I don't have to pick-and-choose between a dozen (or more) tracks when deciding which sessions to attend - there is only one track with about seven sessions per day. I'm also looking forward to visiting the Microsoft campus since I've never been there before. So, all-in-all, it promises to be a great event.

Of course, I'll have to put on my tourist hat in the evenings and check out the local sites such as the Space Needle. Having never been to Washington state I'm not sure what to check out so if anyone has suggestions, please post them. Also, if there is anything specific (i.e. super cool) to visit while on the Microsoft campus please post that as well :-)

TFS 2008 System Recommendations Released

noreply@blogger.com (Jeff B.) — Thu, 25 Oct 2007 00:08:00 +0000

In case you haven't seen it, Brian Harry posted the TFS 2008 System Recommendations a few days ago. There is some great information in there if you are planning on upgrading existing TFS 2005 installations or if you're planning on installing TFS 2008 on a new system. Based on the test results it looks like some pretty good performance improvements have been achieved. You can read more here.

What's New in TFS 2008

noreply@blogger.com (Jeff B.) — Fri, 19 Oct 2007 17:52:00 +0000

I just completed my presentation on the new features of TFS 2008 at this year's Tulsa TechFest. It was a relatively small session held in one of the classrooms here at the OSU campus which allowed me to more easily address questions during the presentation. The topic I presented on is called What's New in TFS 2008. Although the presentations run roughly 75 minutes, I had to skip over a couple of my demos because there are so many new features in TFS 2008. It was easy to tell that I'm not the only one excited about some of the new features :-) If I had to pick my top 5 features in TFS, they would have to be:

Continuous Integration - although there are 3rd party/open source implementations available for TFS 2005 now, they don't have the same, clean integration that's present in TFS 2008.
Build Retention Policies - finally, I won't have to worry about running out of space on the "drop" server because there are 2,000 old builds sitting around collecting dust. Anyone that's ever had a build fail due to lack of disk space (which is not stated in the build failure log) will appreciate (or, love) this feature!
Better Build Support - specifically, the ability to store the TFSBuild.proj file in any folder. This greatly enhances branching options.
Queued Builds - the ability to queue builds is great. I know longer have to wait for my CI build to complete before I can start the test build that pushes the updates to the test machines.
Performance Improvements - there are tons of other enhancements and improvements throughout TFS 2008 but there are also a lot of performance improvements as well. Anything that allows my builds to complete a little bit sooner is much welcomed.

I could probably list a couple dozen other features that I really like in addition to those above but I have to stop somewhere :-)

You can download the slides here if you're interested:

TFS 2008 Features in TFS 2005

noreply@blogger.com (Jeff B.) — Thu, 18 Oct 2007 03:36:00 +0000

There are a lot of new features in TFS 2008. So many in fact, it's difficult to list them all at once. I will, however, do my best to cover as many new features as I can during this year's Tulsa TechFest when I present on What's New in TFS 2008. There are a lot of new features that have been integrated into TFS 2008 that can also be had today in TFS 2005. Some of these are listed below...

Continuous Integration - there are several 3rd party solutions for implementing continuous integration in TFS 2005. These include:

A Microsoft implementation - this is a web-service based implementation that allows you to associate a Team Project with a specific Build Type to be called any time something is checked into version control. I've seen several variations of this implementation available on the web.
TeamCI by Notion Solutions - this is a free CI tool offered by Notion Solutions.
TFSBuildLab - this is an open source project on Microsoft's CodePlex site. This TFS utility offers more than just CI capabilities.

TFSBuildLab - along with the continuous integration capabilities listed above, TFSBuildLab has many other features:

Retention policies - can be based on Build Status or Build Quality. You can also specify the number of builds to keep or the number of days to keep them.
Tray notifications - receive build and check-in notifications (via "toast" messages)
Build queuing - provides a mechanism for queuing builds.
Build scheduling - provides a UI for scheduling builds.

"Listless" Unit Tests - TFS 2008 has the ability to specify which unit tests to run (during a build) based upon a file mask rather than being forced to select a list of tests. This approach lets you easily run all unit tests within an assembly or set of assemblies (for example) without ever having to manage lists of tests for the build. Buck Hodges has a great post explaining an implementation for TFS 2005. Trust me, once you start specifying your unit tests in your build using this approach, you'll never go back to test lists again :-)

"Broken Build" Check-in Policy - TFS 2008 has a new check-in policy called Builds. When something is checked into version control this policy will check to see if any related builds are currently in a "broke" state; If so, the policy will fail. The idea is to not let developers keep checking in code when the build is just going to fail anyway. Clark Sell has created a Build Status check-in policy for TFS which gives you this functionality now, in TFS 2005.

BuildStep Task - If you've ever wanted to add your own custom text in the build report (the view you get in Visual Studio while watching an active build run through the various build steps) then you're in luck. In TFS 2008, there's a new build task called the BuildStep task that does just this. You can also get this functionality in TFS 2005 with the TeamBuildTask posted by Aaron Hallberg.

Incremental Builds - incremental builds are supported within TFS 2008. TFS 2005 build scripts can be configured to run incremental builds with a little work. There's a "how to" article on MSDN that explains the steps to run incremental builds in TFS 2005.

There are undoubtedly other features that can be made available for TFS 2005 but this is a good start.

NLarge Utility

noreply@blogger.com (Jeff B.) — Tue, 02 Oct 2007 04:00:00 +0000

I've been putting the finishing touches on a TFS 2008 presentation that I'll be giving at this year's Tulsa TechFest conference later this month and came across a utility that promises to be extremely useful. It's called NLarge and provides the ability to zoom in and out of a presentation (or any other displayed materials) using a smooth scrolling effect. NLarge runs in the taskbar notification area and can be activated with a hotkey (Alt+1). Once activated, the zoom feature can be controlled with the mouse, tablet pen, and/or keyboard. Although I haven't used this utility during a presentation yet, I think it will be extremely valuable in aiding those in the back of the room to see what I'm focusing on.

NLarge is an open source project available on Microsoft's CodePlex site. You can get more information about NLarge here.