Manual Testing Code Coverage – Yeah! from Jeff Levinson
Jeff has a nice post showing how you’ll be able to enable and collect code coverage statistics in Dev11 for manual testing efforts. Code coverage for manual testing was promised many moons ago for MTM 2010 but it didn’t make it in the product, but you’ll be good to go in the next release.

Inside the C++/CX Design from Visual C++ Team Blog
Jim Springfield from the Visual C++ team has some details into the new language extensions in C++ called C++/CX. C++/CX was designed to support the new Windows 8 API model, and you’ll be able to start playing with it in the Dev11 Preview that was released at BUILD.

Coded UI Tests for jqueryui from Mathew Aniyan
If you’ve found yourself developing a bit with jquery, you’ll want to check this post on how to develop Coded UI Tests for web applications that have jqueryui widgets. Lots of details and code can be found at the link.

TFS Integration Tools – Can I Migrate All Work Items from One Team Project Collection to Another? from Willy-Peter Schaub
When it comes to TFS migrations, by far the most common scenario I encountered was the need to move work items from one TFS server to another or one TFS project to another. It’s common when teams collapse (or expand) their TFS installation and move from older versions of TFS to TFS 2010. In this post, Willy summarizes the different scenarios for migrating work from one TFS to another, and more specifically one TFS Project Collection to another. There’s also a bit about the limitations in this process, so you’ll want to give this a read if you’re planning a migration and need to understand your options better.

Multi-line Test Steps Available in Microsoft Test Manager, Among Other Things… from Brian Harry
Brian has a big announcement that a client patch is now available called the “Visual Studio 2010 SP1 TFS Compatibility GDR”. It just rolls off the tongue. There are number of bug fixes in this release, several that are detailed at the link, but the big news is that Microsoft Test Manager now supports multi-line test steps. I’d like to give the team a huge round of applause, but it’s my humble opinion that MTM should have never shipped without it. Still, better late than never and thanks to the DevDiv team for another out-of-band release that not only fixes bugs but also adds value.

Roslyn CTP Now Available from S. Somasegar
Soma has just announced the release of the Microsoft “Roslyn” CTP, which allows C# and VB compilers to be used as a service. Both of the compilers will have a complete rewrite for Dev11 with the C# compiler being written in C#, and the VB compiler being written in VB (as opposed to C++ for both). The result is that Roslyn compilers become services that can be consumed, opening an entire world for developers to provide tools analyzing code and compiler outputs. For more info, check out…

Roslyn Syntax Visualizers from The Visual Studio Blog
The Visual Studio Blog provides a getting started post to help you dive into Roslyn by taking a look at a couple of samples to develop Roslyn extensions. The samples included are a Syntax Debugger and Syntax Visualizer, and this post contains lots of info on both.

The Roslyn Preview Is Now Available from Eric Lippert
Eric also has a post announcing Roslyn and have some additional details about the scope of Roslyn and in what state you should expect to find the CTP. Also included are a number of links out to Roslyn related community pages, forums, and a Roslyn CTP Twitter feed. Dive in!

Windows 8 Development – First Impressions from Dan Hanan
I enjoyed Dan’s impressions on Windows 8 development and his explanation of contracts and his list of bugs he’s run into. Lots of code and details are at the link.

DemoMates for Visual Studio 11 ALM Demos from Brian Keller
Brian has the skinny on a number of DemoMates for the Visual Studio 11 ALM Demos that are part of the Visual Studio 11 ALM Virtual Machine. DemoMates are Silverlight-based renderings of a software demo that can be used to easily learn a demo or demonstrate it to an audience. Very cool stuff.

Introduction to Branching by Quality [Branching-Merging Techniques] from Tarun Arora
Tarun has a great exploration into the “Branch by Quality” branch pattern, where branching is done based on the phase of development for a specific set of code. It’s the most common branching story out there and one that I typically recommend because it jives with my “Scrummerfall” preference. Understanding branching patterns is critical to implementing a proper ALM solution, and unless you’re a branching wizard, you should give this a read.

Using NuGet and TFS Build 2010 from Richard Fennell
Richard has an interesting look at using NuGet in a TFS build and a couple of errors (and their solutions) that arose in a specific example he encountered.

Two Useful Extensions for Presenters Using VS2010 from Mark Pearl
If you’re in the habit of presenting and using Visual Studio 2010 during your presentations, you should check out the Presentation Zoom VS extension and the ZoomEditorMargin VS extension. Both are described in Mark’s post with screens and details at the link.

Visual Studio Architecture Tooling Guidance – How Important is the Guidance Extension? from Willy-Peter Schaub
The Visual Studio 2010 Architecture Tooling Guidance is one of the most popular and, as a result, it should be no surprise that the Visual Studio ALM Rangers have big plans for the next set of the guidance that is part of their Visual Studio 11 Readiness efforts. In this post, the “epics” that are part of the next set of guidance are defined as well as their priorities.

(External) Visual Studio ALM Ranger Champions 2011.2 are Known! Cowabunga! from Willy-Peter Schaub
Willy also recognizes the external (that means, the ones that don’t work for MSFT) Visual Studio ALM Rangers champions, Michael Fourie, Martin Hinshelwood, and Robert MacLean! All three have been long-time contributors to the Visual Studio ALM community and this recognition is well deserved. Congrats!

How to Change Test Scribe Template and Test Scribe – Developer Guide from Shai Raiten
Shai posted on how to change the Test Scribe template and ended up writing a developer’s guide to answer some of the questions he received via email. If you are looking to utilize Test Scribe and customize it’s output, you’ll want to read both posts. He provides a complete reference for both the images and strings Test Scribe uses, as well as an explanation of the command list.

Effective Stand-Ups from Robert May
I really liked this post on effective stand-up meetings and some of the dysfunctions teams doing stand-ups tend to face. I’m not a big fan of the gimmicks surrounding stand-ups and Scrum, as those are in place just to overcome most managers inability to conduct a meeting, but believe that daily, ultra-quick status meetings are indispensible for teams looking to regain control of their project. Even if you’re an old hand at Scrum, you’ll find something in this post worth your while.

Agile is for Your Whole Business from Joel Semeniuk
I really liked this post from Joel on Agile software development and its application to your entire business. I’m actually a partner in a health and fitness business and have been thinking quite a bit about how to apply Agile concepts to what we do.

Test Case Management (TCM) Reporting - Frequently Asked Questions - Part 1 from Visual Studio Team Test
This is a great post answering a few frequently asked questions about Test Case management and reporting with Microsoft Test Manager and Visual Studio 2010. Using reports and data effectively seems intuitive, but its been my experience that most teams are very ineffective at not only gathering effective quantifiers to manage their team but then using that data once they have it.

Anatomy of a Good Bug Report from Tim Heuer
Tim shows us the anatomy of a good bug report by describing what she be in it, which fields should be required, and what a good bug report looks like. I worked for a company many moons ago that rewrote it’s “bug template” multiple times to overcome issues where people weren’t entering good data in bugs. In reality, the biggest impediment to creating and using bug reports wasn’t the specifics of its contents but rather the discipline of the team to enter effective data and then use it. So standardize on something (like Tim’s recommendations) and then actually use the damn thing.

Using the HTML 5 File API to Read the file Contents from The Problem Solver
It’s post like this that make me want to drop everything and focus entirely on HTML 5. Here, we get a look at reading file contents using the HTML 5 FileReader API.

How We Review Code from Lee Winder
Code Reviews are probably the least understood, and therefore least effectively quality control tool that teams use. How a code review is of extreme importance, and can take code reviews from being a complete waste of time to being the most important part of your development process. To understand the different types of code reviews and how they can be used, check out this great post describing different review strategies.

What is New in VS TFS 2011 Part 2 and Part 3 from Tarun Arora
Tarun continues his excellent series on the new goodness in Team Foundation Server 11 by showing off the features that pertain to Testers, Business Analysts, Project Managers, and TFS Administrators. A lot of ground is covered, and if you’ve ignored TFS 11 up until this point, this series is a good place to get started catching up.

Building with VS11 and Team Foundation Service Preview from Bryan Group
I’ve linked to a bit on this subject before, but Bryan’s post on TFS Build and Team Foundation Service is the most complete I’ve seen yet. He shows how to set up TFS Build with TF Service and also walks through queuing and monitoring your builds.

Why Does My MS Project Run So Slow When Connected to TFS from Donovan Brown
Donovan has a quick tip to help out MS Project performance when you’re using MS Project with TFS Work Items.

The Three Things We Need at Work from Chad Moore
I really liked this post from Chad Moore on the three key factors to creating a productive and profitable workspace. Chad is in game development, but the factors he highlights (autonomy, mastery, and contribution) are universal to all teams. This is definitely worth a quick read.

Using the TFS API to Display Results of a Hierarchical Work Item Query from Colin Dembovsky
If you’re querying data with the TFS API, you’ve probably figured out that RunQuery() won’t work for a tree or direct links query. To overcome this, Colin has put together some code that will allow you to query hierarchical work items and has lots of details and screens at the link (downloadable code too).

How Windows 8’s Memory Management Modifications Make for a Better User Experience from Ars Technica
Ars brings us a great read explaining the memory management story in Windows 8 and how it claims to be even more efficient than Windows 7. I’m a big Ars fan and think you should be to, so set a bookmark.

Windows 8 and the Up and Coming Hardware Revolution from Keith Elder
I really liked Keith’s post on how Windows 8 will juggle the traditional PC and the tablet interface, and his thoughts on the perfect computer. He also links to a really cool BUILD presentation titled 8 Traits of Great Metro Style Apps. It’s worth your time if you’re trying to get your head around where Microsoft thinks the future is going, at least where interfaces are concerned.

Things I Wish I Knew Earlier from Zachary Hoefler
This is a terrific post with some nuggets on Zach’s experience at an internship and what he wished people had told him up front. I’ve been at it a lot longer than Zach, but I can vouch that there is incredible wisdom in what he says and that every programmer should give it a read. There’s greatness in the comments too.

Visual Studio 11 Developer Preview: Search Everywhere from The Visual Studio Blog
The search story in Visual Studio has gotten much better in Dev11, and the Visual Studio Blog has all the details.

What is New in VS TFS 2011 Part 1 from Tarun Arora
Tarun has an incredible post, the first in a series, showing off the new features and capabilities of Team Foundation Server 11. This post provides a broad look at the focus of TFS 11 and then dives into a number of specific features, including the new Team Explorer, Code Review capabilities, version control improvements, and much more.

Building Windows Phone Apps with a 64-bit Build Agent from TFS Build from Paul King
Developers have run into a host of issues trying to use TFS to manage builds for Windows Phone applications. In this post, Paul walks you through getting everything set up by showing you how to resolve one issue where you need to specify which version of MSBuild to run during the build process.

Announcing Wrox's Professional C++, 2nd Edition from the Visual C++ Team Blog
Mar Gregoire announces the release of his book, Professional C++, Second Edition, which includes bits on the latest C++ standard, C++11. You can get a copy on the Kindle (or other digital book readers) as well. Odds are, this one will make it to my shelf.

Database Changes Between TFS 2010 and TFS 2011 from Tarun Arora
Tarun has put together an incredible post outlining the database changes that were made between TFS 2010 and TFS 2011 and which feature those changes pertain to. It’s a neat peek behind-the-scenes as to the scope of the changes and how you can access that data.

How Do I: Use the web.config Transforms in Visual Studio 2010 from Chris Koenig
Chris Koenig, our local Microsoft Developer Evangelist here in Dallas, has a succinct video showing off how to use the web.config transform feature in Visual Studio 2010. Web.config transforms help deal with the classic problem of having different web.config files and settings for different environments. These transforms are essential to teams with ALM needs that involve different environments depending on the maturity of a specific feature or release.

Visual WIP Beta 2 is Now Out! from Hakan Forss
A second beta of Visual WIP, a Kanban visualization tool for Team Foundation Server that gives visibility to your Work in Progress, has been released. This project has definitely shaped up over its lifetime and there are lots of new features in this release as well as a number of bug fixes. Details and screens can be found at the link.

5 Things You Might Not Know About Visual Studio from Gustavo Samour
Visual Studio is massive and very complex, so it follows that your experience using Visual Studio may be drastically different from others. Consequently, you might be missing out on a number of useful tools and features. This post outlines five things you might not know about Visual Studio, but should know. Also check the comments for a few additional nuggets that might be useful.

Improving Developer Productivity with Visual Studio 11 Developer Preview from The Visual Studio Blog
The Visual Studio Blog breaks down how Visual Studio 11 Developer Preview increases developer productivity and how Visual Studio’s performance has been improved. Details and screens can be found at the link.

A Custom Data Diagnostic Adapter for Visual Studio Coded UI Test using Windows PSR from Visual Studio ALM + Team Foundation Server Blog
This is a neat post that shows how the Windows Azure AppFabric Product Group developed an automated UI test framework using the Windows Problem Steps Recorder. They’ve made the project and code available over at Codeplex, and in this post they show off code, screens, and details on how it works.

Build 2011 – ALM Wrap-up from Bryan Group
Bryan recaps BUILD and provides links to all of the major news related to developers that was released at the conference. If you’re looking to start diving into the news and bits from BUILD, start here.

TFS Azure: Set Up Visual Studio 2010 to Work with TFS Azure from Tarun Arora
Tarun walks you through you through, screen-by-screen, how to set up Visual Studio 2010 to work with TFS Azure.

Creating Custom Team Foundation Server Reports from Bryan Group
Bryan has a great post walking you through how to create your own custom TFS report. In his example, he creates a report to show which work items are assigned to which team members and the area and iteration they’re contained within. If you’ve looked to create your own reports, you’ll want to give this a look.

What's New in the Visual Studio Team Foundation Server 11 Developer Preview from Visual Studio ALM + Team Foundation Server Blog
Check this post for a look back at a lot of the new goodness that can be found in the Visual Studio Team Foundation Server 11 Developer Preview that was announced at BUILD. It’s been a few weeks now, but if you’re still trying to get caught up (like me), you’ll find lots of interesting stuff at the link.

Visual Studio 11 Developer Preview: Find & Replace from The Visual Studio Blog
An overlooked new feature in Dev11 is the new streamlined and modernized the Find and Find and Replace interfaces for Visual Studio. The Find and Replace capabilities in Visual Studio are immense and used by every developer slinging code, so it follows that there are LOTS of details, screens, and changes you’ll definitely want to check out.

Good Collaboration: Bringing Devs and Testers Closer from Jim Holmes
I really liked this post from Jim Holmes on how to encourage developers and testers to work more closely with each other to influence the quality of software. I definitely have a few nits I could pick with his approach, but that doesn’t change the fact that figuring out ways to get developers and testers to work together better to increase quality and productivity is the goal we are all striving towards. Good stuff.

Team Build: Building Code with Visual Studio from Tiago Pascoal
Tiago has a terrific post on on building code with Team Build for projects that aren’t supported by MSBuild. I’ve been doing this for a long time, and still learned a lot about how TFS Build works and how to leverage the tools better in scenarios that aren’t directly supported. This is definitely worth a read, even for the most skilled build ninjas.

Community TFS 2010 Build Extensions – September 2011 from Mike Fourie
I’ve linked recently to a few posts that mentioned the new release of the TFS Build Extensions, but never linked to the announcement itself. In this post, Mike provides a link to the new release and a preview of what’s coming in the next release, which is targeted for December.

Utility to Manually Refresh the TFS 2010 Warehouse from Benjamin Day
Ben has created a utility to let you refresh the TFS 2010 Warehouse via the push of a button. Details, screens, and a download link can be found in the post.

A Pre-Commit Checklist from Ivan-Assen-Ivanov
I really liked this post which provides a pre-commit checklist to help improve your defect resolution process. It’s thorough while still being succinct, and is probably worth printing and taping to the wall in your developers’ workspace.

Rangers Flash – September 2011 from Willy-Peter Schaub
Check this post to find out what the Rangers were up to in the month of September, including updates for CodedUI guidance and the Word4TFS projection.

Hands On Intro to Blend for HTML – Video Plus Code from BlendInsider
The official Microsoft Expression Blend team blog has a video from BUILD where Christian Schormann presented a deep dive into Blend for designing Metro-style applications with HTML. He shows step-by-step how to use the Blend preview so download and follow along to get up to speed.

How to Enable Code Coverage in my Team Build from Donovan Brown
If you’re looking to get code coverage statistics from your build process, you’ll want to check this post from Donovan Brown that includes a video showing you how to make that happen.

Seeing Loads of ‘Cannot Load Load Assemblies’ Errors when Editing a TFS 2010 Build Process Workflow from Richard Fennell
Richard ran into an issue with the Community Build Extensions where the build workflow he was working on reported a “Cannot Load Load Assemblies” issue. He shows how he diagnosed and fixed the issue, using Process Monitor.

MTM Testing Scorecard using TFS API from Tarun Arora
Tarun Arora keeps knocking posts out of the park with this continuation on his series using the TFS SDK and the TFS API by showing you how to programmatically build a test scorecard. Lots of code, screens, and details can be found at the link.

Visual Studio 11 Programming Language Advances from S. Somasegar
Soma shows off some of the new programming language advances in Visual Studio 11 by highlighting the advances made with JavaScript and the Visual Studio editor, asynchrony in Visual Basic and C#, C++ and parallelism, and F# and data access.

Program Management – Thinking About PM != PM and the PM Role in Microsoft from Willy-Peter Schaub
I really liked this post, which explores the job of the “Program Manager” at Microsoft and how it corresponds to how the Visual Studio ALM Rangers conduct business.

CUIT Demo of Feature Pack 2 Coded UI Test Editor from Donovan Brown
Donovan has recorded a great video that shows off some of the new capabilities of Coded UI Testing in the recently released Feature Pack 2 that helps you deal with issues where tests are failing on playback. Titled “Solving Real World Recording Issues”, you’ll definitely want to watch this video to help you better utilize the Visual Studio automated testing features.

TFS SDK Get Groups Users Permissions Using TFS API with Linqpad from Tarun Arora
Tarun continues his excellent series on the TFS API by showing you how to get security groups, members, permissions, and security settings of users in Team Projects in TFS. Lots of details, screens, and code can be found inside.

Windows Phone SDK 7.1 Now Available! from The Windows Phone Developer Blog
Windows Phone users are being treated to the Mango release, which apparently is quite good, so it follows that developers now can get the Windows Phone SDK 7.1! Download it here and get to work!

GoingNative Live at BUILD: Herb Sutter, Joanna Mason, Tony Goodhew and GoingNative 2: C++ at BUILD, Windows Runtime Library (WRL), Meet Tarek and Sridhar from C9::GoingNative
C9::GoingNative, Channel 9’s show that exclusively focuses on C++ development for Windows, has two new shows examining all of the news and new stuff that came out of BUILD. You’ll hear about C++11 compliance in VC11, the Windows Runtime Library, and much more.

Local Workspaces from Ricci Gian Maria
I’ve linked to a number of stories on local workspaces, but you’ll find quite a few new nuggets in this post including a comparison to SVN, screens, and more. If you haven’t read about local workspaces, you’ll also find a nice overview to help explains why this new feature is likely the most important change in the TFS 11 version control system.

Empty Groups Not Being Expanded in a Combobox for a TFS Work Item from Richard Fennell
This post deals with a problem old school TFS guys have seen since the very beginning, and that’s when empty groups are not expanded into a combobox for a TFS Work Item field with an Allowedvalues list. Check the post for details and the solution.

I Don’t Want Entity Framework Code Counted in Code Coverage from Donovan Brown
Donovan shows us how to exclude code from code coverage metrics, and more specifically he shows how to do so with Entity Framework.

Team Foundation Server on Windows Azure: A Rangers Dog Fooding Perspective from Visual Studio ALM + Team Foundation Server Blog
Visual Studio ALM Rangers lead Willy-Peter Schaub has a great article on the Rangers’ efforts to dog-food Team Foundation Server on Windows Azure. It’s an interesting look at real-world TFS Azure use and may open your eyes to some of the potential the hosted TFS platform has.

Book: Agile Software Engineering with Visual Studio from Neno Loje
Neno brings word that the book he co-authored with Sam Guckenheimer, Agile Software Engineering with Visual Studio: From Concept to Continuous Feedback, has finally been released. It’s been a long time coming, but it’s something I intend to dive into shortly. The original was one of my favorites and it’s clear a lot of work went into making this one every bit as good. Neno provides a look at the table of contents, a description of the book, and what’s covered.

How to Test Deep Hierarchy Controls Using Coded UI Test in WPF? from Deepak Singhal
Some developing custom controls that have a deep control hierarchy have been frustrated at trying to use Coded UI Tests to automate the testing of those controls due to bugs. A few months ago, Microsoft released a hotfix that attempts to resolve these issues. This post helps you determine whether your issues will be resolved and what type of benefits the hotfix will provide.

Visual Studio Macro to Group Files from Ricci Gian Maria
This post provides a quick Visual Studio Macro that will allow you to take advantage of the file grouping feature used by code generation tools that you often see in Solution Explorer by grouping your own files together however you see fit. Details, screens, and code can be found at the link.

Build HTML 5 Apps with Expression blend for Windows Developer Preview from BlendInsider
The Microsoft Expression Blend Team Blog links out to a terrific MSDN article on using the new Expression Blend 5 Developer Preview to build HTML 5 applications. Also included are a number of links to additional resources on Metro-style applications and Windows 8 interface development.

Visual Studio 11 Developer Preview: Quick Launch from The Visual Studio Blog
Visual Studio 11 introduces a new feature called quick launch, which provides a means of finding things that might be buried deep in the IDE or things that are just obfuscated by all of the noise in the Visual Studio interface. There’s a lot more depth than you think to Quick Launch, so take a look at the post (from Zain Naboulsi) for details.

Page Inspector for Visual Studio 11 Developer Preview from Web Development Tools @ Microsoft
Another new Visual Studio 11 feature is the introduction of the new Page Inspector. Page Inspector brings browser diagnostics into Visual Studio and (long overdue!) provides an integrated experience between the browser, ASP.NET, and source code. This post contains a mountain of details and also points out a few known issues you should be aware of. You can also download the Page Inspector via the Web Platform Installer from this link.

Wrapping Performance Testing Introduction: What to Monitor (Plus Learning Resources) from Jim Holmes
Jim finishes his performance testing series over at Telerik’s automated testing blog by examining what to monitor during a performance test and where you can learn more about the philosophies and nuances of performance testing.

The Dismal Science of Code Metrics from Andrew Binstock
And as an extra link for no additional cost, I’m pointing you to this article over at Dr. Dobb’s on code metrics and their limited utility. I can’t count the times I’ve seen metrics misused and abused. It always reminds me of the Benjamin Disraeli line (via Mark Twain) that there are “three kinds of lies: lies, damned lies, and statistics.”

Top 10 Visual Studio Links for Monday, September 26th from Rob Caron
I’ve linked to Mickey Gousset’s great blog, where he often links out to posts in the community (similar to how I do), but I wanted to also pointed you towards Rob’s blog where he often will post the top 10 Visual Studio links for a given day. Today he links out to a number of items you’ve yet (but will) see here and provides a different style of highlighting community information. If you’re subscribed here, you should do yourself a favor and subscribe over there as well.

Building Metro Style Apps with C++ and JavaScript from the Visual C++ Team Blog
Microsoft has significantly re-emphasized C++ development with Windows 8, so if you’re a C++ developer you’ll want to watch this Channel 9 video on developing Metro Style Apps with C++ (and JavaScript).

Syncing the Build Number and Assembly Version Numbers in a TFS Build When Using the TFSVersion Activity from Richard Fennell
Richard shows off the extensibility of build as well as the wonderful tools available via the community when he uses the TFSVersion community extension to make the TFS build number the same format as the assembly build number. There are some hiccups, but it’s a good exploration of TFS Build and using a build extension to solve problems.

Team Foundation Server Team Project Guidance … We Have a Phenomenal Team! from Willy-Peter Schaub
Take a detailed look at one of the the Visual Studio ALM Rangers’ new projects, the Team Foundation Server Team Project Guidance, which will deliver practical guidance and scenario-based guidance through the decisions of whether to have one or more TFS implementations, one or more TFS Project Collections, one or more Team Projects, and one or more teams. This guidance will be more difficult than you think, as typically there are no “right” answers. Typically, I advised my clients on the strengths and weaknesses of different approaches, and also advised them that they would likely make whatever they eventually chose “just work”. I can’t wait to see the finished product.

Understanding our Visual Studio 11 Readiness Conspiracy
Latest Readiness Adventure Part 5 … More Newcomers
Latest Readiness Adventure Part 6 … the Complete Picture from Willy-Peter Schaub
As you can see from three links, I had a lot of catching up to do for all of the new and updated project announcements from the Visual Studio ALM Rangers. Here you’ll find a complete list of upcoming Rangers projects (they have become quite prolific) including an explanation of the projects that relate to Visual Studio Dev11 features.

How to Run the Same Test in Different Lab Environments? from Visual Studio Lab Management Team Blog
One of the key benefits of Lab Management for many teams is how to run the same test in different lab environments (and, likely, different environmental configurations). This post leads you down the path of how to make it happen.

I Need to Show TFS History of a File on the Command Line So I Can Redirect to a Text File from Donovan Brown
Donovan explores the TF History command and how to redirect its output to a text file. This will be especially useful if you need to see the version control history of a file but want it output in a manner that allows you to search through the results.

Deep Dive in Process Template’s States and Transitions from Ricci Gian Maria
It’s been a while coming, but we’ve finally got the next in this series of process template modifications via a deep exploration of process template states and transitions. Specifically, it deals with states and transitions using the process template editor, as opposed to showing the raw XML. I prefer hacking the XML, but if you’re new to process template editing, you’ll want to do something similar to what’s described in the post.

Installing TFS 11 Build Server from the BUILD Conference in Anaheim from Visual Studio ALM + Team Foundation Server Blog
Tim Elhajj shows off the installation process for the TFS 11 Developer’s Preview Build Server with a step-by-step, screen-by-screen view of the process. Details, screens, and more are at the link.

Installing TFS 11 Extension for SharePoint from the BUILD Conference in Anaheim from Visual Studio ALM + Team Foundation Server Blog
Tim also shows off how to install the TFS 11 Developer’s Preview Extension for SharePoint that was released at BUILD. Again, screens, details, and more are at the link.

TFS11 and Source Control Improvements from Richard Banks
Richard provides a peek into what is probably the most anticipated version control improvement in TFS 11: local workspaces.

Windows Update (KB2468871) Interferes with TFS 2010 (w/o SP1) from Northwest Cadence
The crew from Northwest Cadence lets us know that the latest Windows Update related to .NET 4.0 (KB2468871) will cause problems with builds that will fail or simply hang. The solution is to get TFS 2010 SP1 installed on the build server (or servers) to solve the problem.

Manual Testing Tools for Windows 8 Metro Style Applications from the Visual Studio ALM + Team Foundation Server Blog
So you think you’re team is ready to start developing Windows 8 Metro style applications, but how are you going to test them? This post shows how to use Microsoft Test Manager to connect to a Windows 8 device to perform manual testing and file rich bugs. Details, screens, and lots of cool stuff can be found at the link.

Customize Your Test Case Work Item Template to Enable Query on Test Suites, Test Plans, Test Categories and Execution Statistics from Visual Studio Team Test
This is a long overdue post showing you how to customize a Test Case work item enable querying for test cases based on the test suites, test plans, test categories, and execution statistics related to a Test Case. If you’ve never customized a work item before, you may be in a bit over your head (just give me a buzz and I’ll get you pointed in the right direction), but the payoff of these customizations – assuming you are using Test Case work items – is immense.

Convert NUnit to MSTest Unit Test from Shai Raiten
Shai tackles a problem I dealt with a few times at client sites where NUnit test suites were converted to MSTest Unit Tests in order to take advantage of the easy integration between build and MSTest. Shai maps references, attributes, and assertions to get you moving. His post won’t deal with every NUnit test scenario that might be in your library, but in my experience it will handle the vast majority and the remaining few will be pretty easy to figure out.

Web Test Recorder Not Shown in Internet Explorer When Recording Web Performance Test from Syed Aslam Basha
If you’re recording Web Performance Tests in Internet Explorer and you don’t see the recorder add-in, you’ll want to read this post on how to enable it. You need to manage the add-on and make sure it’s enabled.

The New Team Explorer in TFS 11 from Brian Harry
Brian provides a deeper look at the new Team Explorer that comes with TFS 11 and many of the new features associated with it, including the new home page, search capabilities, work management capabilities, code review tools, build status management, performance improvements, extensibility, and much more. The new features and usage scenarios now supported are much needed, and really introduce a much deeper work management and communications experience in Visual Studio. Of all of the new goodies coming in TFS 11, the new Team Explorer is the one you’ll end up appreciating the most.

Getting Feedback on Working Software with Visual Studio 11 from Visual Studio ALM + Team Foundation Server Blog
The Visual Studio blog has more on the feedback feature in Visual Studio 11 and TFS 11 by walking through the feedback workflow and providing on overview of the goals of the feedback tools.

New HTML Editor feature in Visual Studio 11 Developer Preview from Web Development Tools @ Microsoft
Microsoft has clearly, and finally, fully embraced HTML as the interface of the future by providing significant improvements in HTML editing in Visual Studio 11. This post discusses many of the new HTML editing features, including HTML5 snippets, IntelliSense for code nuggets in attributes, smart indent, event handler generation, and much more. Lots of details and screens are at the link.

IntelliTrace in Production with VS11 CTP from Larry Guger
Larry takes a look at IntelliTrace in Visual Studio 11 by examining the “IntelliTrace in Production” scenario shown at BUILD.

GPU Debugging with VS11 from Daniel Moth
Daniel shows off the C++ AMP debugging experience with Visual Studio 11 and provides code, a sample, and a video link to his BUILD session on the same subject.

Windows Server 8: Built for the Cloud, Built for Virtualization from Ars Technica
I’ve seen lots of talk about Windows 8, but not so much about Windows Server 8. In this article, Ars lays out the focus of Windows Server 8 and how it fits into the future of computing.

Dev11 Preview is Out – First in a Series from Jeff Levinson
Jeff highlights a feature of TFS and VS vNext I haven’t seen yet, by diving into the new Feedback tool. A big focus of TFS and the next generation of Microsoft ALM tools is improving communication within teams and with customers and stakeholders. That’s where the feedback tool comes in.

Build Deploy Test Enhancements from Rob Maher
Rob continues his discussions on Build-Deploy-Test by showing off some enhancements he’s made to his own custom code activity that better enables Build-Deploy-Test scenarios. It’s been a while since his last post on the subject, so if you used his previous workflow activity or think this might help you, take a look.

Having Trouble Testing my WPF App with Coded UI Test from Donovan Brown
Lost in all the noise about Windows 8, Visual Studio vNext, and TFS vNext are a number of great posts helping you use your existing tools better. In this post, Donovan shows you how to improve your Coded UI testing experience with WPF by advising you to set the Name attribute on controls you are testing. He shows you what’s happening behind-the-scenes that makes this worthwhile and how it will make your tests easier to modify.

TFS Azure – Technical Access Preview Experience from Tarun Arora
Tarun gives us a run-down of the experience of using TFS on Azure. He’s been a part of the program for six months now, and has been nice enough to provide a step-by-step getting started guide as well as an overview of his experiences.

Visual Studio vNext: Concurrency Visualizer from Channel 9
Channel 9 has a great video showing off the latest concurrency visualization and debugging tools in Visual Studio vNext. Unless you’ve been sound asleep for the last 5 years, you’ll know that a big part of getting the most out of hardware is dealing with concurrency issues, so check this out to see how Visual Studio will be assisting you.

An MSDN Library for the Windows Dev Center from Jeff Braaten
Jeff highlights the new Windows Dev Center and its four sub-centers: Metro style apps, Internet Explorer, Desktop apps, and Hardware. He answers why the new, integrated library experience was created and explains the scoped library design principles.

TFS 11 – Teasing Local Workspaces from Mickey Gousset
We’ve linked to posts on local workspaces in TFS 11 before, but you should check out this screenshot from Mickey showing the new “Workspace Settings” option showing you how you’ll toggle between local and server workspaces. I agree with Mickey – offline TFS just got a lot better (thank goodness).