bharry's WebLog

Make sure your SQL Server enterprise edition is up to date

2012-02-01T20:26:00Z

A month or so ago we started seeing crashes on the SQL Server associated with one of our dogfood TFS servers. The crashes ultimately resulted in us having to restore the database from backup. It was a significant work disturbance and an important thing to avoid.

We diagnosed the problem in tandem with the SQL Server team and discovered it was due to a SQL Server bug in tables using page compression. That feature is only supported with SQL Server Enterprise Edition and above – but, that’s what we use. TFS ships with SQL Server Standard Edition so the vast majority of customers won’t be affected. You’ll only be affected if you separately obtained a SQL Server Enterprise or above license and installed it and pointed TFS at it. Further, it only applies to you if you are using TFS 2010 or a preview of TFS 11. We added support for SQL compression in TFS 2010 - before that (TFS 2008 & 2005, we didn't make use of the feature).

Fortunately, SQL has released a fix for the problem.

If you are using SQL Server 2008 Enterprise Edition or above with TFS, you need to update to SP1 CU6 (Apr 7, 2011) or SP2

If you are using SQL Server 2008 R2 Enterprise Edition or above with TFS, you need to update to either RTM CU7 (Jun 16, 2011) or SP1 CU1 (Aug 25, 2011)

You can read more about it in the KB article here: http://support.microsoft.com/kb/2668489. You’ll also find links to the appropriate updates there.

I apologize for the inconvenience.

Brian

Kicking myself

2012-02-01T20:16:22Z

I kind of checked out of the blogosphere just before the holidays and haven’t resurfaced. I feel bad about it. I will say I had a good holiday. I took a full 2 1/2 weeks off and did pretty much nothing but farm work. It was a great vacation. It’s the longest I’ve been away from work in a very long time.

When I got back in January, things were busy. we’re now updating the hosted service weekly with “major” updates every 3-4 weeks. Plus we’re busy locking down to ship VS11/TFS 11 Beta. Plus it’s performance review season and on and on. I won’t bore you to death. It’s just been busy and blogging has suffered. I’ve queued up quite a few topics to talk about in the mean time so hopefully I can get through several things in the next couple of weeks.

Brian

December 2011 TFS Power Tools Release

2011-12-16T13:18:37Z

In the last release of the Team Foundation Server 2010 Power Tools we focused on improving the experience for developers in Visual Studio and using the Shell Extensions inside Windows Explorer. Today we just released a new update of the Team Foundation Server Power Tools focusing on developers outside of Visual Studio with the following improvements:

Team Foundation Server Power Tools for Eclipse (Download)
MSSCCI Provider for 64-bit IDE’s (Download)
VS 2010 Power Tools update (Download)

Power Tools Come to Eclipse

We are completely committed to ensuring that developers outside of Visual Studio have great access to TFS and that includes bringing Power Tools to these developers when appropriate. Today we made a new Power Tool download available as an Eclipse update site. Simply install as you would a normal Eclipse update archive and you will be given the chance to install the following 3 tools

The first one to mention is the Alerts Explorer. In Team Explorer Everywhere 2010 SP1 there was no way for a developer to sign themselves up for alerts from TFS. Rather than bring the simple alerts experience over that ships in the box in Visual Studio 2010 we decided to bring over a version of the enhanced rich Alerts Explorer experience from the Visual Studio version of the Team Foundation Server Power Tools. In TFS 11 we’ve put the alerts experience on to the web but we didn’t have to make our Eclipse developers wait for that, hence the decision to add it to a Power Tool release. Once installed, simply right click on the Team Project Collection in Team Explorer and select “Alerts Explorer”.

This will then query your alert subscriptions and give you an Alerts Explorer editor for you to manage and create new alerts for your user id.

If you create a new alerts you get to pick from one of the templates defined and customize the alert filters to suit your needs. Alerts created in the Visual Studio Power Tool are editable by the Eclipse Alerts Explorer and vice versa.

Also in Eclipse we’ve added a new Work Item Templates tool. If you find yourself creating lots of the same work item type (such as a Bug) and setting certain fields to the same value then this is the tool for you. You create a template work item and can organize these in folders etc. Then when you want to create a new work item using that template simply right click on it and create a work item from that template. There is even a handy action to give you a link to TFS Web Access with the fields set that you have defined in your template – a great way of sharing a link with users of your application inside the company to make sure bugs they file go against your area path etc (we use exactly that feature to make it easy for people internally to log bugs against the Power Tools when we are dogfooding them)

Finally, in Source Control Explorer we have added the ability to find files in the repository by file name or find files checked out by a particular individual.

Note that all these features were added by making use of extensibility points as documented in the TFS SDK for Java. If your company or group has functionality that they want to build on top of Team Explorer Everywhere and Eclipse then you have access to all the same calls that we used to create the Power Tools.

64-bit MSSCCI Support

We also made the one of our most significant updates to the MSSCCI provider for TFS 2010 in recent times by adding support for 64-bit applications wishing to use the MSSCCI provider. While the MSSCCI API was written as a 32-bit interface some IDE’s (most notably Matlab) have released 64-bit versions of their IDE’s and they still wanted to use MSSCCI to talk to version control providers. This allows people to do some really big math and use Team Foundation Server for version control of their models – highly important in the aeronautical engineering sector among others.

VS Power Tools Improvements

As well as the usual round of bug fixes and improvements, we’ve also made some small incremental changes in a few other areas. For example, in the Work Item Search functionality for Visual Studio that we first released in August, there was no easy way to use the search text box to search for a work item by ID. Lacking this was a bit of an oversight – sorry about that, but it’s fixed now. Now, when you enter a number in the work item search box, it will open the work item with that ID rather than searching for text matching the number. If you do want to search for text matching the number, just put the number in double quotes (e.g. “42”) and it will do a full text search rather than just using it as a work item ID. This capability is also now going to be in the search box of the new Team Explorer in VS 11.

Early this year, we released TFS integration with Project Server. In this release of the TFS Power Tools we have added rules into our Best Practice Analyzer to help check that common configuration issues with the Project Server integration to make sure everything is set up correctly and help diagnose any issues. This work was based on the excellent work that our support organization do every day working with real customers, so by running the Best Practice Analyzer against your TFS server you get to benefit from their years of real world diagnostic tips and tricks.

Conclusion

Right now, I’m thinking this will be the last Power Tools release for the VS 2010 wave of products. After the new year, we are going to turn our attention to getting all of the Power Tools working seamlessly with VS/TFS 11 (and removing all the ones that have now been added to the product ).

Please give the latest release of the Power Tools a try and let us know what you think. Your feedback has been essential in ensuring not only that we are able to continually iterate and provide value on top of TFS 2010 but that we can learn from that feedback and incorporate lessons learned into subsequent releases of the product.

Brian

A new invite code for the Team Foundation Service

2011-12-09T15:58:00Z

Yesterday I wrote about the updates we’ve made to the service with our December update. Today, I’m here to deliver on the promise of providing another invite code that people can use to sign up. If you’ve already created an account, there’s no need to use this code. Your preexisting account is still working and has been upgraded to the December release. Just sign in and take a peek. If you don’t yet have an account, feel free to use this code to create one at http://tfspreview.com.

The invitation code is: TfsDecUpdate

In the next couple of days I’ll write a post about our experiences with our first major upgrade since going public. It’s been fun.

Enjoy!

Brian

December refresh of the Team Foundation Service

2011-12-08T19:41:40Z

Today we are updating the Team Foundation Service (running on Azure) with a new build. You can read more about the features in the new update on the Visual Studio ALM blog. The process of updating all of the accounts is ongoing as I type this. It will take most of the day and maybe into tomorrow to finish updating them all. In the meantime, you’ll see much of the new UI but if your account hasn’t yet been updated, you won’t see all the features.

We started the service in April of this year and ran a private pilot program for several months. Then, at the BUILD conference in September, we announced it and made available a bunch of registration codes for people to try it out. Since then the service has continued to grow. We’ve been giving out new registration codes at conferences (I gave out several hundred in Europe over the last couple of weeks) and people have been sharing the “social codes” they get when they sign up for an account.

All in all, the feedback has been good – meaning both that people seem to like it and that they have good ideas on how we can improve it. As part of transitioning from just building an on premises product to also building a cloud service, we’ve been changing the way we think about developing and releasing software. Since the build conference, we’ve managed to get to a cadence of weekly updates to the service. For now these updates are just bug fixes and operational improvements but it’s significant that we’ve gotten the development, QA and release cycle down to updating every week. Our larger updates, like this one, are less frequent. We’ve been updating the service about every 3 months since we launched it in April with significant new feature work.

Of course, “significant” takes on a different meaning when you are talking about a few month’s worth of work rather than a couple of years . We are now trying to transition our “major” update cycle to monthly. I won’t promise that we’ll have major new features every month but we’re going to try to move to a cadence where we have new features show up in more months than not. We’ll see. This whole exercise is a bit of a learning experience for us and it’s been both fun and exciting. At the last couple of conferences I’ve spoken at, I’ve started to share some of our learnings from moving to delivering a service. Sometime in the next few weeks I’ll try to write up a blog post about it.

By tomorrow afternoon I’ll be posting another registration code that new people can use to get an account. Stay tuned.

As always, we look forward to your feedback.

Brian

Expanded hosted TFS offering from DiscountASP.net

2011-11-09T15:52:00Z

DiscountASP.net just recently expanded their hosted TFS offering. You can read more about it on their site and on their blog post.

I can imaging people might wonder why I’d talk about this when I talk so much about our current hosted preview service. Let me give a few reasons why you might want to use a service like the one from DiscountASP.net over the TFS on Azure preview we are currently doing. I don’t claim it to be a complete list but rather just what comes to the top of mind at the moment.

1) DiscountASP.net’s solution is a production service based on a released version of our products. I’d expect their service to be more reliable and to involve less frequent churn.

2) They provide reporting and Sharepoint integration for TFS. Our current hosted preview does not.

3) They provide a build services. Our current hosted preview does not.

4) They provide more data center options today.

5) They provide some VSS migration services.

6) Integration with 3rd party offerings like Urban Turtle.

Etc.

It’s a good option for organizations who are looking to have someone else manage their TFS infrastructure to consider.

Brian

Traveling this fall

2011-11-09T13:20:36Z

Next week I’m getting ready to hit the road for a bunch of conferences and customer visits. I’m looking forward to getting out and talking with people about what they are doing and what’s coming in VS 11.

It all starts with the ALM Summit in Redmond 11/15 – 11/17. There we’ll have a bunch of people passionate about application lifecycle management, and particularly Agile processes, get together and discuss where the industry is going.

The following week I’m headed to Germany for ALM Days 2011 11/23 – 11/25 in Munich. Yes, much to my surprise, this actually means I’m going to be in Germany giving a keynote address on Thanksgiving day. Go figure. Germans don’t celebrate Thanksgiving? My mom was none too happy about this The ALM Days conference (formerly known as TeamConf) is your chance to experience the next generation of development tools for Windows, Web, Phone and the Cloud live. There are keynotes and technical talks by Sam Guckenheimer (who can actually speak German) and me, as well as from many local German speakers like Microsoft’s Chris Binder and independent TFS expert Neno Loje, who just co-authored the new book on modern application management with Sam Guckenheimer (by the way: every ALM Days attendee will receive a free copy of this book). We also working hard to make sure every participant will get a free access code to our http://tfspreview.com. So if you are from Germany or will be in Germany in November head over to the conference website and get a ticket: www.almdays.de

Over the weekend, I’ll be heading to Zurich for a Swiss ALM Days event. It will be similar to the German event but a bit shorter (and I think Sam won’t be able to make it – so you’ll have to settle for me ). While I’m there I’m going to be spending some time with a few customers and visiting with Erich Gamma to see how his new Swiss lab is coming along.

Finally, I’ll be headed to the Netherlands for one more ALM event and some customer visits on the 30th of November.

It’s going to be a whirlwind trip but I’m looking forward to it. If you get a chance to make it to any of the events, I’d love to spend some time talking.

Brian

TFS Databases growing out of control

2011-10-31T12:25:38Z

Several months ago I first started hearing customer reports of TFS databases growing out of control. Every once in a while I’d hear of someone with a database growing by 100GB a week or something equally nutty. Previously that had been the result of someone checking in crazy amounts of data – A few years ago a similar report turned out to be someone checking in 75GB of slide decks from a conference they went to

That turned out not to be the case this time. After some investigation, we realized that the problem was data associated the TFS’s testing features. TFS and Microsoft Test Professional gather very rich data to enable you to do deep analysis of test failures. The cost is that this rich data is large. However, it turns out, much of this data lives long past its usefulness because we really don’t have any process to clean it up.

I first realized how serious it was when someone mentioned to me that on our own server, test attachment data had gotten larger than any other TFS data store. If you’ve followed my blog over the years then you know that our server is pretty dang big (terabytes) that the version control data dominates everything else. When I found out that test data had passed version control data, I knew we had a problem that needed to be addressed quickly.

Our first step was to release a tool we call the “Test Attachment Cleaner”. This tool enables you to define your “retention policy” and automate the clean up of old test attachment data. It helps a lot. Below I refer to a blog post from Anutthara that has links to all of the tools/updates that I refer to here, including the Test Attachment Cleaner. Sadly one or two of our early customers with particularly larger databases and tons of test data, using the Test Attachment Cleaner discovered a bug in SQL Server that causes deleted records to not actually get deleted – and therefore space is not reclaimed. We worked with those customers and the SQL team to diagnose the issue, get a fix get it released. You’ll find reference to this in Anutthara’s post as well.

While the Test Attachment Cleaner was a good start, it was clear that just approaching the problem by providing ways to prune out old data was not enough. We’re clearly shoving too much data into TFS and not all of it is terribly useful or efficient. Hence the next step is a newly released QFE for TFS that avoids uploading binaries associated with executed tests. We’ve found that in practice, very few people use the features that require them. Looking at some internal TFS databases, this saves on average about 48% of all test attachment data. That’s half the data that will never get uploaded in the first place.

We continue to investigate ways to reduce the amount of disk space used by test data – by uploading less, storing it more efficiently or pruning unused data.

You can read more and get links to the various tools and updates from Anutthara’s blog here: http://blogs.msdn.com/b/anutthara/archive/2011/10/30/gsjgd.aspx

Brian

Lab Management improvements in TFS 11

2011-10-31T11:55:36Z

The Team Foundation Server 11 Developer Preview introduces a number of simplifications and enhancements in Lab Management. The primary one you will notice in the developer preview is the introduction of 'Standard environments'. Here is a brief summary of what Standard environments are and what you can do with them.

Ever since we released Lab Management we’ve gotten feedback from a segment of our customers that they love the Lab Management promise but aren’t ready to bite off SCVMM & Hyper-V. Some people use VMWare other just want to just automate the physical machines they use today. Standard environments now enable more flexibility, allowing you to use VMWare, physical machines, etc.

Standard environments help you quickly get started with testing on multi-machine environments and to be able to run functional automated tests as part of continuous integration cycle. You can get started with creating standard environments the day you setup your TFS. You do not need to setup Hyper-V servers or configure System Center Virtual Machine Manager in TFS. With standard environments, the whole process of creating an environment is a matter of a few simple steps.

1. Configure a test controller for your team project collection. All projects within the collection can share this controller. Or, you can scale up by adding more controllers.

2. Let us say you want to setup a 2-machine environment for running post-build automated tests - a client running Windows 7, and a server running Windows Server 2008 R2 SP1 to act as the web server and database server. Have these machines provisioned from wherever is the norm in your enterprise - this could be your IT managed lab, VMWare VMs, physical machines, or anything. Install the pre-requisites needed for your application on these machines.

3. From the Lab Center in Microsoft Test Manager, run the wizard to create a new Standard environment. As part of this wizard, specify the names of the machines from (2) above, and an administrator credential to connect to those machines. If you want to run Coded-UI tests as part of automation, then select that option in the 'Advanced' tab of the wizard.

4. That’s all you have to do in order to create an environment. You will notice that a test agent automatically gets downloaded and installed in all machines of the environment. This is the only agent that is needed in Version 11 of Lab Management in order to deploy builds or run tests. At the end of the creation process, your environment should be "Ready" for use.

5. Ensure that you have a test plan with automated tests as well as a test settings to run those tests on the environment.

6. Create a build definition using Visual Studio Ultimate 11 Developer Preview and choose LabDefaultTemplate.11.xaml as the template. This is the new build-deploy-test automation template that allows you to select a standard environment for running your automation.

7. Queue the new build, and see how the automation runs on the environment.

To summarize, the whole process of installing agents and preparing an environment that is ready for build verification is done with a few clicks. You do not need to setup SCVMM environments in order to use build-deploy-test automation features. A 'standard' environment will suffice.

Of course, SCVMM environments are still supported, and have been enhanced as well to support auto-installation of agents. With SCVMM environments, you get the additional benefits of using snapshots as part of your testing scenarios.

Here are a few common questions that you might be seeking answers to:

1. The Developer preview of Lab Management does not yet support Windows 8 Servers, Windows 8 guests, or SCVMM 2012 Release Candidate. Support for these is in the works.

2. The whole process of auto-installing the agent and configuring it is streamlined only for domain-joined machines (that have a trust relationship with Test Controller) in standard environments. If you are using workgroup machines in standard environments, you still have to setup shadow accounts.

3. The only supported operating systems for machines to be used in standard environments are Windows 7, Windows Server 2008 SP2, Windows Server 2008 R2, and Windows Server 2008 R2 SP1.

For more information, see: MSDN documentation.

Brian

Multi-line test steps available in Microsoft Test Manager, among other things…

2011-10-19T20:02:06Z

Along with the launch of the Team Foundation Service preview we announced at the BUILD conference, we released a new client patch for the VS 2010 family of products. You can get it here: http://go.microsoft.com/fwlink/?LinkID=212065&clcid=0x409 (or you can find the link on the Team Foundation Preview service web page).

You’ll see that it’s called “Visual Studio 2010 SP1 TFS Compatibility GDR” but it’s actually got a few things of interest in it. It’s a roll up of recent fixes and improvements. Here’s a list of the most significant ones:

The update gets its name from the fact that it includes changes necessary to the 2010 client to allow it to work with a TFS 11 server – including our Team Foundation Service Preview.
The biggest “news” is the addition of support for multi-line test steps in Microsoft Test Manager. It’s mentioned in the #1 suggestion for Visual Studio Test and Lab Management. I’m super excited about being able to bring this feature out quickly.
KB2522890 – Team Explorer Crashes when opening build from TFS 2008
KB2552300 - Gated Checkins fail with the “Preserve local Changes” option
KB2561827 – DiffMerge closes with unhandled exception when comparing two files.

Yes, I know, I know, the KB article hasn’t been published yet. This was the last straw for me and I’ve raised a bit of a ruckus about it. I think I’m getting the attention of the right people to start fixing this problem. I’ve set a clear goal to have the KB articles available the same day the update is available.

Brian

ALM Summit 2011 in Redmond – Nov 14-18

2011-09-19T14:13:53Z

Now that BUILD has wrapped up and hopefully most of you are busy trying out the VS 11/TFS 11 developer preview, I wanted to let you know about an event that I will be speaking at in November. At the ALM Summit in Redmond, November 14-18^th, we get a chance to talk about the process of making great software. We intentionally had fairly light coverage of our V.Next ALM plans at the BUILD conference because it we heavily oriented towards the new Windows 8 capabilities. The ALM Summit is really the next time where we’ll get to go deep on our future ALM plans.

Last year was the first year of the ALM Summit and we got terrific feedback from the attendees about the event and how to make it even better for this year.

This year’s event has a great speaker line-up that includes Jason Zander, Scott Guthrie and Mark Russinovich among others that will talk about Agile, Scrum, and other ALM best practices. New for this year’s event, there are two breakout tracks:

ALM Leadership – strategy focused content to help CIO’s, application development VP’s and directors improve their teams software development process
Agile Developer – Agile best practices to help individual contributors become exceptional members of their team

We will also have a dedicated hands on lab for Team Foundation Server, I expect that a lot of the team will be around to get your feedback.

I hope to see you there!

Brian

Deleting a Team Project from the Team Foundation Service on Windows Azure

2011-09-19T14:02:04Z

I've seen a few questions come up about this. Two questions, actually:

Question: How do I delete a Team Project Collection on the Team Foundation Service?

Answer: You can't. For now we automatically create one collection per account (called DefaultCollection) and you can't delete it, rename it, add another one or anything else.

Question: How do I delete a Team Project on the Team Foundation Service?

Answer: You can but it's ugly. This is one of those unfinished scenarios that helps explain why this is a "preview" and not a finished service. Buck wrote a post on how to do this.

Brian

The New Team Explorer in TFS 11

2011-09-19T12:44:32Z

You’ve seen snippets of the new Team Explorer in previous posts I’ve done on version control improvements. In this post, I’m going to focus on the new Team Explorer experience, talk a bit more about what overall changes we’ve made and why.

You’ll recall that the Team Explorer window in TFS 2010 and before is a pretty standard tree control – it looks a bit like the solution explorer. For a long time now, we’ve felt that the model that everything we wanted to do in Team Explorer would have to fit into a tree was overly constraining. When I built the Team Members Power Tools a couple of years ago, I very much wanted to have a richer way to show people, including pictures, etc. – but the Team Explorer window didn’t support it, so I just added another tree node. As we started looking at some of the TFS 11 features we wanted to create, like code review, it became clear that we needed a new approach. An alternative, of course, is to just keep adding new tool widows for everything. The problem is that we already have quite a lot of them and we get feedback that people are overwhelmed with them.

We decided to experiment with a new kind of tool window. I tool window that is, in essence, a frame that houses many other tool windows (or pages, we call them) and provides a browser inspired navigational model around them. We felt this would give reasonably easy access to the breadth of functionality while not polluting the IDE with 10 more tool windows.

As we entered the design, there were other problems we wanted to tackle as well. They include, but are not limited to…

Move to modeless experiences in more places. All the modal dialogs we had for presenting information was creating ugly stacked UI.
Move to more async experiences and have a common way to display progress/cancelation.
Improve startup/connect speed by not populating all the Team Explorer info (documents, reports, work items, builds, …) on startup, but rather loading them on demand.
Streamline common scenarios.
Give Team Explorer a fresher look.
Provide much richer extensibility.
Enable a more scenario oriented organization rather than the artifact classification we’ve had for a while.

To refresh your memory, here’s a picture of what the Team Explorer looks like in TFS 2010:

Meet the Home Page

The new Team Explorer in TFS 11 uses page navigation to provide a lot more functionality in a single tool window. The “root” of the page navigation is the Home page and is quickly accessible via the “little house” button on the tool bar. It contains links to most of the pages and links to the most common actions associated with those pages. You'll also see forward and back buttons to navigate through the stack of pages you've visited and a search box you can use to search for work items.

The search box work similar to search in Outlook or Team Web Access (in 2010). In this example, I'm searching for work items with the word "Create" in the title or description that are currently assigned to me. The drop down on the search box gives you some options to filter by specific fields. You can double click on a work item to open it, or you can use the "Open as Query" link to open your search as a full work item query where you can further refine your criteria, export your results to excel, etc. The search feature only supports work items for now, but we're hoping to expand on that in the future.

Managing Your Work

In TFS 2010, your workflow might have gone something like this:

Open a solution
Make some changes
Find the work items (if any) associated with your changes
Enter a comment describing the changes you made
Check-in your changes

In TFS 11, we're tuning that flow a bit. The "My Work" page gives you a place to review the work that's currently assigned to you and keeps track of what you are working on.

Once you've decided what to get started on, you can use a context menu on the work item (drag and drop will be enabled in the Beta release) to mark them as "in progress."

Those two work items are now "in progress." Since you haven't made any changes yet, you see a "Finish" link rather than a "Check In" link. In the Developer Preview, all that happens when you do this is that the work items are associated with your pending changes. For Beta, this gesture will also transition these work items to the next logical state in their workflow. For example, if you're using the Scrum template, it would transition them from "To Do" to "In Progress" and that change would also be reflected on the web-based task board. Of course, you can also remove work items from the "In Progress" section using a context menu (for Beta, this would revert them back to their previous state).

Once you make some changes to your solution, you'll see some different links.

When you have pending changes, you have the following options:

Check in those changes,
Request a code review of those changes, or
Suspend those changes and your associated context to a shelveset

Let's start with the last option first. You're probably already familiar with Shelvesets which let you move a set of changes to the server and (optionally) undo them from your local workspace. It's a really useful feature for setting work aside, migrating it to another machine or handing it off to a teammate. We're building on that functionality for the Suspend feature so that is also includes your Visual Studio context (open solution, tool windows, bookmarks, breakpoints, etc.). Capturing all of your IDE state so that you can return exactly back to how you were can significantly decrease the cost of interruptions.

When you click Suspend, an in-line panel appears where you can describe your work before you actually Suspend it. If you're concerned that the edit box is smaller than you'd like for this task, you'll be pleased to know that it'll expand horizontally with the tool window and it'll expand vertically to accommodate your content (up to three lines at this width). When you click suspend, your changes will be moved to a shelveset (and undone from your workspace). You'll see your suspended work in the Suspended section as shown here:

If you expand the newly suspended work, you'll see the work items you were working on as well as a summary of the change you made:

The View Changes link will navigate to a Shelveset Details page where you can review the changes, the associated work items, etc.

Another awesome new feature of the work items in the new Team Explorer (particularly in the My Work page) is an “unread” indicator. If there is a work item assigned to you and it has changed since the last time you looked at it or is new – it will be bolded. This makes is really easy for me to stay abreast of any changes or comments on my work. I’ll show an example in the code review section below.

Code Review

For the purposes of this walkthrough, let's request a code review of our suspended work. If we click on the More link, we'll get a pop-up menu where we can request code review for our changes.

On the New Code Review page, you can specify a reviewer, give your request a title, assign an area path, and enter an initial comment to let your reviewer(s) know what feedback you're looking for. If you want to omit some of the files from your code review request, you can click the View Changes link to exclude them. When you're finished, you can click Submit Request to create your new code review request and it will show up on your My Work page in the Code Reviews & Requests section. This is where you can check on the status of your request and navigate to the code review details to see what feedback you've received.

Reviewer's Perspective

If your reviewer(s) have configured their project alerts to receive email, they'll receive a notification mail. In all cases, they'll see the incoming code review request in the My Work page like this:

Double clicking on the incoming code review request navigates to the Code Review page where the Reviewer can see the details of the request:

From here, the reviewer can decide to accept the review request by clicking the Accept button. Alternatively, they can choose to decline the review. If you want to hand the review off to someone else, you can simply expand the Reviewers section, add a the appropriate reviewer, then Decline the review request. You might also want to add a comment to the review to let the requestor know why you're handing the review off to someone else.

Reviewers can add comments to the review itself, to files included in the review set, or to blocks of text within those files. As described earlier, the comment edit boxes will expand vertically to accommodate the comment.

When the reviewer is finished commenting on the changes, they'll click the Send Comments link to publish their comments. You'll notice that the new comments here are shown in bold. When the reviewer is finished with the review, they can click the Finish button. Sending comments happens immediately and is available for others to comment on right away. You can actually even use this pretty much like an interactive IM conversation if both parties are online at the same time.

When finishing, you have some options to succinctly communicate the outcome of the review to the Requestor. If you've added at least one comment, then "With Comments" is the default choice. Alternatively, you can let the Requestor know that their changes "look good" and that you're fine with them being checked in. The "needs work" outcome is a way to let the Requestor know that you'd like them to address your feedback before checking in. Of course, you can also communicate your precise intentions with comments in the review.

Once the Reviewer "finishes" the review, it will be removed from the Code Reviews & Requests section of the My Work page. For the Beta release, the Reviewer will have an easy way to bring up a list of recently finished reviews in case they want to follow-up on some aspect of the review. If you expect the Requestor to follow up with you regarding the feedback you've provided, you can leave the Review unfinished.

Requestor's Perspective

Once the Reviewer sends comments on or finishes the review, it will appear as unread (bold) in the My Work page:

The Requestor sees that the Reviewer has finished the code review and has provided some feedback.

Before addressing the Reviewer's feedback, the Requestor will Resume the suspended work. The Resume command is available on the context menu for the suspended work. For our Beta release, you'll also be able to simply drag the suspended work to the In Progress section to resume your work on it.

Resuming the suspended work will unshelve the changes to your workspace and restore your task context (the solution, open files, etc.) in Visual Studio. After addressing the Reviewer's feedback, the Requestor will close the review and, in this case, indicate that it's complete.

Now you're ready to check in your changes. Clicking the Check In link takes you to the Pending Changes page (see Wrapping up TFS 11 Version Control improvements for more details on the Pending Changes page). After checking in, you'll see a confirmation along with a link to your committed changeset:

Builds

We’ve added a lot of richness to builds in the new Team Explorer that wasn’t there before. We’ve broad forward some of the features from the Build Explorer so that you don’t have to open it for the common cases (like seeing the status of the build you recently kicked off). It doesn't completely replace the Build Explorer, but it should definitely reduce the need to go to that window. We’ve also gotten a lot of feedback on managing large numbers of Build definitions. One of the top User Voice suggestions for TFS is to add “build folder” for organizing build definitions. We haven’t yet (and we’re not sure we will). We’re trying some other approaches that we think might serve as well and not introduce one more organizational hierarchy into the product. See more below…

The My Builds section shows builds that you've queued or triggered (e.g. continuous integration or gated check-in builds). The context menu for builds in this section offers the following commands:

The Requeue command is new. As you might guess, it lets you re-queue a particular build with the same build process parameters, etc. as the build you've selected. It's useful in cases where the build has failed due to some environmental issue.

The All Build Definitions section gives you a list with, you guessed it, all of your build definitions (well, the first 100 actually). You can use the filter box to filter the list down to the one you're looking for. It’s a quick and easy way to find the build definition you are looking for without having to navigate a large list. Further, you can identify a list of “favorite” build definitions. These are the build definitions you use more frequently and are always at your finger tips.

For your favorite build definitions, you'll see the status of the most recent build along with the build history visualized as a color-coded histogram. Like the Build Summary view in TFS 2010, you can click on a bar in the histogram to navigate to the details for that particular build. Note that your favorite build definitions are tracked on the server, so you'll see the same list from any machine you connect to your project collection from (including Web Access).

Work Items

The Work Items page in the Developer Preview looks fairly similar to the work items node in the previous version. Maybe the biggest change is that now some actions are links in the page rather than having to use context menus for everything.

There are more capabilities coming in the Beta release (including server-side favorites).

Performance

We've worked hard to move long-running tasks to background threads wherever possible. There are still some cases where, due to interactions with the Visual Studio UI, we need to perform those tasks on the foreground thread, however. We've continue to improve performance since the branch for the Developer Preview was locked down and you'll see those improvements in the Beta release.

Extensibility

In TFS 2010, the extensibility of Team Explorer was pretty limited. You could add a set of nodes to the tree control, provide a context menu for them and handle activation (double click) events. In TFS 11, Team Explorer has a much richer extensibility model. You can extend it the following ways:

Add whole new pages to the navigation structure
Add a new section to an existing page
Add a top-level link to the Home page
Add a secondary link beneath an existing top-level item in the Home page

In your custom Team Explorer page, we recommend that you organize your content into sections using our framework. But, you have complete control over the content and behavior of your page. Stay tuned for a future post on writing a new Team Explorer extension.

Brian

Team Foundation Service Registration code for Asia-Pacific

2011-09-19T04:22:00Z

I got several comments last week that posting my registration codes in the middle of the afternoon North Carolina time was not very friendly for people in the Asia-Pacific region. It worked out to the middle of the night and since they didn’t last more than a few hours, they were all used up by the time people woke up. Tonight I’m going to remedy that situation. Here, I’m posting another registration code but I’m doing it late night my time on Sunday night – which should be morning to mid afternoon for most of Asia.

Please try it out and let us know what you think.

Registration code: “bharry-asiapack”

Brian

Improving Visual Studio Performance

2011-09-16T22:02:34Z

We've had a few healthy exchanges about performance on my blog and it's clear there's a lot of energy out there about it. After the last exchange I kicked off a discussion internally about making sure we are directing our performance efforts at the right things. We published a User Voice site a couple of months ago and performance issues dominate the top of the suggestion list. However, they are, by and large, pretty general and difficult for me to derive specific priorities from.

So, we hatched an idea to create a new User Voice site and pre-populate it with a hand full of fairly specific suggestions/scenarios where we think people would like to see performance improved. Our hope is that you will volunteer your own suggestions - in the same spirit of fairly specific scenarios and vote on them. We can then use this list to prioritize our work as we finish up Visual Studio 11. We appreciate your help with this.

Larry Sullivan has written a post to begin the discussion about perf. The User Voice site for suggestions is here: http://visualstudio.uservoice.com/forums/131389-visual-studio-performance/filters/top

We're looking forward to your feedback!

Brian

The VS 11 developer preview is now live

2011-09-16T18:14:54Z

Visit the landing page here: http://t.co/48p0iAdH

Brian

Visual Studio 11 ALM Virtual Machine and hands-on-labs available

2011-09-16T16:22:36Z

Brian Keller just published a virtual machine with many of the VS 11 Preview bits on it and a bunch of hands-on-labs to walk you through many of the new features. Check it out: http://aka.ms/VS11ALMVM

Brian

Configuring a build server against your shiny new hosted TFS account

2011-09-15T20:33:14Z

Now that you have a Team Foundation Service account, some of you are going to be interested in setting up a build machine to work with it. Richard Hundhausen did a very nice video to walk you through this process but I’m going to recap it because there’s a few additional things I want to explain. If you watch his video, it’s higher fidelity than this post but you might get some additional understanding here.

First let’s talk about options. You can install and configure a build machine to run against your Team Foundation Service account. You will have to use a TFS 11 build agent. The TFS build agent is part of the TFS install and is available to MSDN subscribers on the download site and will be available to everyone tomorrow (Friday 9/16) at this url: http://go.microsoft.com/fwlink/?LinkId=225714

You can install the build server on any machine you use – a workgroup machine at home, a domain machine at work, an Azure VM Role, an Amazon VM, whatever you like. TFS doesn’t really care. The machine just has to have connectivity to the internet to get to tfspreview.com.

Run the TFS installer on the machine you want to install the build controller/agent on and you’ll accept the license, copy the bits on to the machine, etc and then get an install screen like this. Since you are just installing a build server, you don’t want to choose any of the Team Foundation Application Server wizard. You just want the Configure Team Foundation Build Service. Click on “Configure Team Foundation Build Service” and then click the Start Wizard button at the bottom.

You’ll see a welcome page, click Next and see this. If this isn’t what you see, try canceling and make sure you had the right wizard selected. This wants you to identify your team project collection/account on the hosted service. You can’t type here so just click the Browse button.

And you’ll see this. I’ve not connected to a server from this machine before so there’s no server for me to pick from. I click the Servers… button.

And get the list of available servers – see there aren’t any. I told you So click the Add button.

You can type the full url in the top line if you want but here, I’m using the dialog controls. “minka” (that’s actually the name of my farm ) is the name of the account so I give a name of minka.tfspreview.com. Then I click the https button (you have to use https to connect to the server for this). The url in the preview field is what I could have put in the top edit field if I had wanted to.

Now I click OK and I go back to the previous window and close that and I see this. For our TFS Service, the team project collection is always called DefaultCollection and you can only have one. In the on premises product you can have more than one and name them whatever you want. Select DefaultCollection and click Connect.

At this point you are connected and the url will be filled in the wizard page above. Click next on that wizard page and you’ll go to the Build Services page. This allows you to configure how many agent you want running. The default is 1 per core but I don’t really need to build 8 things in parallel on my little machine at home so I changed it to 2 and clicked Next.

That takes me to the Settings page which controls how the build service runs on my local machine. Remember the build service itself runs on the machine I’m installing it on and it needs some identity to run as. It’s going to connect to my hosted account with a different identity but more about that in a minute. I created an account on my local machine called “Build”. I could have called it anything I want or used the account I was logged in as. If I had been on a domain, I could have used Network Service but I’m at home so I’m just using a local machine account. BTW, while I was playing with this, I discovered that we don’t support accounts with no password right now. That’s a bug and we’ll fix it. I’m logged in to my 11 year old’s account at home and he doesn’t have a password That’s the only reason I went and created a new account just for the build service.

The last thing you do is specify what port on your local machine you want the build service to use. This isn’t the port on the hosted service but rather the one on your local machine. The default works for most people.

Then there’s that bit in the middle about authenticating with the hosted service and the Windows Credential Manager. Let’s finish the wizard and then I’ll talk about that.

Click Next and you can review your choices and click Verify. Everything should Verify fine and you can click Configure.

When configuration is done you’ll get a completion screen that looks like this. You can now finish out the wizard and it will launch you into the TFS admin console.

Click on the Build Configuration node on the left and see that you controller and agents are up and running and all is happy. You can close the admin console, go into VS, start creating build definitions and running builds.

Now what about those funny credentials. There’s up to 4 sets of credentials at play here:

What you are logged into the local machine you are installing as. As long as you have sufficient permissions to install that’s all that really matters.
The account you configure the local build service to run as. That’s what you entered into the wizard. I used a local account called “Build”. Many people just use the account they are logged in as or, if they are on a domain – Network Service.
The Live ID that you log into your Team Foundation Service account with. It only plays a part here in that you have to authenticate with the service using that Live ID when you in the connect dialog sequence above. If the system hasn’t saved those credentials you’ll get a Live ID web page to log in. This makes sure that you have permission to configure a build machine against your account. You wouldn’t want random people creating build machines against your account would you?
The service identity that the build agent uses to connect to your Team Foundation Service account – we sometimes refer to this as the “Project Collection Identity”. This is the bit of magic that the text in the above dialog is about.

Let me expound on #4… The build service, running on your local machine, needs to talk to your hosted account. To do that it needs to authenticate (login). Unfortunately, it can’t use your Live ID because Live ID doesn’t support automated services authenticating. Fortunately, we use Windows Azure Access Control Services (aka ACS) to handle authentication and ACS supports something called service identities that are explicitly designed for this kind of scenario. The build setup wizard you’ve just run uses the Live ID authentication you did when you connected to create a service identity for you and generates a random password. It then puts that password in the Windows Credential Manager for your local build service account.

When I look in my Windows Credential Manager for my local “Build” account, I see:

Note it’s got my url https://minka.tfspreview.com/defaultcollection and an auto generated user name (the name of your ACS service account on the hosted service) – “Account Service (minka)”. And it’s got my auto-generated password. Please, please, please don’t change it. That will only change your local copy (not the one on hosted TFS) and your build service won’t work. Since you don’t know what the auto-generated password is, you can’t set it back. That means you are hosed. the only thing you can do is unconfigure the build service and reconfigure it from scratch.

Let’s look at this in the admin console: If I click the “Properties” link on the build configuration page, I get a dialog like this. I need to click the “stop to make changes” link which stops the local build service while you make configuration changes.

OK, now my local build service is stopped. Notice the two tabs at the bottom. The visible tab, “Service Identity” is actually the account that your local build service runs as on your local machine. My computer is KIDS-PC and the account is Build. I can change that and save the changes and all will be well.

The other tab, “Project Collection Identity” is what account the build service uses to talk with the server (in this case my hosted TFS account). For our hosted TFS service, I have to use an ACS Service Identity and I can’t change it or the password (at least right now). We have not built any feature of the service to change either the ACS service account or its password.

OK, that’s some long gory details about exactly how it works. Most people need never know or care. Run through the wizard and it just “does the right thing” for you. But just in case you ever need to understand what is going on, now you do.

Have fun!

Brian

More Team Foundation Service activation codes

2011-09-15T17:10:40Z

The demand for accounts to try out the Windows Azure based TFS Service Preview we announced yesterday has been terrific. We've used a bunch of avenues to get codes in people's hands but the demand keeps out pacing supply. Because of that, this morning, we bumped the number of activations on my "bharry" activation code. There should now be a bunch of new activations available now. If you've been wanting to get an account but struggling to get a ticket, give it a shot. We'll see how fast it runs out :)

Brian

VS 11/TFS 11 Developer Preview

2011-09-15T11:41:45Z

Yesterday was a pretty crazy day with our new hosted TFS Service going live. I'd stayed pretty focused on that to make sure everything went smoothly. But, in case of some rare anomaly that you missed it, we announced a VS 11/TFS 11 developer preview yesterday as well. They are available to MSDN subscribers on the download center today (well last night, actually) and will be available to everyone tomorrow. Read Jason's blog entry for a good overview: http://blogs.msdn.com/b/jasonz/archive/2011/09/14/announcing-visual-studio-11-developer-preview.aspx

Here are the public download links for when it becomes available on Friday:

Visual Studio 11

Team Foundation Server 11

I've already got a series going highlighting some of the new ALM features and I've got a lot more yet to go. Also you can follow the VS ALM team blog to learn more.

Brian

Team Foundation Server on Windows Azure: A Preview is available!

2011-09-14T16:00:00Z

Today at the BUILD conference, we announced availability of our Windows Azure based Visual Studio Team Foundation Service Preview. If you’ve been following my blog, then you know we’ve been working on it for a while now. We’ve had a private preview going for the past several months and are up to several hundred users. We’re ready to take the next step and open it up to a broader audience. As part of the announcement at the BUILD conference we gave invitation codes to all attendees to sign up for an account.

Everyone who signs up for an account can invite as many people as they like to use it with them. In addition, everyone who gets an account can get another invitation code that they can hand out to 5 friends for them to create their own accounts.

Now you are thinking to yourself: Dang! I didn’t go to BUILD. What do I do? You’re not totally left out in the cold J I’ve included below a registration code you can use. It’s good for the first 250 people that use it. Each of those 250 people get the same benefits I described above (creating a project, inviting friends and handing out 5 accounts to friends).

250 use activation code: “bharry”

To use the code, visit http://tfspreview.com. Below you’ll find a walk through of the sign up experience.

Benefits

Our hosted TFS Service is a quick and easy way to get started with TFS. In only a few minutes, you can have an account and be productive with your team regardless of where they are around the world. It takes away the time and hassle of arranging for hardware, installing software, providing network infrastructure, etc. The service takes care of all of that for you and lets you focus on your project.

Although the service is pre-release at this time and is not complete, much of the TFS functionality works today. You can use:

Source control
Work item tracking
Agile project management (a new feature in TFS 11)
Testing
Build automation (though for now you will need to set up a TFS 11 CTP build agent on your own hardware)
and more…

You can use most of the TFS clients – including VS 2010 and Test Professional 2010 (with an available client patch), VS 11 (CTP to be available soon), Team Explorer Everywhere (compatible update available here), Microsoft Office integration, etc.

Getting Started

To try out our TFS service yourself, browse to http://tfspreview.com. You’ll be greeted with this screen (though the video will have changed by then):

You can watch the video (hosted from Channel 9) to learn more and when you are ready, just click Create Account. You should see the sign up screen. Here I’ve entered and account name (bharryblog) in the server url field. And an invitation code (bharry) to authorize me to create an account. If you attended the BUILD conference, please use the invitation code you received in your goodies bag. Accept the terms of service and then click Sign Up.

You’ll need to sign in with a Windows Live ID. Note, you can only create one account per Windows Live ID.

And it will walk you through the steps. Your account is created (make sure to make note of the url to get you to your account) but you need to create your first project. Do that by clicking create team project.

And that will allow you to name your Team Project and choose a process template. When you have filled out the form, click Create Project.

You’ll get a progress dialog:

And a completion screen:

At this point you can go one of two directions. You can click “My Team home page” and begin playing around with the web experience. Or you can click close and download the VS client patch. The simplest flow (and what I show below) is to go to the Team home page. You can download the client patch later. If you choose to close this and go download the client, you just need to be aware that you are left in “administration mode” in the web UI and need to click the “EXIT ADMINISTRATION” link in the upper right to get back to “normal” mode. Our usability studies have told us this is not intuitive and we plan to fix it for the next update. If you click the My Team home page, you’ll see your team’s home page and you are ready to explore the product.

Enjoy and don’t forget my overview post on the Agile Project Management features. I’ll write more in subsequent posts. Once you’ve played around, you can invite others to join your project by selecting your project in the upper left of the nav area and choosing Manage teams and project groups.

Select your team (or or other group you want to add them to, but your team is easiest) and click add members.

Type their Live ID and click Save Changes. Note you are in administration mode in the UI and you need to click EXIT ADMINISTRATION in the upper right to get back to “normal” mode. Did I mention we’d be improving that? Roughly speaking you can add as many people as you like to your account.

Or if you want to invite a friend to create their own account, you can click the ADMINISTRATION link on the upper right and select ACCOUNT in the nav area. On the lower right, you can click on “invite others” and it will generate an invitation code (good for 5 accounts).

Current Feature Status

As I mentioned earlier, this release is a preview and the product is not yet complete. Most of the functionality is in place but I want to mention a few notable things that are not yet available:

You cannot customize your process template at this time. You can choose any of the 3 built in templates but you can’t change them. For now we’re trying to keep upgrade of the service simple and don’t want to deal with potential conflicts between customizations and service evolution yet.
Sharepoint integration is not available. The on-premises product integrates with Sharepoint to provide a project portal in addition to the web UI available in TFS. At this point Sharepoint integration is not yet available for the service.
There is very limited reporting. We provide some reports (like burn down charts) as part of our Agile project management experience but many of the reports that you may be used to in the on-premises product are not yet available on the service.
The service does not currently support lab management.
Email alerts are currently not delivered by the service.

If you find anything else that seems to be missing and you want to know if it’s a bug or simply an unfinished feature, let me know.

Status of the Service

We’ve been running the service for months now and it’s been working reliably. I suspect now that they can talk about it, you’ll be able to find some of our early adopters blogging about their experiences. But, like the product, the service isn’t fully finished yet either and there are some things to be aware of:

The service has been very reliable but, at the moment, we are not providing any uptime guarantees. We are not on a 24x7 support schedule yet. We will do our best to keep the service running well but we’re still learning everything we need to know to do this well. Our goal is 99.9% availability and so far we’ve stayed very close to that.
Data you put into our TFS service WILL be carried forward. We do not plan to ever wipe the service and restart or any such thing. The service launched in April from our perspective and every time we upgrade it (which we’ve done about 3 times so far) we bring all the customer data along with it.
For now the service is free of charge. At some point in the future, we will announce a pricing model. We’re still working on it and are not ready to discuss any of the thinking yet.
Because the service is free and we’ve provided a network effect for invitation codes, we don’t know how many accounts people are going to create. We do have some overall limits on the service and if/when we hit them, new account creation will get disabled. To allow room for people who really want to use the service, inactive accounts will be deleted. An inactive account is any account that has not been used for 60 days. We will not keep backups of any deleted, inactive accounts.
There is a per account storage limit. It’s a bit of a soft limit and will depend somewhat on how you use the system but roughly speaking it should handle real world projects up to about 4GB of compressed source code. Assuming about a 4:1 LZW compression ratio, that’s about 16GB of source and should handle the vast majority of projects.
We currently only have the TFS service in a single data center (in Chicago). Eventually it will be deployed to Azure data centers around the world.
This launch of the preview will likely dramatically increase the usage of the service. We’ve worked hard to ensure that the service is ready. We’ve been doing performance and load testing work for the past couple of months trying to simulate the load that we expect the new wave of early adopters will put on it. However, my experience in the past running large scale services says that any time you have a large inflection in the usage, you should be prepared for problems. I expect we’ll see a few hiccups over the next week or two as we burn in the new load pattern but we’ll be working hard to keep things healthy and happy.
We don’t currently have a way to migrate project either from your local TFS instance to the cloud or from the cloud to a local TFS instance. Those are things we hope to provide in the future but for now you’ll want to start with “fresh” projects that can stay in the cloud.
The service is currently only available in English. We’ll add additional languages in future updates.

Overall, I think you’ll be very pleased with the service. The feedback from our early adopters has been very positive. Most have reported very good availability and performance.

Feedback and Issues

We very much want your feedback on the service. Feedback comes in many forms and we’ve provided a number of avenues for you to provide it:

Feature suggestions: http://visualstudio.uservoice.com

Bug reports: http://connect.microsoft.com

Support questions: http://social.msdn.microsoft.com/Forums/en-US/TFService/threads

Eventually, we plan to have a nice self-service way for you to check on the status of the service and make sure everything is running smoothly (to help you determine if a problem you are seeing is service wide or specific to you). For now, we’ll be using a blog to keep you informed about the state of the service. You will find it here: http://blogs.msdn.com/b/TFService. You can also use this Twitter url: http://twitter.com/#!/tfservice.

And, of course, I’m always here on my blog to help you if I can.

Conclusion

It’s an exciting time for us. We’ve been working hard on getting this service ready and we’re thrilled to be able to offer it for you all to try it out. We’re eagerly awaiting your feedback and, at the same time, working hard on the next update already. One of the things that you’ll find is that a service is very different from an on-premises product from a release cadence stand point. Right now we are upgrading the service with new capabilities about every 2-3 months. We’re working on further decreasing that cycle time but you should expect us to keep bringing you fresh capabilities and reacting to your feedback on a pretty regular basis.

Thanks,

Brian

Wrapping up TFS 11 Version Control improvements

2011-09-01T19:28:52Z

This is the third post in the series on “Developers are Raving Fans” TFS features. The first post was on workspace improvements, the second on merging and this is kind of a wrap up post that covers the rest of the version control improvements. There’s a few more that are in progress that I’m not quite ready to talk about yet but this should cover the majority of what is left.

Team Explorer

Probably the biggest thing I haven’t talked about yet is the changes to Team Explorer and the Pending Changes window. I’m going to do a full post in the future on the overhaul we have done to Team Explorer so for now I will just focus on a small part of it. The biggest thing you probably need to know is that the Team Explorer tool window is no longer just a simple tree control. It is now a “canvas” in which we aggregate a number of experiences and allow you to navigate between them. One of the changes we’ve made in the process is to merge the Pending Changes window into the Team Explorer.

The UI I’m going to show you here is not final – we’re still tuning and tweaking it (especially the navigation) but it’s getting there. Overall our goal here is to streamline and remove clutter – in tool window count, complexity and visual overload. Here’s a picture of the new Pending Changes page in Team Explorer and some comments on the changes below.

Some things I want to point out:

The window has a vertical orientation and shares the space occupied by Solution Explorer by default.
The look of the of the list of files is much simpler. It’s a reasonably compressed tree view and rather than textually writing the change type, give a more visual indication ([+] for add, [oldfilename] for rename, strikeout for delete, etc). The result is a less cluttered and easier to digest look. Also, for the case of renamed files, I challenge you to find out what it was renamed from in the 2010 version
You’ll notice the checkboxes are now gone. Instead we have “included” and “excluded” changes. You can drag and drop, etc between them. When you check in, only the files in “included changes” are included in the check in. The excluded changes also includes the detected changes functionality I talked about in my post on workspaces.
If you are watching closely, you see that we have an “Add Work Item by ID” command which was something you couldn’t do in 2010 (you could only pick from a query result) and has been a much requested feature.
Each section can be expanded or collapse to remove clutter.
If you have checkin policy violations, that section will show up and if not, you won’t see it – a nice clutter reduction for those who don’t have policies or violations.
A checkin notes section will show up if you have checkin notes defined. We don’t have any by default any more so you don’t see them in the pane above.

As you can see, additional commands are under the “More” drop down:

Overall I think the experience around managing pending changes is an improvement.

Friendly Names

When we were developing TFS 2005 (oh, it seems so long ago), we built it to show everyone using their domain name (e.g. redmond\bharry) everywhere in the product. Late in the beta, we got overwhelming feedback that that was a terrible thing for many customers. Many customers have seemingly random sequences of numbers and letter for windows usernames – so they look like mycompany\Q27f01. And no one has any idea who that is (maybe not even the person who owns it ). It was late enough in the product cycle that we couldn’t make a wholesale change throughout the product so after much going round on feedback, we settled on changing work item tracking to use “friendly names” (e.g. Brian Harry) and the rest of the product to use domain names (e.g. redmond\bharry). That quelled the uproar and then somehow, we never found the time to “finish the job” in TFS 2008 or TFS 2010. Well, we finally have. Now friendly names show up everywhere in the product that a user name shows up. The ultimate driving requirement that made us do this now was that there are no domain names on the internet (Google, facebook, live ID, etc) and in order to show useful names on our hosted service, we had to significantly rejigger how we manage user names.

Here’s a screenshot of source control explorer where it’s showing my full name rather than my domain name:

To ease the transition for people who are so used to domain names (for those that are used to them in version control), I think just about everywhere (in version control) we accept a user name as input, we’ll take either the friendly name or the domain name and do the same thing.

Reducing Modality

One of the things that I know no one likes is modal dialog boxes stacked on top of modal dialog boxes on top of yet more modal dialog boxes. In TFS 2010, we had way too much of that. The most serious downside is that the modality causes you to be locked into that part of the UI and unable to access other parts of the UI to investigate related information. Also the stacked dialogs is confusing/cluttering and we have to introduce new instantiations of commands because you can’t access the main menu/toolbar, etc. We’ve taken steps to reduce modality around the product. More things show up in document well, in the Team Explorer well, etc. The checkin experience I showed you above in the Team Explorer window is one example (we now use that from many more places in the UI than we used to use the pending changes window). Also having “Compare” use the VS editor in the document well gives a kind of non-modal experience relative to using an external diff tool. Another example I want to talk about is shelvesets.

The whole shelveset experience used to be a stacked modal dialog experience. None of it is modal now. If you looked closely at the “More” context menu I showed in the pending changes section, you saw a “Find Shelvesets” option. This is the analog of the old “Unshelve” button in the 2010 pending changes window. However, rather than launching a modal dialog, it opens a new pane in the Team Explorer window that looks something like this:

A couple of things to note here:

I can still filter by shelveset owner (here it’s filtered to my shelvesets – that’s the default). I can type “Brian Harry” or “redmond\bharry” and I’ll get the same result.
I can also filter by text in the shelveset title (the “Type here to filter the list” box) and is darn handy for people who keep a lot of shelvesets (and I’ve seen people with dozens and dozens). It’s an incremental – as you type filter so you only have to type as much as needed to find what you want.
We provide a nicer way of showing how old the shelveset is rather than just showing the creation date.
Once I’ve found the shelveset I want, rather than hitting a “Details” button and getting a modal dialog, double click it and get an in place shelveset details pane, allowing me to operate on the files in the shelveset the same way I would on any other. I’ve included a picture. Note it looks an awful lot like the pending changes window above. As a side note, notice that I’ve configured a checkin note (Localization) and that’s now showing up at the bottom of the pane. I’ve also collapsed the comment section and associated a work item with this shelveset.

Change set details from many places (like history, annotate, etc) will also be non-modal now.

Asynchronous Operations

In my first post in this series, I talked about the offline, and responsiveness advantages of local workspaces that don’t have to contact the server to do everything. We’ve also done work around the UI to make things that do have to contact the server more responsive too. We’ve done this by making several more operations async (some things already are – history, annotate, source control explorer). Some of the asynchronous changes we’ve made rely on the modality changes I talked about a second ago. It’s hard to make waiting for a modal dialog asynchronous Are you going to go start working on something else and then have the modal dialog randomly pop-up at some point in the future?

Some examples of asynchronous work we’ve done include:

Editing a file is now asynchronous. Local workspaces help decouple us from the server but we’ve also decoupled all the IDE state updating so editing a file really is instantaneous.
Checking in is now asynchronous – you can keep on working while your checkin processes.
Find shelveset is asynchronous.
Sheveset details and changeset details are asynchronous.
File compare is asynchronous.
Other things outside of version control are also asynchronous – like opening a work item. It used to block the UI.

There are certain things that have significant interaction with the VS project systems that are hard to make async. Other than that, probably the biggest operation that we haven’t gotten around to making async yet is “Get latest version”.

Rollback in the UI

I blogged about this (with screenshots) in my latest Power Tools post. We added rollback in the UI in the latest Power Tools for TFS 2010 but we’ve also added it to the TFS 11 product. It’s great to have this long standing request in for good.

Restore file modification time

When TFS gets files on to your local disk, it always sets the file modification time to the date/time that the get operation happened. There are some work practices where this is problematic. Some practices use the date stamp on the file for incremental deployment or other kinds of change management. SourceSafe had 3 options for setting the time stamp on files:

The time the file is gotten (this was the default and works very well in concert with make and other similar build dependency trackers).
The modification time that the file had when it was last edited before checkin.
The date/time that the file was checked in.

TFS 2010 and before only supported option #1. In TFS 11, we have added support for option #3. It can be set on a workspace by workspace basis. We plan to add support for #2 in the future but haven’t gotten there yet.

Unix file attributes

Our Team Explorer Everywhere client runs on Unix. One of the things you have to deal with on Unix is the file attributes – particularly the execute bit. It’s an attribute of a file that really needs to be saved and restored or it messes things up pretty much. TFS 2008 had no support for this kind of thing. In 2010, we added a property system with the goal of applying it in these kinds of scenarios but didn’t get around to adding branching and merging semantics to it so it wasn’t sufficient to carry Unix file attributes. In the meantime the Team Explorer Everywhere team built a work around of storing file attributes in a “.tpattributes” file but it’s an incomplete solution.

In TFS 11, we are rounding out the properties mechanism and will be building first class Unix file attributes support. Basically, now you can attach properties to a file in version control and expect them to behave “properly” across all version control operations. Although Unix file attribute support will be the first feature incarnation on top of this, the #2 scenario for restoring file modification time should be able to follow reasonably quickly on its heels.

Properties on Shelvesets

This isn’t going to sound very impressive but in my upcoming post I’m going to talk about some very cool features that build on this. In TFS 2010, we introduced a property system that allows you to tag properties on objects (I talked about this a bit in my Unix file attributes section). However, we didn’t have specific support for properties on shelvesets. In TFS 11, we’ve added that. It’s a general purpose extensibility mechanism. You can attach properties to a shelveset and their access is controlled by the permissions on the shelveset. Also they are deleted when the shelveset is deleted, etc. Give me a week or so and I’ll tell you why this is a very nice feature to have

Conclusion

That rounds out most of the version control improvements under the “Developers are Raving Fans” theme. As I said at the beginning there are a few more thing in the pipe that I’m not ready to commit to yet but what you’ve seen so far is most of it. And it’s quite a lot of stuff – 3 pretty long blog posts to cover it all. And there’s more “Raving Fans” stuff yet to come – more Team Explorer improvements, build, work item tracking, … I’ll cover the rest in the next few posts.

I hope you like what you’ve seen. I can’t wait until I can share the bits for you to try yourself.

Brian

Merge enhancements in TFS 11

2011-08-31T18:31:20Z

Here’s the next post in my series of “Developers are raving fans” enhancements coming in TFS 11. My last post was on workspace improvements.

One of the things we consistently get customer feedback on in TFS 2010 is that merging is still too complicated and/or too limited. We’ve made several significant improvements in the coming release:

A new diff/merge experience – The one we’ve been shipping for the past 5 years is the original SourceSafe diff/merge tools – built while we were One Tree Software circa 1994. It had been enhanced over the years to support globalization, Unicode, etc but it was, in essence, the same diff tool. Well not any more, it’s gone! We’ve built a new diff/merge experience based on the VS editor. And before you say “but wait, I really love kdiff!”, don’t worry – it’s still configurable and you can use any tool you like but the out of the box one is now WAY better. How is it better you say?

It supports both “inline” and “side by side” modes and you can choose the one you like best.
It has syntax highlighting (as supported in the VS editor).
Individual changes within a line are highlighted.
When both diffing and merging, you can edit with the full power of the VS editor, including undo, Intellisense and everything!
Diff has a nice “mini-map”.
You can now take more actions from the views (like history, etc).
Diff uses the new provisional tab feature in VS to avoid cluttering your document well.
An improved way of manually selecting merge resolutions.
An interactive way of turning on/off ignoring whitespace.

Here are some screen shots to demonstrate. You can observe many of the points I made above:

Side by side diff view in the provisional tab (all the way to the right) with a change highlighting gutter on the left, in line change highlighting, VS style class/method navigation, syntax coloring and more. Yes the text with the file names above the source looks dumb – that’s a bug.

Same diff using inline mode:

And here are some screenshots of the merge experience. I’ve included all three of the views you can choose from:

Overall, it’s a much better default diff and merge experience than we’ve had before!

Minimal conflicts when merging – Probably the biggest complaint that we hear about merging is that it’s way too cumbersome. We spent a bunch of time trying to get to the bottom of this feedback and concluded that the primary issue is that when you do a merge, you get way too many reported conflicts that actually don’t require you to make meaningful decisions. People want it to just “handle” all the obvious merge cases and only draw their attention to places where they have real work to do.

To demonstrate the difference between TFS 2010 and TFS 11, I have run a sample scenario. It’s simple and contrived but it demonstrates the difference. I took a big folder full of TFS source code and branched it. I then global renames of two methods in the two branches and merged the results. The result was 48 files changed in the source branch and 90 files changed in the destination branch. The resulting reported conflicts were:

TFS 2010: 38 conflicts
TFS 11: 12 conflicts

The difference is that TFS 11 automatically resolved 26 of the conflicts without requiring user interaction.

I always hear that Git is the “gold standard” for this behavior. So, we did a head-to-head comparison between Git and TFS merge behavior and we found that the change necessary to our code to get pretty close to the Git experience was actually pretty small. So I did a head-to-head to compare the new TFS merge behavior to Git. I’m not going to claim that it’s an exhaustive test or that I caught everything but I believe it covers most of the common scenarios and, when you get your hands on it, if you find anything we missed, please let me know.

For this scenario, I wanted to compare the behavior with different kinds of conflicts. I created a folder with 9 files in it, branched it and then arranged a specific pattern of changes to evoke conflicts. Here are the changes:

File	Source change	Destination change	Comment
file1.txt	unchanged	unchanged	Trivial case, nothing to merge and nothing in the destination
file2.txt	edit line 3	unchanged	Just merge the change into the destination
file3.txt	unchanged	edit line 3	Nothing to merge over and the change in the destination should affect it
file4.txt	edit line 3	edit line 7	Distinct changes in source and destination
file5.txt	edit line 5	same edit line 5	Same change in both files should merge well
file6.txt	edit line 5	different edit line 5	This is a conflict that will require user interaction to resolve
file7.txt	delete file	unchanged	Delete the file in the source an no changes in the destination
file8.txt	delete file	edit line 5	A file delete in the source conflicting with an edit in the destination
file9.txt	rename file	unchanged	Should not really be any conflict here

I then created the same scenario in TFS 2010, TFS 11 and Git and looked at the results. In this scenario, I used the command lines for all 3 to really show apples to apples.

Here’s the merge output for TFS 2010:

Note there are 3 conflicts listed and 4 additional merges. files 1 and 3 didn’t require any merges. And here’s the output of tf status:

And we see 7 changes pended (to be expected based on what we saw in the merge output).

Here’s the merge output for Git in the same scenario:

and the status output:

First thing to note is that Git lists only 2 conflicts – file4 is automatically resolved where it is not in TFS 2010. The other thing that I notice is that file5 doesn’t show up at all (remember that’s the one where identical changes were made in source and destination). Other than that, the merge/conflict results are identical. Other things I notice is that all the wrapping in TFS’s merge output makes it hard to read, the color coding in Git is nicer and including the conflict information in the status output is very nice.

I then ran the same scenario in TFS 11:

Now the number of conflicts matches Git. We still have the difference that we list file5.txt because we way we do debit/credit logic on merges requires that we have a pending change to recognize that the merge has happened. I’m going to look at this more closely. The output is the same and I’ve spoken to the team about making a few changes here that can improve readability and reduce verbosity.

When I ran this comparison against Git, I was struck that the number of types of conflicts that we resolved differently in 2010 was not actually all that high. However, that doesn’t take into account frequency (which is why I did the rename example first). The one type we didn’t handle as well happens to be the most common type, so that small change has a pretty big effect on the developer experience.

Baseless merge in the UI – Another long standing piece of feedback is people want to be able to initiate baseless merges in the UI. We’ve supported it in the command line for a long time but much as I said about rollback in my post on the Power Tools, for many people, if it’s not in the UI, it’s not in the product. Now it’s in the UI. If you initiate a merge from the Source Control Explorer, the merge wizard now has a browse button that allows you to go find branches to do a baseless merge against.

Let’s look at an example. I started with a branch structure that looked like this:

As you can see there’s no merge relationship between destination and AlternateDestination. But let’s imagine that I have some changes in destination that I want in AlternateDestination but I don’t want to go through Source. I want a baseless merge from destination to AlternateDestination. I can now go to Source Control Explorer and start the standard merge experience:

As always, only Source is in the list because it is the only related branch to destination. However, unlike TFS 2010, there is now a Browse… button for baseless merges. If you click it, you get:

and here you can see I can pick AlternateDestination. And if I do, and hit OK, I go back to the wizard:

And it warns me that I’m doing a baseless merge but I can hit next and then finish and proceed with it. So, now you can do baseless merges in the UI!

Merge on unshelve – From the beginning people have loved shelving as a simple, clean way to package up changes and set them aside. However, we’ve often heard the complaint that the inability to unshelve into a workspace with pending changes and deal with the merge conflicts was a serious limitation. No more! We have now built merging into unshelve operation and it works just like merging does elsewhere in the product.

This post has gotten plenty long so I’m not going to include screenshots of this. The new thing is that merges are performed, conflicts are filed, etc in this scenario. All the UI around that is the same as on other scenarios (like merge and get) where merges happen.

Whew! That was a lot but I’ve got plenty more to tell so I’ll keep writing posts in this series.

Brian

Sequencing VS 2010 with App-V

2011-08-29T15:09:51Z

For all of you who have been waiting to create App-V images of VS 2010, it’s finally possible. You’ll need VS 2010 + SP1 + 1 patch and App-V 4.6 SP1. Here’s some instructions for how to do it.

You might wonder why it hasn’t just always worked. For an app to work just fine in an App-V image, it must not have any machine specific data coded in it’s configuration. Unfortunately, VS does – specifically in some of our licensing configuration data. The patch I mentioned above changes the way we encode license data so the it doesn’t contain any machine specific state. With that change, you can sequence VS.

If you have issues trying this, I recommend posting on our setup forum here: http://social.msdn.microsoft.com/Forums/en-US/vssetup/threads

Brian

Developer Tools Deployment Planning Services

2011-08-24T17:57:00Z

When you purchase Software Assurance along with your software purchases from Microsoft, you get Deployment Planning Services“ credits. These credits can be spent on deployment planning training/consulting on all manner of Microsoft software. This is nothing new. It’s been in place for a while. I don’t think it’s well understood but it’s not new.

What’s new is that we now have some developer tools offerings that you can spend your credits on. These offerings are primarily designed for enterprises undertaking large scale or involved deployments (high availability, broad feature set, migration from other tools, etc). They are a safety net to make sure you have easy access to resources to ensure you know how to be successful with the transition. We’ve recently rolled out 3 offerings:

Team Foundation Server Deployment Assessment – This is a five-day assessment that provides a detailed overview of the steps required for a successful deployment of Team Foundation Server 2010.
Visual SourceSafe Migration Assessment – This is a three-day engagement that provides a detailed overview of the steps required to migrate from Visual SourceSafe to Team Foundation Server 2010.
Visual Studio Quality Tools Deployment Assessment – This is a five-day assessment that provides a plan to simplify and streamline test planning and manual test execution processes by utilizing Team Foundation Server 2010 with Test Professional 2010.

**UPDATE** Check out http://www.microsoft.com/licensing/software-assurance/planning-services-overview.aspx#tab=2 for more info on how to cash in on your points.

**UPDATE**

In a comment I was asked about credits for VS + MSDN and I posted a chart which didn't render very well. At the same time I wondered how many points the various assessments cost. So I go that information and have provided it here too:

Here's the number of points you get for some of the VS SKUs:

Product	Points per License
Visual Studio Ultimate + MSDN	75
Visual Studio Premium + MSDN	50
Visual Studio Pro + MSDN	25
TFS CAL	1

And here's what the assessments cost (in points). Remember though, you can use points from any of your SA agreements (not just VS ones):

Offering	Engagement Length	Deployment Points Needed
TFS Deployment Assessment	5 days	2000
Visual SourceSafe Migration Assessment	3 days	500
Visual Studio Quality Tools Assessment	5 days	2000

If you find yourself in the situation of needing this kind of support, check with your Microsoft sales rep and see how you can use this.

Brian