Accessing TFS2010 from Visual Studio 2008

I have run several times into a question: Can I (How Do I) connect to TFS2010 from Visual Studio 2008? The answer is YES you can, and here what you need to do:

1. Make sure that Service Pack 1 for Visual Studio 2008 has been installed

2. Download and install Visual Studio Team System 2008 Service Pack 1 Forward Compatibility Update for TFS 2010.

3. Configure connection to your TFS server.

In TFS2010 we now have ability to host multiple collections, groups of Team Project, so as result when accessing to TFS2010 we need to know what collection we are interested in.

General TFS connection constructed like:

http(s)://{Server Name}:{Port}/{Directory}/{Collection Name}

where as:

• {Server Name}, either the name of the server TFS2010 installed on (application tier) or Fully Qualify Domain Name that would resolve to the location of your TFS server
• {Port }, the port configured for TFS access
• {Path}, the path to installed TFS services
• {Collection Name}, name of TFS Team Collection

If you have installed TFS2010 following default suggestions it would be something like that: http://{Server Name}:8080/tfs/DefaultCollection

For example if you have downloaded VS2010 RTM Virtual Machine from Brian Keller’s blog then you can access TFS server from VS2008 by configuring connection string as:

4. But there are limitations on what you can do from Visual Studio 2008 Team Explorer with TFS2010, some of the big ones:

• Creating new Projects
• Working with Hierarchical WorkItem Queries
• Managing Builds
• Reports
• etc

Due to all the new features made to TFS2010.

DogFood v2 Session summary on: Customizing TFS Process Template to Match Your Process.

My slide portion of the session has briefly covered customization and extension points on TFS. Due to time limitations I had to hide a significant portion of slides.  The full version of the PowerPoint Deck is available for download.

In summary, if you are planning on customizing process template I recommend for you to follow a few simple steps:
1. Start with documenting your process.  Do an ALM Assessment, as a mere a fact Microsoft has a great tool for it: Application Platform Capability Assessment.  Spend the time with all the people that are involved in the process and get a "Green Light" from the management.  Remember the process is not only for developers, but for the entire team (including business sponsors and clients).  Create an Action Plan of the implementation steps.

2. Templates shipped with current versions of TFS are not meant to be used as is, they are just blueprints.  Do not treat the process as paint, throwing it on the wall and seeing what will stick is not the best strategy for the development.

3.  Do not expect by customizing TFS process guidance to go fully integrated (dynamic) environment over night. It will take time, long time.  Use your Action Plan (created part of the ALM Assessment) to fully integrated ALM into VSTS/TFS.

4. Treat your TFS server as production server.  Do not go and try some new ideas against.  If you need to prototype a rule or workflow or workitem get yourself a test environment.  Once you know that it is working well in test server, then go ahead and implement it in your production TFS.

5.  Do not be afraid to make process adjustments on active projects (as long as you are following rule #4).  If your project needs a new rule/workitem/field/report/etc then just implement it.  At the end of the project do a retrospective and decide if the change is worth making part of the global template.  If you are not willing to change and adjust the process, chances are it will become stagnant and obsolete.  100 years ago ice houses and transporting ice down the rivers was a booming business, now days we just use refrigerators...

Happy customizations!

Missing Demo from SDLC KY: Branching and Merging with TFS Source Control

This webcast is a brief demo of how one may use TFS Source Control and its rich set of features like: Branching, Merging, and Shelving to manage production and development code.

I have collapsed the 90 minute demo into 35 minute webcast.
This is my first webcast, so any feedback is appriciated.
At some point I will re-record it at lower resolution.

KY SDLC Day 2 Summary

It was a pretty full day, it is very unfortunate that Mike and I have run out of time and were not able to cover all the topics in needed details. In the upcoming days (weeks), I will a set of the recordings to capture testing and source control in greater details, meanwhile you may visit Team System Cafe for a great variety of information on VSTS/TFS.

On Day 2 we have covered following topics:

1. VSTS Architect
We talked about Physical, Logical, and Deployment diagrams. In the demo we have used VSTS as architects (infrastructure & software) and build master to generate/validate diagrams; model the application and to have generated code based on our models.

2. VSTS Database Professional, aka "DataDude"
Is probably one of the most under-used edition of VSTS, which by the way, is now became a part of the VSTS Developer Edition. As a DBA we have covered topics of Managing, Developing, and Deploying database. We reviewed schema compare/validation/refactoring/deployment, data compare, data generation with Data Generation Plans, visioning of database, and creation of database unit tests.

3. VSTS Developer
Since were short on the time we have skipped demoing some of the development tools and concentrated demos on how the developer can use Code Coverage, Code Analysis, and Code Profiling (Instrumentation and Profiling) to troubleshoot and improve the quality of created code.

4. Creating Unit Tests, Test Driven Development, and Data Driven Tests.
In this portion of the SDLC presentation we have talked about the importance of testing and various ways one may start doing it. It can be as easy as "right click" and "generate test" (as I heard at the PDC08: Even a VP Can Do It), to getting into xDD (where x is Test/Behavior/Domain/etc Driven Development). TDD is all about Red-Green-Refactor!

In this section we have also expanded on Code coverage and demonstrated that hooking the test to data source can significantly reduce amount of tests a developer needs to write, while still maintaining a reasonable code coverage.

5. TeamBuild
On all the projects that I have a privilege to be part of, we have also setup a Continuous Server (CI) to establish an environment for automated code build and verification. I try to have a CI setup and go on day one of the project. TeamBuild is an excellent tool for creating and maintaining solution builds, we have demonstrated build can be setup under 2 minutes and perform all kings of tasks including test execution, code analysis, build failure notifications. Since TeamBuild sits on top of the MSBuild one may use a variety of created MSBuild tasks to perform additional actions like: code promotion to QA/Testing environments (only if it passes all other validations), creation of website, registration of DLL, file updates. Using Community MSBuild Tasks from TIGRIS, we were able to change the keys of the web.config file to reflect the changes between development and QA database connection strings. There are many other good collections of MSBuild tasks, like MSBuild Extension Pack.

6. VSTS Tester
Since we had limited time we showed only only Web and Load Tests in details. VSTS Tester edition has a set of powerful tools to allow us to create and manage a variety of test types. One of the greater features is an ability to capture user interactions between the browser and the server on the TCP layer stack and being able to replay it back as a WebTest or convert it to the .NET code.

I will be putting an additional posting to cover Testing in greater details, to cover other type of tests like: manual and ordered.

7. First look into VSTS 2010
Mike has given us a teaser into what Microsoft will be releasing soon, VSTS 2010, TFS 2010, .NET 4.0 all of those tolls has many new and improved features. You may get Mike's presentation from here.

You may find a lot of material on 10-4 (VSTS2010 and .NET4.0) on:

• Team System Cafe, site dedicated to VSTS
• VSTS2010 Beta1, can be download from here
• download a training kit on with a set of Hands-on Labs for VSTS2010, by the way Quick Solutions made contributions to the content.
• a set of the web casts on VSTS2010 .NET4.0 on Channel9, known as 10-4

8. Advance Source Control, for the 4 people that waited patiently for it :)
We have talked about Branching and Merging strategies. We have run through a real-life example on how one may work on the production V1.0 code performing hot fixes, at the same time continue development of the V2.0 application , and how merge can be completed between application branches.

Since mostly of the people missed this demo due to time constrains, I will be putting a recording of it in a very close future.

Here is a great white paper on Branching Strategy

KY SDLC Day 1 Summary

On the first day we have covered the following topics (SDLC deck):

1. Application Lifecycle Management
Mike has talked about the business value of the ALM, here is a link to the Power Point deck.

2. VSTS & TFS Overview
We have covered how Microsoft addresses the need for the robust set of tools for the ALM, the PowerPoint presentation is here.

3. Team Explorer Overview (Security, Collaboration, Alerts, Source Control)

• Team Foundation Administration Tool was used to show how to simplify user management in TFS.
• TFS Power Tools "Alerts Editor" was used to customize alert setup, a user interface to BisSubscribe.exe.
• Team System Web Access and Work Item Web Access were briefly shown as alternatives to default sharepoint site and WIWA a free (no license required) workitem creation tool.

4. Customization / Setup
We have covered some of the popular TFS Templates for Agile Development

• eSCRUM, used by some teams at Microsoft (by some reason the download link is broken, I do have a copy of it somewhere and will post the download link shortly)
• VSTS Scrum on Codeplex, maintained by a group of MVPs, a light version of scrum implementation. It is a great starting point for customization.
• SCRUM for Team Systems from Conchango, out of box fully implemented scrum template with a great set of features.

I have used TFS Power Tools "Process Editor" to modify template during my demos.

5. Work Item Management (Tools for Managing Requirements)
Besides showing a variety of ways one may create and manage work items in TFS (Team Explorer, Excel, Project, Web Access, WIWA) I also briefly demoed: TeamLook and TeamSpec.

What Software did I use for the SDLC presentation

to save time and to make the demos easily reproducible I have used a trial version of Visual Studio Team System 2008 Team Foundation Server SP1 VPC Image, you may download from here. The image will not expire till the end of 2009, so happy exploring!

After booting into it and applying all the security patches, I have also downloaded and installed additional software and tools:
1. Team Foundation Administration Tool - to simplify permission management
2. TeamLook, from Team System Solutions - an Outlook add-on for Work Item Management (will work with TFS2005/2008 and Outlook 2003/2007)
3. TeamSpec, from Team System Solutions - a Word add-on for managing Work Items in the word (again will work with TFS 2005/2008 and Word 2003/2008)
4. Ravenflow - great tool for round trip requirements and work items management.
5. Teamprise plugin for Eclipse - java development TFS integrated development toolset
6. Sparx Enterprise Architect, UML modeling tool.
7. I do not remember if TFS Power Tools were part of the image, but in case you are missing them you may get them from here
8. Tigris MSBuild tasks - a collection of MSBuild tasks to help with TeamBuild automations

[UPDATE]
9. I forgot to include VSTS 2008 Database Edition GDR R2 setup and
10. VSTS 2008 Database Edition Power Tools, I did not use any of the features during the demos, but it has a few great improvements.


Alternatively, if you want to try some of the demos/features for the VSTS2008 and TFS2008 you may want to try to use Team System Virtual Labs, it is truly a great resource.

A Two Day Event: SDLC in a Box on July 15-16, 2009

WHAT:
This 2 day event will focus on application life-cycle management, we will review how one may leverage TFS and VSTS on a project, from initial conception through requirements gathering, design, development, testing, build & review processes. We will demonstrate integration with non-Microsoft development and best-of-breed partner solutions & offerings for Visual Studio 2008 Team System.

For additional information please see http://www.sdlcinabox.com/

Target Audience:
This two day sessions is targeted for Developers, Architects, Project Managers, DBAs and Business Analysts looking for ALM and researching Team Foundation Server.

Speakers:
1. Alexei Govorine:
Co-Founder of the Central Ohio ALM Group
ALM/.NET Practice Manager for Quick Solutions
2. Mike Gresley:
MS SLG Dev Tools team
3. David Baliles:
MS SLG Dev Tools team
Co-Founder of the SDLC in a Box program

WHERE:
Capitol Annex Bldg: Room 171, 700 Capital Avenue Frankfort, KY 40601

WHEN:
July 15-16, 2009 from 9-4:30 PM

Registration Link: http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032418198&Culture=en-US


Draft Agenda of the event topics:
Day 1:

1. Introductions
2. SDLC in a Box: Background
3. Application Lifecycle Management
4. VSTS & TFS Overview
5. Customization / Setup
6. Team Explorer Overview (Security, Collaboration, Alerts, Source Control)
7. Work Item Management (Tools for Managing Requirements)
8. Architecture

Day 2:

1. Database
2. Development
3. Unit Testing & Test-Driven (TDD)
4. Code Promotion: Building & Deploying code
5. Functional Testing
6. Branching & Hotfix Demonstration
7. Reports
8. Q&A
9. (optional) Lap Around VSTS 2010

FRAG! I have checked in the code in TFS05 I did not mean. What do I do now?

Hypothetically speaking...

Lets assume that one of my "friends" made a big mistake and have checked in the code into TFS, and broke the build, and screw up the code that was frozen & suppose to be ready to go to the production!

So, what can the "friend" do at this point, considering that once the code is checked in into the TFS source control it does become part of the permanent record.

Well the "friend" has found that the easiest thing to do, besides blaming the PM is to do following:

1. Find the Changeset that was preceding the check-in, one can do it by right clicking on the solution/project/file(s) (I think solution or project would be preferred to ensure that all changes will be rolled back) and selecting "Get Specific Version"; from the Type dropdown select "Changeset" and using the Changeset dialog to display all change for the day or person.

2. Once the code for the selected Changeset is loaded, you still have nothing to check-in, so trigger the checking process, select solution/project/file(s) and select "Check Out for Edit".

3. Now one should be able to check-in the back into the source control by selecting "Checkin Pending Changes".

4. Here is where the fun comes, during the check-in process "Conflict" dialog will popup, one should select the file(s) and click on "Resolve" choice and select "Discard Server Changes".

5. Now that all conflicts has been resolved, repeat step 3.

 

Alternatively, one may download Team Foundation PowerToys (TFPT.exe) and use one of the nifty commands: tfpt rollback /changeset:###; if there are any conflicts detected user is presented with a "Merge" dialog.

Mysterious ### signs during Work Items export to Excel

Several of my co-workers have run into the problem of exporting work items into the Excel 2007.  The problem was/is during the export of HTML type fields (like description) in some cases they have gotten #### instead of actual words.

There is a forms post that have one of the permanent solutions listed, but I found a workaround to the problem or at least temporary solution by formatting the cell/column.

option 1:

I have selected "Format Cells" -> Number -> Custom -> General -> OK

and the final result is:

option 2:

alternative approach, if one knows how to use new Excel ribbon menus would be selecting cell/column and: Home ->Style -> Normal to reset the style and to re-enable wrapping: Alignment -> Wrap Text

So what is the moral of the post? Lets stop blaming TFS and start learning on how to use Excel  :)

Test Driven Development & Visual Studio Team System

Recently, I was given an opportunity to give a presentation on TDD and how one may use VS2005 to accomplish this task. During the presentation I have used a standard Microsoft presentation on TDD and VSTS.
During my presentation I showed several examples on how to author: unit test, manual tests, load tests, web tests, database unit tests (stored procedures), and ordered tests. We have looked closer at: Test Manager, Code Coverage, Code Analysis and how these functionality integrates with TFS. The sample solution containing all the code can be found here.

My final thoughts on testing in VSTS:
1. Visual Studio Team System makes testing easy, great auto-generation tools allow one to generate all the plumbing without any hassle; it also provides a starting point for learning how to create tests.
2. With an exception on Windows Forms UI tests VSTS allows to generate tests that will cover all the aspects of the development and testing.
3. 100% Code Coverage does not mean that the application is bullet prove, it should be used in conjunction with Code Analysis to identify if we are comfortable the number of tests.
4. all written tests should be used in regression testing, once we start to modify existing code.
5. We have "white tests" written usually by developers that deal implementation and technology details; and "black tests" written by testers (QC/QA) that deal functional requirements of the application.

An interesting thought: From the tester's point of view we need to create a "time line". For example users does something in the system, system does something in response and based on the those results user does something else. For example user creates a task, task's work flow/state triggers additional email notifications that may provide user with additional information.

So what is the problem? The problem is that we are violating several rules: Unit Test must be simple and cover small portions of the functionality and all Unit Tests must be independent of each other. My current solution for this problem:
1. use multiple asserts in the test and
2. group relevant tests in Ordered Test.

Any thoughts on it?