Hot on the heels of announcing the release of Feature Pack 2 – the Testing Feature Pack, I’m excited to announce that the Visual Studio Team Foundation Server 2010 and Project Server Integration Feature Pack is now in Beta.  To avoid being repetitive, if you are new to the concept of a Feature Pack, you can read a little more about them.

The TFS-PS Feature Pack is being released to MSDN subscribers today as a “go-live” Beta.  That means we believe it is ready to be installed and used in a production environment.  Unlike the CTP that has been available for a while now, this is not being released as a Virtual Machine but rather fully installable bits that you can install on your own machine(s).  You’ll be able to call our technical support to get help with any production issues you have and we encourage you to use our TFS/Project Server forum to get quick responses to any questions you have.

What Does it Do?

In short, TFS <-> Project Server integration is a server side synchronization/workflow tool that enables project managers who use Project Server to share up to date project status and resource availability with development teams who use Team Foundation Server whether they use formal or Agile development processes.  It enables the two constituencies to work in the tools of their choice and at a granularity that is most comfortable to them.  Project managers can work in fairly high level tasks using a long range plan.  Developers can see the plan and decompose the high level tasks into detailed assignments in whatever fashion works best for them.  As tasks are decomposed and work is completed, Project Server is updated with both resource availability and task progress.  Of course, all of this ties into the standard Project Server work approval process so that the project manager maintains some control over the high level plan and changes can be deliberate rather than random.  If a project manager wants to deal with all of the detail of the development team, they can configure the integration to import all task breakdown – but for projects that are very large, it’s likely to be overwhelming.

All of this great integrated data can then be rolled up across all the projects in your portfolio into high level enterprise report on progress, resource availability and more:

clip_image001[11]

clip_image001[13]

Let’s look at an example scenario.  A project manager can start by defining a high level plan in Project/Project Server.  Notice that you can control which tasks are published to Team Foundation Server (not all tasks in a project are development tasks – even though we developers like to think that’s all that matters :)).

clip_image002

The development team lead can then use TFS tools – Team Explorer, Team Web Access, Excel, the Agile Workbook, etc to break down the high level requirements/tasks into the development team’s work – tasks, user stories, etc.  This first screenshot is a query run in Team Explorer to show that the Requirements entered in Project Server automatically flowed into TFS, the second shows using Excel to do decomposition and the third shows using the Agile workbooks.

clip_image002[7]

clip_image002[5]

clip_image002[13]

Once the development lead saves the work breakdown, the project manager will get notified of updates and can use Project Web Access to view task and resource rollup.  Notice, the project manager is not seeing the individual tasks but rather a rollup that includes resource utilization so they can do overall resource planning.

clip_image002[9]

 

 

 

And those rolled up detailed tasks are viewed by the project manager as multiple people working on the same high level task.

clip_image001[5]

Of course, if the project manager want a detailed view, all tasks can be marked for publishing between Project Server and TFS and you can get a fully detailed project plan.

clip_image002[11]

If you’d like to learn more there’s a great TechEd presentation/demo done just a couple of weeks ago here: http://www.msteched.com/2010/Europe/OFS201

 

 

 

Internal Dogfooding

We’ve had a few project teams in Microsoft IT using our TFS/Project Server integration since May of this year.  The feedback has been extremely positive.  You can read some of their early comments in the post I did announcing the initial CTP.  We checked in with them again a couple of months ago to get another good overview of how it was working for them.  Here is an excerpt from the meeting notes from that discussion…

What did we hear?

  • Devs don't even know that by updating these tasks they are moving the schedules out two weeks.  We get reality from our developers and most especially from our vendors who typically only tell us what we want to hear.  PMs have the ability to understand the updates fully and their impacts before publishing the project plan.
  • You have given us our nights back.  We had to work with India at night to get their updates.

What did we see?

  • We saw two project plans that were color coded by the PM.  The color coding was based on what he wanted the developer to update and what he wanted control of.
  • We saw that they put the work item ID for synced tasks into the title field.
  • We saw that they had a mix of high and low fidelity in the plan.  In some cases, they only had the feature and it was rolling up the work from the tasks in TFS.  In other cases they wanted to know what was going on with individual tasks so had them in the plan as well.
  • We saw how Mike was doing schedule modeling by putting multiple resources on some tasks to see how it would affect the schedule duration.

 

Licensing and Installation

The TFS-PS Feature Pack is included in MSDN subscriptions purchased with Visual Studio Ultimate.  Specifically, in order to use the TFS-PS Feature Pack, an organization must own at least one license of VS Ultimate with MSDN.  With that one license, the software can be downloaded and installed and then all users with access to either the Project Server or the TFS server that are connected can benefit from the integration.  This is yet one more advantage to owning an MSDN subscription.  If you go to your MSDN download center, you should find the Visual Studio Team Foundation Server 2010 and Project Server Integration Feature Pack as an available download.

This Feature Pack is being released in tandem with VS/TFS 2010 SP 1.  It supports Team Foundation Server 2010 and Project Server 2007 and 2010.  For the Project Server <-> TFS integration to fully work, there are a few components that work together:

  1. TFS 2010 SP1 needs to be installed on any Team Foundation Server 2010 instance that will be connected to Project Server.
  2. VS 2010 SP1 needs to be installed on all VS 2010/Team Explorer clients on which you will use the TFS and Microsoft Project integration (basically project manager’s machines – while we recommend SP1 for everyone, it’s only required for the MS Project integration to work fully)- As you’ve probably noticed, in other news today, we announced the availability of VS/TFS SP1 Beta.
  3. Team Explorer Everywhere SP1 needs to be installed on all TEE 2010 clients – A Beta of TEE SP1 is available already.
  4. The Visual Studio Team Foundation Server 2010 and Project Server Integration Feature Pack needs to be installed on any Project Server instance that will be connected to Team Foundation Server.
  5. You’ll definitely want to read and follow the installation and configuration instructions.  Don’t forget that because it is a .chm file, after you save it to your local computer, you have to right click on it in Windows Explorer and select “Properties…”.  You then need to click the “Unblock” button.  If you don’t do this, you won’t be able to see the content.
  6. If you have people who use VS 2005 or VS 2008 along with the corresponding Team Explorer, you will want to make sure the install the “forward compatibility” patches for those versions.  They’ve been out a good while.  Team Explorer 2005 patchTeam Explorer 2008 patch.  And if you use another IDE and the TFS MSSCCI provider, then you’ll want to make sure you install the latest version of the MSSCCI provider.

We haven’t announced a release date for SP1 or for this Feature Pack but our expectation, pending your validation, is that it will ship sometime in the first half of next year (2011).  It will be possible to upgrade from this Beta to the final release easily while preserving all of your data and state.

How Does It Work?

The synchronization between TFS involves components on the TFS server, on the Project Server server and on the client.  Unfortunately, most of the administrative functions are command line tools right now.  On the good side that means they are scriptable, on the bad side it means they aren’t so intuitive.  Over time, we hope to add GUI administration as well.  Here’s a screen shot of the help for the command line tool.

clip_image001[7]

I won’t go into the details of which commands you need to run and what parameters you need to pass here.  Detailed information on how to configure this is available in our TFS <-> Project Server integration documentation: http://download.microsoft.com/download/1/D/8/1D84BA74-4A54-4CA8-B8F8-6DC7F8CFB0FE/dv_TFSProjectServer.chm

Once this is all configured, you’ll find TFS fields available in Project Server (as you’ve seen in some of the screenshots above) and Project Server information available in TFS.  Here you see a new tab on the work item form with information about synchronization between TFS and Project Server.  Changes made either to TFS or to Project Server will generally show up on the other side within just a few minutes.

Note that Project Server can have different values for some things than TFS does.  For example, let’s assume a developer enters a new remaining work estimate that increases the total work causing the project managers plan to require a change.  The project manager (like they can do in Project Server today) can reject that change.  Obviously, what needs to happen is a conversation between the dev lead and the project manager to figure out what to do about significant project schedule changes.  Rather than just undoing the estimate change the dev team made, we capture both the TFS value and the Project Server value.  Field comparison queries, introduced in TFS 2010, enable you do do things like write a query that will show all work items where the Project Server remaining work is different from the TFS remaining work.

clip_image001[9]

Conclusion

Integration between Project Server and TFS is a huge leap forward for organizations that have both Project Management Offices managing many projects and development teams using TFS.  It enables the organizations to work together effectively while not getting overwhelmed with each others’ detail.  The most innovative thing about it is that it enables the two groups to work both together and independently by enabling them to work at different granularities while providing effective rollup between them.  It:

  1. Provides executives insight into portfolio execution , alignment with strategic objectives, and visibility into resource  utilization of their software development projects by leveraging quantitative data stored in different systems.
  2. Facilitates collaboration between the Project Management Office and Application Development by bridging the gap between waterfall and agile methodologies
  3. Enables development and project management to use familiar tools to collaborate and communicate project timeline and progress such as Microsoft Visual Studio, Project, and SharePoint

Although integrating data together is hugely valuable (and we do a lot of it), true integration requires more than that.  It requires integrating people and part of that is making sure everyone has a natural way to participate in the team using the tools and processes they are familiar with and that best enable them to get their jobs done.  Integration between TFS and Project Server is just the next step in the long journey of ensuring all constituents involved in application lifecycle management have access to the right information at the right time to make the right decisions.

I hope you really enjoy using it.  As always, please try it out and give us any feedback you have.

Thanks,

Brian