In a larger project, I got the following error message:

Visual Studio could not open the file "c:\TestAutomation\BuildVerificationTests.orderedtest" because the file contains tests. A test can be opened only within a test project. Add the file to a test project, add the test project to the open solution, and then try again.

Reason: The solution contains a service model (Service Factory). Right-clicking and selecting Unload Project (on the service model) fixes the problem with not being able to open the ordered test.

If your Team Build informs you that "The following fields have incorrect values: ..." you are most likely the victim of someone modifying the Bug work item type, adding mandatory fields without default values.

Resolution: <SkipWorkItemCreation>true</SkipWorkItemCreation>

Adding an alert via the Team Foundation Power Tools Alerts Editor (October 2008) is innocent enough:

If you close and reopen the Alerts Editors, the alert definiton is still there (in the above screenshot for "A work item was assigned to me"). However, closing & reopening VS is a different thing - now your alert definition is gone - poof, vanished mysteriously.

It took a while and quite a bit of searching, but finally I found out why and made a slight change:

The username that is pre-filled in in the "Send to:" field doesn't work - you have to use your email address! That much for trusting defaults, but I'm more than happy that it now works as advertised.

I have created another (hopefully useful) checkin policy for Team Foundation Server 2008 - one that checks C# and VB.NET project files for COM references. The idea came from a customer, where they require the developers to use "authorized" interop assemblies instead of developers recreating those by simply adding a COM reference to each and every project. And how do you prevent this? By having a TFS checkin policy in place.

A COM reference looks like this in an MSBuild project file:

  <ItemGroup>
    <COMReference Include="XcpControlLib">
      <Guid>{283C8576-0726-4DBC-9609-3F855162009A}</Guid>
      <VersionMajor>1</VersionMajor>
      <VersionMinor>0</VersionMinor>
      <Lcid>0</Lcid>
      <WrapperTool>tlbimp</WrapperTool>
      <Isolated>False</Isolated>
    </COMReference>
  </ItemGroup>

Instead of searching for the string "<COMReference" I decided to use the MSBuild Engine API in my implementation:

          
            public
            override PolicyFailure[]
Evaluate() { PendingChange[] checkedFiles = PendingCheckin.PendingChanges.CheckedPendingChanges;
ArrayList failures =new ArrayList(); foreach (PendingChange
change in checkedFiles)
{ string extension = Path.GetExtension(change.LocalItem); if ((0
== String.Compare(extension, ".csproj", false))
|| (0 == String.Compare(extension, ".vbproj", false)))
{ if (change.ChangeType
== ChangeType.Edit || change.ChangeType == ChangeType.Add) { //
this is a workaround because project.Load(fileName doesn't work in the same process
as VS FileStream fs = File.OpenRead(change.LocalItem);
Project project =new Project();
project.Load(new StreamReader(fs),
ProjectLoadSettings.IgnoreMissingImports); foreach (BuildItemGroup
big in project.ItemGroups)
{ foreach (BuildItem
bi in big)
{ if (0
== String.Compare(bi.Name, "COMReference", true))
{ PolicyFailure failure =new PolicyFailure(String.Format(ComReferencePolicyStrings.activateMessage,
change.LocalItem), this);
failures.Add(failure); } } } } } } return (PolicyFailure[])failures.ToArray(typeof(PolicyFailure));
}
        

At first, I tried to load directly from the .??proj files, but Visual Studio (after thinking a bit about it it is pretty obvious...) doesn't like someone inside its process play around with the MSBuild engine. That's why I resorted to loading it indirectly.

For installation I have provided checkinpolicy.reg, however, you must adapt the path to the .dll before importing it into the registry.

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\9.0\TeamFoundation\SourceControl\Checkin Policies]
"ChrisOnNet.CheckinPolicies.ComReferencePolicy"="C:\\Work\\ChrisOnNet.CheckinPolicies.ComReferencePolicy.dll"

Once registered, you can add it to your team projects:

As usual I have included the source code (BSD licensed) in the download:

ChrisOnNet.CheckinPolicies.ComReferencePolicy.zip (35.35 KB)

Today is the last leg of a total of four stations of this year's Big>Days (Helden von Heute) event from Microsoft Austria. I am speaking in the developers track on ALM (Application Lifecycle Management) with Visual Studio Team System (and beyond) together with Georg Drobny from MS Consulting Services. We only have seventy minutes to get this topic across, which really is a challenge when covering such an important topic. But so far, we managed to overrun our alotted time only very little. Let's see how it works out today.

It's been quiet on this blog recently, one reason being that it is conference season again. Last week, I was in Munich for VSone, where I did three talks:

• LINQ to SQL
• ADO.NET Entity Framework
• ADO.NET Data Services

At this very moment, I am at the airport in Frankfurt waiting for my flight back from the ready.for.take.off Visual Studio 2008 / Windows Server 2008 / SQL Server 2008 launch event here in Germany. It was the biggest developer event in Germany so far (7000+ conference participants), and Microsoft gave away quite a nice package of software: VS Standard, TFS with one CAL, Windows Server 2008 Enterprise with 5 CALs plus a voucher for SQL Server 2008 that will be available later this year.

I was staffing ATE (Ask the Experts) at this event, initially for IIS7. However, we were very pleasantly surprised that the attendees showed great interest in TFS / VSTS, so I switched duties to that area (VSTS / TFS is a growing business for me as I do training and consulting for those products). Hopefully this free license will trigger more adoption because Team System is such a great tool!

I updated the TFS Code Comment Checking Policy so that it works with VSTS 20008 RTM. The downloaded labeled as Beta 1 comes with the well-known setup, the changes to the August test version are only minimal: the parser has been updated (to better support C# 3.0), and all projects now target .NET Framework 3.5.

Please use the discussions to report any issues you find.

Been following tf4mono development for quite a while, and now there is an installer that works on Windows with .NET 2.0 (more info). Be sure to check out the comments as it doesn't seem to work on a machine with Team Explorer already installed.

I ran into a snag last night - I imported a db schema (created via Visio / Generate) into a DB Pro project in VS 2008 Beta 2 DB Pro edition. Then I tried to build & deploy into SQL Express (the one that comes in the TFS / VSTS preconfigured VPC). And it balked.

The error message on TSD158 I got wasn't like the one described in the MSDN Forums post Extending Timeout on SqlBuildTask, however, I decided to look into the registry anyways. Interestingly enough, the value for the key LongRunningQueryTimeoutSeconds was zero. Increased that to 120, restarted VS, presto: build is now working!

Yesterday, I adapted the code comment checkin policy for Team Foundation Server to work with VSTS 2008 ("Orcas") Beta 2. It is functionally equivalent to version 2.1.1 (download) for Visual Studio Team System 2005, therefore you configure it once for a team project, and then it is used both by 2005 & 2008. However, please note the parser doesn't yet fully understand all C# 3.0 constructs, so there might be "false positives".

Download test version here.

The check-in policy for TFS is revved to v2.1 and it comes with the "Included Paths" and "Excluded Namespaces" features announced earlier on my blog. The release announcement has more details; also, take a look at the screenshot tour of configuring CCCP.

When I released version 2.0 of the TFS CCCP, I also previewed one feature of the planned 2.1 release: included source control paths. That prompted a comment by Klaus that excluding namespaces for eg auto-generated code (think CodeSmith or code generated by GAT / GAX guidances) would be a nice feature too.

So I carved out some time today, and built the UI plus added the necessary code changes. To give you an idea what it will look like, here is a screenshot:

To do: testing, documenting, packaging.

Today, I finally released v2.0 of the code comment checking policy for Team Foundation Server (TFS) / Visual Studio Team System (VSTS) 2005. Two major new features: firstly, you can extend the policy to do more restricitive checks (i.e. verify that the comments are actually in line with the number of parameters). Secondly, you now get an MSBuild task to compute "code comment coverage" during an automated build - independent of VSTS / TFS!

As for future versions, it is already in source control - take the following team project for example:

Currently, you can turn on / off CCCP only for the entire team project. However, checking a unit test project or a Windows Forms smart client is rather pointless (in my opinion at least):

It is much more helpful for library projects that are to be used by different in-house or external customers, where with the help of eg Sandcastle you can create a nice help file. Therefore, vNext will sport a "Paths to check" feature:

I decided to go with include instead of exclude because it is much more explicit with regards what is being checked and what not. Currently, this is only available via source download.

Jimmy Li's article Understanding the TFS Cube gives great insight into the warehouse for Team Foundation Server. Well worth your time if you want to dive into analyzing your projects.

Today, I uploaded a preview of version 2.0 to CodePlex. There are two big ticket new items in comparison to version 1.3:

• Plugin support The TFS checkin policy only tests for existence of code comments. For many applications, this is just fine. However, sometimes you also want to test for completeness of comments (i.e. a refactoring "broke" the documented parameter list). In this case you can use the new extensibility API, which comes with two sample plugins in the cccplibcontrib project. The API allows you to select which checking you want to override or complement, and you get full access to the parsed source file just like the stock implementation ("abuse" for non-code commment checking purposes obviously possible too). If you come up with a cool plugin, be sure to contact me for inclusion into the contrib project!
• MSBuild task This build task lives in cccplib, which is entirely independent of TFS or VSTS (it was written by Matt Ward). Therefore, you can use it eg with CruiseControl.NET or simply as part of the local .*proj files. What's the purpose of this build task anyways? Simple: as part of the build, you get information on "code comment coverage", just like you do with let's say code coverage and unit tests. Currently, you only get an XML file with the report - if you are XSLT-savvy and want to contribute a HTML report transform, let me know!

To get an overview what v2 looks like, how to configure it, etc you might be interested in this demo screen recording.

Please see http://blogs.msdn.com/bharry/archive/2007/04/17/configuring-tfs-to-use-sharepoint-2007.aspx

Buck Hodges has a blog entry on this acquisition. To quote the most interesting part for everyone: "Effective today, TeamPlain is available, at no additional charge, to users who own a Team Foundation Server". If you need a Web interface for TFS, go get it!

Want to know what's next? Check out http://msdn.microsoft.com/teamsystem/futures/

World and dog has been reporting about the Orcas March CTP, so I'll stick with reporting news on released technology: the Visual Studio 2005 SDK Version 4.0 is here. Why is this important? It has all the cool stuff in it for extending VS, VSTS and TFS SP1.

Yesterday was the last day of VSone, the German .NET conference featuring almost all  well-known German speakers. As I had hinted at earlier, I did three talks there, and I still owe the audience of my VSTE DbPro talk a couple of resource links:

• Sachin Rekhi's blog
• Samples project for Microsoft Visual Studion Team Edition 2005 for Database Professionals
• A Security Overview of Microsoft Visual Studio 2005 Team Edition for Database Professionals
• Introducing Visual Studio 2005 Team Edition for Database Professionals (if you weren't awake at this time in the morning <g />)

Once again, the TFS installation guide has been updated (2/5/2007). Download here

This is so totally pathetic: rolling back a changeset in Team Foundation Version Control. A decent version control simply must have a revert story - mistakes do happen, and when you need to revert a check-in that for the sake of an example has 20+ files associated, the advice in the aforementioned how-to definitely will drive your blood pressure up.

Instead of developing a medical condition, you can go for tfpt - the Team Foundation PowerToys. The command tfpt rollback is your friend.

Shortly after Christmas last year, I started with the Code Comment Checking Policy (read about it here, here and here) for Team Foundation Server. The idea for it was based on Florent Santin's TFSCCPolicy, but it used an entirely different approach (full-blown parser instead of RegEx).

As I never intended to compete with him (after all, we are both MVPs), I contacted him informing him of my endeavours. He liked the approach I took, and offered me take over on CodePlex because he had little time to spend on it anyways. So, at long last, today I set up shop as project coordinator at TFS Code Comment Checking Policy, Formerly Known as TFSCCPolicy.

The latest binaries are available, as well as the source code checked into the repository. If you have ideas on how to improve the feature set, let us know in the User Forum. Same goes for joining the team or letting us know about blog posts or tutorials you wrote.

From the "outsmarting yourself department": Yesterday, I installed Team Explorer on my machine to get access to a CodePlex project. Easy enough, at least that's what I thought. So after installation I went to Visual Studio to configure the server connection, but I ended up not being able to connect:

As I was in a hurry anyways, I decided to leave it at that. Fast forward a few hours, to a different location: a pub. I was discussing IT problems with a friend, and at some point we got to firewalls. That's when I went "Bingo!" - this Vista machine has Privoxy installed, to "emulate" Firefox's Adblock extension (Privoxy does a few things more - check their Web site, it's free). And IE7 is configured to use it as proxy server.

So first thing today was to get back into Visual Studio, try again, and then check the Privoxy logs:

Note to self: The TFS client APIs use Internet Explorer settings when it comes to connecting to the Internet, and Privoxy positively strips requests of certain headers.

Fixing is easy: Tools / Options / Environment / Web Browser:

And then add exceptions for all the TFS servers you need to access:

Security does tend to get in the way. Nothing new here.

Yesterday I finished the first TFS / VSTS course of this year, and I had rebuilt my demo machine with TFS / VSTS SP1 and Office 2007. I have to say that Excel 2007 really shines when you slice & dice the TFS warehouse's cubes. If you are in the PM business on projects, you definitely should upgrade to the new version of Office!

Updates

• TFSCCPolicy and CCCP Merge

As promised, the latest version of CCCP now sports a setup program. Setup is based on WiX, and has been created using SharpDevelop's WiX support. A special thanks flies out to Matt Ward, who provided me with the initial skeleton of this setup project. Please note, however, that you must use the bits from our build server because Beta 3 of SharpDevelop 2.1 doesn't work correctly with this setup project (\Source\Setup\Cccp.Setup.sln).

To give you an idea of the WiX project editing experience inside SharpDevelop I have included two screenshots for you (Matt promised a tutorial for his blog):

Above you can see the project tree plus the main WiX file, below the editing experience for the files included in the setup project:

There are four assemblies included in this setup project, with three being installed to the GAC - only cccppol.dll is copied to the target directory, and it has a registry key associated that enables the policy within VSTS. This is a change to previous versions of the policy that used ILMerge to pack those four assemblies into one.

The only other main change over previous versions is configuration:

The new options make hard-coded values from previous versions accessible to the administrator. Please note that this will force you to remove & then add the policy back to your team project if you used previous versions of CCCP (serialization changed).

I also put together a short screen recording on getting up and running with CCCP (sorry for the low audio quality, but I didn't manage to get Vista & my headset to cooperate nicely):

CCCP12InAction.wmv (1.58 MB)

Finally, here are the downloads:

CCCP12.msi (626.5 KB) [Windows Installer as demonstrated in the video]

CCCP12_Source.zip (1.06 MB) [Source code, BSD-licensed]

With this release I declare the CCCP feature-complete, at least when it comes to the features that I need. If you have further ideas for improvement, let me know by adding a comment to this post. If you find bugs, please let me know too. Oh, and if you like it, let others know!

Post Scriptum: yes, the MSBuild task hasn't been implemented yet. But the policy is done.

You will have to wait till next year to get this (and more) new functionality for the Code Comment Checking Policy. For example, a WiX-based setup:

Also in the box now: version information to easily see which assemblies are currently in use when you are adding the policy:

Also, there are a few changes to the configuration of the policy. Note that this will require you to remove & add the policy back to the team project's source control settings. The new defaults are the same values as the previously hard-coded configuration:

So check back next year!

Work progressed much faster than I thought, so I can present you today with the next iteration of CCCP, the Code Comment Checking Policy for VSTS / TFS. What is new and improved over yesterday's release:

• VB.NET code comment verification enabled
• Code comment statistics tracking implemented, off by default
• Reference.* excluded (Web Services auto-generated files)
• Visibility special-casing of class type removed, CodeCommentCheckingVisibility honored
• Refactoring of CheckCodeComments, CreateInstance added for cleaner construction
• Unit testing automated and initial tests added
• Use String.Compare instead of == where potentially case sensitive or culture dependent

This equates to: the policy itself is feature-complete! It now sports the following functionality:

• Code comment verification for C# and VB.NET using a real parser engine
• Options to enable verification based on elements (methods, ...) and visibility (public, ...) - note that C# and VB.NET is auto-detected, no need to enable or configure this

Not included is "double-clicking policy violation automatically positions cursor on offending element" (I'd need to take a dependency on VS, and quite frankly have no idea how to implement this using VS' object model). Remaining on the todo list is the MSBuild task for calculating code comment coverage, but this will take a while because firstly I am not really that firm with writing MSBuild tasks, and secondly I will have to spend more quality time with IIS7 in the near future.

Without further ado, here are the goods:

• CCCP11_20061228_SetupOnly.zip (238 KB): Contains cccppol.dll, a .reg file and ReadMe.txt. Follow the instructions in the latter to modify the .reg file, and then double-click the .reg file to register the version control checkin policy.
• CCCP11_20061228_SourceSetup.zip (1.49 MB): Includes the above plus all the source code (BSD-licensed). This is a complete build tree minus only one tool: ILMerge. This must be downloaded separately. Please see the Source folder for the solution file, and PostBuild for instructions on how to build the final cccppol.dll assembly.

Further information:

• CCCP - Code Comment Checking Policy aka "Policy Triple-Slash" for VSTS / TFS, the initial post about the making of the checkin policy.

Updates

• 2007/1/21: TFSCCPolicy and CCCP Merge
• 2007/1/1: CCCP 1.2 Available With Setup (this is the latest released version)
• 2006/12/28: A newer version supporting VB.NET is available

The idea for this VS Team System version control checkin policy came up in the week before Christmas when I was pointed to one of the shortcomings of TFSCCPolicy, namely that it would flag commented-out methods as missing code comments. That triggered me looking at the source code and I saw that it was using regular expressions.

Why use RegEx when you can use a full-blown parser engine with a DOM? Well, that's what I thought and therefore got in touch with Daniel, technical lead of SharpDevelop. We discussed two potential ways: either going to the metal using NRefactory alone, or go it easy using the DOM and visitors. He even supplied me with a few lines of code to get started - of course for the latter option because I am a lazy coder.

So I set out yesterday to write that checkin policy. To make it really useful, I set up a library project which would contain all the logic, a unit test project for it, plus the actual policy project. The advantage? Well, the logic library can be reused in an MSBuild task, the idea is as follows: calculate the "comment coverage" just like you can do with code coverage and unit testing. (Sorry, but this isn't part of the package just yet)

Given that plan, I of course got around to the policy project as the last one today. When I was pretty much done, I set out to test it for the first time inside VSTS - whoa, what a surprise. It balked almost immediately. You can read my quest for enlightenment here, the main takeaway: don't outsmart yourself when you create a checkin policy which consists of multiple assemblies that don't live in the GAC.

That way I at least got around to deploy my first project using ILMerge. There is only one downside to using ILMerge - the merged assemblies don't retain their version numbers, which can be seen in this screenshot of the configuration dialog (NRefactory should be 2.1):

Aside from this minor glitch, the checkin policy is working fine. What can it do / what can't it do at the moment:

• It is currently limited to C#. VB.NET will be added later, all I need to do is instantiate the parser. It is as easy as that.
• Auto-update when files are saved. Someone please hit me with the clue stick.
• It doesn't exclude all auto-generated files, just the .designer files like TFSCCPolicy. I need to sit down and make a list.
• Not all elements correctly report the line number.
• Unit tests - well, only one at the moment. More to follow of course, including the full build automation.
• Cleanup in the logic library.

Other than that I would love to get feedback from you on this initial version! Simply post feedback on this blog entry.

Finally, the source code (BSD-licensed by the way) and the binaries:

CCCP10_20061227.zip (964.34 KB)

If you are interested in using it only, then please go to the Drop directory. For those interested in the code: start with the solution file in the Source folder (and then go to Setup).

Updates to the code / checkin policy will be linked to at the end of this post, so feel free to bookmark this blog post for your reference on CCCP.

From Express to Team Suite & Team Foundation Server. Get it here

The Feature Specifications for Visual Studio and .NET Framework "Orcas" page has a document on it entitled Get Latest on Check Out. The reason I bring this up is that I had been asked during TechEd in Barcelona at the ATE booth (by a fellow ATE) whether the default behavior for Team Foundation Version Control (TFVC) - make the current version of the file in the workspace editable - can be changed to get latest first, then make editable. 

The problem that prompted the question is that more often than not, a developer is likely to forget to do a Get Latest first and only then start editing. If forgotten, this can lead to unnecessary merge operations. The good news is that the feature will be available, the bad news is that it isn't today.

At next year's VSone in Munich (a German developer conference taking place in February), I will be doing three talks:

• Visual Studio 2005 Team Edition for Database Professionals
• User Account Control (UAC) in Your Applications
• Advanced Code Access Security (CAS)

Two security topics, one team-development focused. See you in Munich!

The versions 4.1 of MSF for Agile Software Development Process and MSF for CMMI Process Improvement contain updated guidance for Data Dude (VSTE for Database Professionals). In addition to this, be sure to check out David Anderson's interview on Channel9: Thoughts on Visual Studio Team System and "Dark Matter" Iteration Forecasting. In this interview, he is talking about MSF backgrounds, and why he is interested in scaling agile to the enterprise level - and he has a new blog post up on this very topic. So if you are interested on why the software 'guys' should be playing on the team, be sure to check out the interview, really great background information in there (oh, and don't miss out on the lean project management slide deck).

Namely Visual Studio Team Edition for Database Professionals. This needs either SQL Server Enterprise or Developer Edition. Of course I had Standard and Express on my machine only...

It's two weeks in Barcelona for me - and for IT Forum, I am really doing ask-the-experts for Visual Studio Team System!

I will be in Barcelona next week for Tech·Ed: Developers. You can get in touch with me at the Team System booth (Tuesday afternoon & Friday morning) of the Ask the Experts pavilion.

Update Actually, I am assigned to the ASP.NET booth as it turns out.

From the "Summer of Books": I just finished reading the book Software Engineering with Microsoft Visual Studio Team System. Great (project management) book, even if you never plan on using VSTS. As there are other reviews online (Mike's and one that includes an interview with Sam Guckenheimer on TSS), I'll simply stick with a "highly recommended".

The concept of shelving was made popular by Visual Studio Team System's source control system - it allows you to "shelve" your changes for a couple reasons, like:

• You have to work on a bug fix immediately, but you are in the middle of implementing a new feature. You cannot check in those half-baked changes, only the bug fix. So you shelve your feature work. Once done with the bug fix, you unshelve the feature work and continue.
• Sharing work. Another developer needs the changes you are currently working on, but you are not yet done. So you shelve your changes and the other dev unshelves them and can get productive immediately.
• Code review. Instead of having someone come over to your office (or worse, email the files) to review the changes before checkin, you shelve them and the reviewer can unshelve them.
• Backup. How many times do you leave your workplace with a feature not yet completed? What to do with this build-breaking half-baked work? Shelve it!

Now you get the idea why shelving is pretty neat. Even Subversion does support the concept although it is not explicitly there: the blog posts Shelving in Subversion and Shelving Subversion show how you can make shelving happen with Subversion.

Tracking down the URL for the Webcast Detecting and Debugging Common Application Issues Using the Windows Application Verifier really turned into a scavenger hunt today... if you don't know what AppVerifier is, download it here, and read more here.

This download contains the agile process guidance that will be shipping with Visual Studio Team System.

Next week, I will be in Rosenheim, Germany for the ADC 2005. I'll be teaching the Visual Studio 2005 Team System Hands-on workshop (Tuesday as well as Friday), plus doing two talks during the main conference: IIS 7 and ASP.NET 2.0 Health Monitoring. See you there!

I already have one box (the Shuttle XPC) that is running Windows Server Codename Longhorn Build 5219. Because it wasn't all that much of a hassle when compared to Beta 1 of Windows Vista, I decided to set up Longhorn on my laptop - and try to work with that installation for a week, while I am in Seattle for the MVP & AspInsiders summits. Boy did I end up with an installation marathon...

Lessons learned in this Sunday's "don't try this at home kids" department:

• Don't assume that ATI drivers for your IBM X31 will install on Longhorn. They refuse, making for rather crappy UI performance. By the way, on failing, setup suggests to install a VGA driver first.
• None of the network adapters were found - neither the onboard LAN, nor the onboard WLAN. When you peek into Computer Mangement, it is your guess which of the two "Ethernet Controller" is which.
• Don't only update the driver for one, even if it is the LAN one. Your ISA 2004 client installation will mysteriously fail. After installing drivers for all LAN equipement, it just works.
• Minor annoyance: the OS-provided sound driver produces hisses et al. Not too bad, but annoying if you plan to watch loads of Channel 9 movies. Your guess is correct: the vendor-provided driver refuses to install.
• No standby. That sucks royally.
• You learned about that in my previous post - no .NET 1.1 for you by default.
• Installing VS can be so much fun, especially if MSXML 6.0 refuses to install as part of the default install. Doing it separately works so much better. And the "Locate File" dialog for the VM driver irritated me only for the better part of a minute...
• Before installing the Atlas VSIs, you better start VS at least once. Otherwise the Atlas installation will fail. Only mildly interesting.
• Do I need to mention that Virtual PC networking doesn't work? That one didn't change for the better, which will make me dual boot into XP.

On a different note: default installs of 5219 have a blank password for Administrator. And IIS 7 is installed by default, which really baffled me. I'm so trained to enable features after install that at first I was thinking it was not part of the bits I got...

The PDC today officially kicked off with a keynote by Bill Gates. To me, the more interesting parts came later in Jim Allchins keynote: Atlas, Windows Communication Foundation, Windows Presentation Foundation as well as C# 3.0 & LINQ. However, Office 12 does look very promising too. Can't wait to get my hands on that beta (never expected to say that about Office, ever).

In the afternoon, I attended the following breakouts:

• Behind the Scenes of Visual Studio 2005 Team Foundation Server
• Windows Server “Longhorn”: What's New for Developers
• Windows Presentation Foundation ("Avalon"): A Lap around the Windows Presentation Foundation

Looking forward to tomorrow, because Windows Workflow Foundation will be revealed at the keynote (aka general session).

I promised two things during today's webcast The build system of Visual Studio Team System: links to get started with MSBuild as well as the samples I presented. Let's get started with the easy part, the samples:

VS05BetaExperienceWebcastMSBuildSamples.zip

And here are some useful links for your start into MSBuild:

• MSBuild Wiki
• MSBuild Wiki External Links and Resources
• The Road to MSBuild
• TaskSchema, a XSD schema generator for MsBuild tasks

That's it. You might also want to check out my link list for last week's webcast, Profiling for Visual Studio 2005 Team Systems Beta Experience.

Just minutes ago, I finished my Webcast on Profiling with Visual Studio Team System, which is one in a series of Webcasts for MSDN Connection Service: Visual Studio 2005 Team Systems Beta Experience (MSDN Deutschland). As promised, here is a list of links that prove to be invaluable when navigating the "bits":

• The Profiling Team’s Greatest Hits: Volume One
• The Profiling Team’s Greatest Hits: A Few More Hits
• Make Your Apps Fly with the New Enterprise Performance Tool
• Rico Mariani's Articles and Recommendations
• Select team member blogs: IanWho, Angry Richard, SCarroll
• Enterprise Performance Tools Team Blog
• And last but not least the most important newssource for Team System in general - Rob Caron's Blog

That should get you started with profiling. Next week's topic is "The build system of Visual Studio Team System".

As everyone is blogging about the obvious, I will stick to the more interesting bits (in my opinion, of course). For example, the updated Visual Studio 2005 Team Foundation Server Installation Guide.

This is the most current version of the Team Foundation Installation Guide for the December 2004 CTP release of Visual Studio Team System. It contains any changes that were made to the guide since the public release of the December 2004 CTP release of Visual Studio Team System.

You can download two PowerPoint slide decks from Visual Studio 2005 Team System presentations at DevConnections in Las Vegas (November 2004):

• VMS352 - Visual Studio 2005 Team System: Software Project Management
  In this session you will learn how to take advantage of the combined power of Visual Studio, the Microsoft Office System, and industry proven practices to successfully manage software projects—from conception to deployment.
• VMS355 - Visual Studio 2005 Team System: Enterprise Class Source Control & Work Item Tracking
  This session introduces the new Team Foundation Server in Visual Studio 2005, including the new Source Code Control, Work Item Tracking and Team Portal. See how an integrated and extensible server-based system will boost your team’s productivity by significantly streamlining your development processes.

The walkthroughs are located on GDN as a project. It says "These walkthrough projects will help you exercise the functionality of Visual Studio 2005 Team System. These walkthrough projects support the walkthroughs on unit testing, web testing, load testing, profiling and code analysis that appear in the Visual Studio 2005 Team System documentation."