Seriously. They can't.

http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=259259&SiteID=1

You may delete specific values, but not the list itself. This means you can effectively "zero out" a list by deleting all of it's items.

I don't quite understand why this would be a good feature, as it doesn't really stand up for a test of trace-ability. I just deleted a Team Project whose work items referenced a global list, so there are no references to the list in the system anymore.

Perhaps one way to mitigate this would be to use abstract list names? List A, List B, etc. Then you could re-purpose a list later by giving it new values. Nah.

So, what's the take away? Be very careful about the Global Lists you create in your Team Foundation Server. They will be with you a long time.

Mike Azocar, a fellow Team System MVP, reports:

We released LWS version 2.1 today.  This version includes a new process guidance and SharePoint template as well as many work item enhancements.   You can download it at
www.codeplex.com/vstsscrum

Mike also indicates that they will soon release a version that will work with the Project Server connector.

Having just inherited a TFS installation to manage, I received a request to add some values to a global list. I got a little nervous about this when I saw that the server had many (MANY) global lists in it already and I wanted to be very careful not to break anything during this change.

Of course the first thing I did was consult the master book on the subject of TFS, Rich's Working with Microsoft® Visual Studio® 2005 Team System. This was a great start to groking the whole Global List thing.

The steps needed to do this are pretty simple and documented well from Microsoft. The step to export your current global lists is to use the glexport command line tool. From the Visual Studio command line prompt (this works fine on a client), do this:

glexport /f AllGlobalLists.xml /t myTfsServerName

Credentials used are the local login credentials. This gives me one big file containing all the global lists in the server. Now the question I had was this, "Should I edit this master global lists file and import the whole thing, or should I just try to import changes to one list?" Obviously I wanted to work only on the one list I needed to change, but what effect would it have if I pulled out all the other lists from the file and uploaded just a single list in a smaller XML file?

I was scared to death of deleting all the other lists in the file. I saved a copy of the master, and then took out all the global lists except the one I was interested in, changed the values, and ended up with something like this:

<?xml version="1.0" encoding="utf-8"?>

<gl:GLOBALLISTS xmlns:gl="http://schemas.microsoft.com/VisualStudio/2005/workitemtracking/globallists">

  <GLOBALLIST name="Teams - Product Backlog">

    <LISTITEM value="Team A" />

    <LISTITEM value="Team B" />

    <LISTITEM value="User Experience" />

    <LISTITEM value="Team C" />

  </GLOBALLIST>

</gl:GLOBALLISTS>

So, on a wing and a prayer I ran this command:

glimport /f TeamList.xml /t myTfsServerName

And guess what happened: It worked great! All of my other lists were intact and my new team names showed up just fine. So I learned 2 things in this little exercise.

1. You can import a single global list XML file into your TFS server without affecting other lists.
2. glimport and glexport work just fine on a VS2008 client talking to a 2005 TFS server.

Martin Woodward has done his magic again! For those of you who don't know Martin, he is the primary developer of Teamprise, a fantastic suite of client applications that gives Java developers cross-platform access to Team Foundation Server from the command line, a stand-alone GUI or an Eclipse plug-in. In his blog, Martin announced the release of Teamprise 3.0, updated to take advantage of the new features in Team Foundation Server 2008.  This release contains some many impressive new features including check-in policy support, recursive folder compare, single sign on support on windows clients, and gui support for version control undelete and destroy commands. Perhaps the most impressive new feature is the full Team Build integration and the brand new Teamprise Extensions for Team Foundation Build, which allows developers to use Ant scripts with Team Build - amazing! Even better, Teamprise Extensions for Team Foundation Build, including source code, is available free of charge to everyone.

For more information, see Martin's announcement.

Last year I posted a note about how to integrate VSoft Technology FinalBuilder with Team Build. I really like FinalBuilder and think it's easy to use, compared with having to hand-jam the XML of MSBuild.

With the upcoming version 6.0 of FinalBuilder, this integration becomes a snap, even including a Visual Studio add-in for configuring Team Build.

Read this article for more information.

It's generally known that if you want to run any tests, code analysis, or database project build/deployment that you need to install one or more Team Edition of VSTS on your build server. What's not so well known are the licensing ramifications around these scenarios.

Fortunately Jeff Beehler, Team System Chief of Staff, has posted on this subject.

To summarize:

If the users creating the builds are licensed users of the edition in question (or Team Suite), that license extends to Team Foundation Build and you don't need to purchase an additional license. One way to think about it is: the people that are using the Team editions need to be properly licensed which in turn ensures the that the build machines are covered as well. Users who merely queue (execute) and review the automated builds are only required to have a Team Foundation Server CAL.

Have you ever had a production application in the data center act up, and you spend countless hours hunting down the source of the problem? If so, then then you might be interested in a new project on CodePlex called Design for Operations (DFO).

For years now engineers have been designing physical products with ease of manufacturing in mind. Called Design for Manufacturability (DFM), this technique takes fabrication and assembly into consideration early in the design process. DFM has a significant impact by improving the cost and quality of a product. Well, a variant of the technique has finally found its way to the world of software. Called Design for Operations, this technique allows software architects and developers to design their applications with built-in, real-time health monitoring, giving the operations staff much better operational information and improving the quality of service. According to William Loeffler, a Microsoft program manager:

It’s a recent effort from patterns & practices to provide tooling for architects and developers with a means to model their application in terms meaningful to operations. Once modeled the tool can be used to create a Health Model for the application and once the Health Model has been completed at the architect and development roles the tool can be used to generate platform instrumentation as defined in the model. All that’s necessary for the developer is to call the generated API within their solution for each instance of instrumentation. The tool will also generate a Management Pack for System Center OpsMgr 2008 from the model that matches the generated instrumentation.

For more information see:

http://www.codeplex.com/dfo

Hopefully DFO will become mainstream in the software development discipline, in the same way that unit testing has become popular.

Since first seeing the Code Metrics feature in the Development Edition of Visual Studio Team System 2008, I've been on a quest for bad (read: unmanageable) code. Rather than face the tool towards my code, I thought I would pick on Microsoft.

... and it looks like the EntLib has a maintainability index between 77 and 89.

Thanks to Ajoy krishnamoorthy for actually doing the hard work on this.

Back home now, and I have a moment to get the photos downloaded from my camera and uploaded to my blog. Next time I'll take my SD card reader with me.

As you can see, registration was quite busy. I heard that there were 4000 people there, but didn't count them myself. The long lines delayed the keynote by about an hour:

Douglas McDowell and I snuck into the press area. Well, he was officially press (SQL Server Magazine), but I wasn't - still I took more notes than most of the other pressies there.

The main screen was huge, and 3D. We estimated about 80' wide and 20' tall. When no slides were on the screen, there was a spinning 3D Earth enclosed in curley brackets. Hey, what about VB?

After the keynote, there was a short walk to the LA convention center, where the breakout sessions, chalk-talks, exhibitor area, etc. Fortunately, we had these interpretive dancers along the way to keep us from getting lost.

The line to lunch was too long, so we ducked inside to check out the exhibitor area.

I was there (where it says "You Are Here")

Attendees attending one of Doug Seven's chalk talks on Team System.

Doug was all about the writing quality code and the 3 C's in his talk (Code Coverage, Code Analysis, and the new Code Metrics)

After I turned in my evaluation form, I picked up the attendee bag, which had  lots of goodies, including a hard-bound, coffee-table style book called "Heroes Happen Here" which contains IT heroes from all around the world, photographed by Carolyn Jones. And yes, I got my book signed!

It's not much, but we heard that call that there "wouldn't be free coffee" at the Boise Code Camp 3.0 this coming March 8, so we're kicking in, so that we can enjoy free coffee. Ahem.

This way, we don't have to walk around with one of these things on our backs: