This is similar to AppSight that is a product that has been around for some time, though it has the ability to provide this information for unmanaged code.   Appsight allows stepping backward and forward in a simulated debugger.  The intellitrace view is more like a trace log that you can click through to look at that point in time.

For managed code this seemed like a great improvement to debugging and I’m sure managed developers will greatly apprciate this new feature.

On the unmanaged side intellitrace doesn’t do very much.  Though one nice feature available in both managed and unmanged code is Tracepoints.  Tracepoints provide the ability to run a macro at a breakpoint, output a trace  line as an example. 

So now instead of having to add trace lines to your code and recompile, you can add trace lines on the fly that don’t need to exist in the code, they just exist like breakpoints would when debugging.  I suspect unmanaged developers will come to like this new feature as well.

I’m looking forward to digging deeper into the VS2010 in the future.

The installation is much improved offering an easier basic option that can install the majority of simple components for a very simple installation or test.  Still had issues with the install but this is vastly improved from TFS 2005/2008.  The configuration wizard acts much more like sharepoints config wizard.

A very quick check of source control functionality changes seems to be related to the branching and merge visualization.

Branching was changed to be a single atomic operation.  I’m not overly fond of this as it had been very nice to pend the changes before they actually were created to get the branch trees just right first.  I wish they offered both options.

Branches also have their own unique little icon now and a branch is now a permissionable object in TFS.  Having both descriptions, hierarchy and permissions.

Branch and merge visualization has changed.  You can now visualize the branch tree and the changeset merges into the branches.  Many different graphical visualization options are available.  This is a much welcomed change and has been sorely needed since the beginning.

Branch/merge permissions are a nice feature a lot of folks have asked for to limit who has the ability to do certain operations related to a branch.

Baseless merge support still seems to be sorely lacking in TFS that can make some development scenarios much more painful to manage.

Labels still don’t seem to show in relation to merge history visualization that other products like clearcase, mks and others offer.

Label history still only shows the label that was applied but not the version it was applied at and does not appear to show recursively.  Other products again offer better options still.

The new TFS 2010 interface has an annoying habit of creating new history windows every time you view history.  I would have prefered same window re-use with an option to open another window.  (I haven’t found if there is an option to change this yet).

Get latest checkout appears to be an option at the team project level now if desired.

I haven’t tested this yet but still haven’t found an option that would help it but it still seems dealing with Word documents would be painful in TFS since they are binary and there is no way to force get latest on checkout by file type that I can see, it can be possible someone checks out an earlier version and tries to update but it won’t allow the merge obviously since its treated as binary.  (Maybe there is a new option that will handle this I haven’t found yet.)

A nice touch that was added was the conflict resolution view to the pending changes window.  This should significantly improve on the ease of use for resolving conflicts.

There have been reports on other blogs of performance concerns with TFS2010 and MS has been asking people to provide any info on performance issues they may find.  I haven’t run any type of testing to evaluate this yet.

Rollback seems available in the default tf.exe command line options and the interface looks improved supporting rollback of a range of changesets or a timeframe, I still don’t see a UI for this in the interface though.

There are many more features to try, Build controllers, lab management and more I look forward to checking out.

TFS Still seems to be lacking in some basic areas while MS builds out the more involved lab management and build management.  I wish they would address the basic concerns first (Rollback, label history, merge history with labels, tracking changes in relationships to projects, etc. that other products already do and are considered somewhat basic functionality for the enterprise products in this category.)  With that said TFS holds great promise with one of the few new products in this category being built out now by a major firm, and by the firm that creates visual studio the level of integration currently and we might expect in the future should be high.

Team Foundation Server is frustrating to a lot of folks as it appears some basic features like rollback, history with labels and merge information were left out from the UI or out completely. 

Rollback at least is offered from the command line (only if you install power tools, its not even built into the product).  Even then it is very painful to use as it requires syncing EVERY file in your workspace to do ANY rollback at all.  Also certain command line options don’t work or produce errors.

After enough complaints about this I just threw together a very quick batch file (so please excuse the formatting bugs, etc J ) that uses the power tool rollback but also helps create a new temporary workspace so that you can limit the amount of workspace sync time you need to do.  I would have had this with no prompts but at least on TFS2005 the command line tool gets errors when I use /noprompt.  (I haven’t actually tested with the TFS2008 version yet, though the script here should handle it if you have it.)

Pre-requisites for this are you have VS2005 or 2008 installed with the TFS2005/2008 client installed into the default directories on either the c: or d: drives (you can edit the script if you have it somewhere else).

At  start of the script set the TFSSERVER value to the name of your server.

After you run the script look to see if there were any errors then go to the workspace RollbackTmp in your visual studio (you may have to restart it to see that workspace if you had it running).  Go to pending changes window and select that workspace and click the refresh button.  If it all looks good then check in the changes.

Usage:

 rollback workspaceserverpath workspacelocalpath changeset filespec/dir [/recursive] [/useexistingworkspace]

workspaceserverpath –  is the server directory that we want to map to a local folder.  It should be at the lowest level possible that captures all of the files below it in the changeset you plan to roll back.  You want it as low in the folder tree as possible as the rollback tries to sync ALL files that are mapped in the workspace, so map as few as needed.  Example: $/Project1/Folder1

Workspacelocalpath – The local directory that you want the server directory mapped to.  This can not overlap any other folders for other workspaces on your machine.  Example: d:\tmp\Project1\Folder1

Changeset – This is the changeset you want to rollback.  Example: 123456

Filespec/dir – This is the server/local file or directory path  If this is a directory all files in the changeset at that directory will be rolled back (if you use /recursive all files in that changeset modified at the specified directory/filespec and below will be rolled back)

/recurisve – If used will recursvie rollback any files that match the spec or below.

To read up more about rollback look at the team foundation power tools documentation.

Example:

rollback $/TestProj/Folder1/Docs d:\tmp\TestProj 123456 $/TestProj/Folder1/docs /recursive

This example creates a workspace that maps $/TestProj/Folder1/Docs to the local folder d:\tmp\TestProj and rolls back changeset 123456 for anything in that changeset that was modified in that changeset at the path or below $/TestProj/Folder1/Docs (and lower level directories since the recursive option is specified.)

Save the below file to rollback.bat or something along those lines.

@Echo off

set TFSSERVER=<put your server name here>

set WORKSPACENAME=RollbackTmp

if not exist “C:\Program Files\Microsoft Team Foundation Server 2005 Power Tools\tfpt.exe” goto tfs2008check:

set TFPTPATH=”C:\Program Files\Microsoft Team Foundation Server 2005 Power Tools\tfpt.exe”

goto found

:tfs2008check

if not exist “C:\Program Files\Microsoft Team Foundation Server 2008 Power Tools\tfpt.exe” goto tfptnotfoundc:

set TFPTPATH=”C:\Program Files\Microsoft Team Foundation Server 2008 Power Tools\tfpt.exe”

goto found

:tfptnotfoundC

if not exist “D:\Program Files\Microsoft Team Foundation Server 2005 Power Tools\tfpt.exe” goto tfs2008checkD:

set TFPTPATH=”D:\Program Files\Microsoft Team Foundation Server 2005 Power Tools\tfpt.exe”

goto found

:tfs2008checkD

if not exist “D:\Program Files\Microsoft Team Foundation Server 2008 Power Tools\tfpt.exe” goto tfptnotfoundall:

set TFPTPATH=”D:\Program Files\Microsoft Team Foundation Server 2008 Power Tools\tfpt.exe”

goto found

tfptnotfoundall:

Echo “Did not find TFS Power tools 2005/2008 on C or D drives in default directories

goto altexit:

:found

Echo Found tfpt.exe

if not exist “C:\Program Files\Microsoft Visual Studio 8\Common7\IDE\tf.exe” goto tfddrivecheck:

set TFPATH=”C:\Program Files\Microsoft Visual Studio 8\Common7\IDE\tf.exe”

goto foundtf

:tfddrivecheck

if not exist “D:\Program Files\Microsoft Visual Studio 8\Common7\IDE\tf.exe” goto tf2008check:

set TFPATH=”D:\Program Files\Microsoft Visual Studio 8\Common7\IDE\tf.exe”

goto foundtf

:tf2008check

if not exist “C:\Program Files\Microsoft Visual Studio 9\Common7\IDE\tf.exe” goto tf2008ddrivecheck:

set TFPATH=”C:\Program Files\Microsoft Visual Studio 9\Common7\IDE\tf.exe”

goto foundtf

:tf2008ddrivecheck

if not exist “D:\Program Files\Microsoft Visual Studio 9\Common7\IDE\tf.exe” goto tfnotfound:

set TFPATH=”D:\Program Files\Microsoft Visual Studio 9\Common7\IDE\tf.exe”

goto foundtf

:tfnotfound

Echo “Did not find tf.exe for 2005 or 2008 on C or D drives in default directories”

goto altexit:

:foundtf

Echo Found tf.exe

if “%1″==”"  goto usage:

if “%1″==”/?” goto usage:

if “%2″==”"  goto usage:

if “%3″==”"  goto usage:

if “%4″==”"  goto usage:

:domainworkhere

if “%5″==”/useexistingworkspace” goto skipworkspacedelete:

if “%6″==”/useexistingworkspace” goto skipworkspacedelete:

%TFPATH% workspace /delete %WORKSPACENAME% /server:%TFSSERVER%

:skipworkspacedelete

%TFPATH% workspace /new %WORKSPACENAME% /server:%TFSSERVER% /noprompt

%TFPATH% workfold /unmap $/ /server:%TFSSERVER% /workspace:%WORKSPACENAME%

%TFPATH% workfold /map %1 %2 /server:%TFSSERVER% /workspace:%WORKSPACENAME%

mkdir %2

Rem @Echo on

cd /D %2

REM @Echo off

rem Echo Above you should see path got changed to the workspace local path you specified. If not hit ctrl-c to exit

rem Echo about to run the rollback command…

rem pause

if “%5″==”/recursive” goto skipworkspacedelete:

%TFPTPATH% rollback /changeset:%3 %4

goto done:

:recursive

%TFPTPATH% rollback /changeset:%3 /recursive %4

:done

Echo *************************************************************************

Echo * Changese NOT checked in – Review changes in workspace %WORKSPACENAME% *

Echo * Then checkin if good.  Undo changes if you don’t want those checked in*

Echo *************************************************************************

goto altexit:

:usage

Echo Usage:

Echo rollback workspacepathserverpath workspacelocalpath changeset filespec/dir [/recursive] [/useexistingworkspace]

Echo -                          

Echo This command will create a temporary workspace named %WORKSPACENAME% and delete it.

Echo Example:

Echo rollback $/TestProj/Folder1/Docs d:\tmp\TestProj 123456 $/TestProj/Folder1/docs /recursive

:altexit

http://referencesource.microsoft.com

This bit of source code is interesting as it shows a fast thread safe way to  lazy init a property/object.  In this case the SyncRoot for a list.  The Interlocked.CompareExchange is key:

// Synchronization root for this object.

        Object System.Collections.ICollection.SyncRoot {

            get {

                if( _syncRoot == null) {

                    System.Threading.Interlocked.CompareExchange(ref _syncRoot, new Object(), null);

                }

                return _syncRoot;

            }

        }

This seems to work, though with one issue found so far getting an error trying to bring up permissions.

The benefits of doing this are:

1.  You can view history labels in the interface but it is very slow – many minutes before a data return on TFS2005, much faster on TFS2008

2. You can edit labels with it’s much better label interface, though still a bit slow on TFS2005, 2008 is better.

Not much else notable in the interface that I found yet that would be beneficial to use this client to connect to an older repository.

Updated: Microsoft says TFS2010 client is not supported going against the tfs2005 server.  It is only supported against tfs2008sp1 or later.

Resharper  main features:

Better intellisense

Better highlighting

Better refactoring

Error/warning bar down the side

Code shortcuts/templates

Auto Using clause helper and cleanup.

Help inserting/creating template code

Better code searching

The only negatives I’ve really had or heard about resharper is it seems to slow down the interface a lot.  JetBrains claims to have improved this a lot in the latest version (I have not tried yet).

Even with the IDE slightly slower, Resharper makes me a more productive developer period.

After using Resharper I was hooked, I find it hard to code in C# without it, and feel encumbered when it’s not installed on a machine I am using.

Resharper pricing at this time is $349 commercial, $199 personal,  $49 academic, and free classroom license. 

A few years ago the price was quite a bit cheaper and this was a much easier sale.  It would be nice if they reduced the price for personal use a bit more and the commercial license.

You can download a trial copy at: www.jetbrains.com

You may be asking yourself,  why is this guy posting information about a product that has been out for a long while.   The answer is somewhat simple.  I want to provide information on products I use or have used, so that you get more than just a quick overview or a one shot article on a product, but where I can provide a bit more information about how the product will really work.  Since this is one of my first posts, I’m starting with something I have a bit of experience with.

This information was coalesced from using TFS and reading a lot of the forum posts.

I am going to focus on version control features as that’s what we use.  I’ll offer some guidance on best practices we found, etc.  I’m going to point out a lot of issues either we’ve encountered or read about on the forums and just wanted to put these all together in one place.

Version Control:

VSS to TFS differences:

From an outsiders view it would appear that Microsoft gave very little thought to the migration from VSS to TFS for users.  Several workflows that were simple and fast in VSS are now either impossible or cumbersome in TFS.

Set Working Directory vs. Workspaces

TFS No GetLatest on checkout

TFS No recursive version history that includes labels

TFS History does not by default show all files changed only changesets involved with the files in the requested path.

Labels are actual entities in TFS that can point to multiple points in time.

Can’t compare source repository to an arbitrary location/directory with the same structure.

GetLatest can remove files (if files have been renamed/moved/deleted they will be updated in your workspace in TFS)

Getting labels will remove any files below the GET location that are not part of the label you are getting.

Workspaces coming from the VSS world are a little annoying since the software enforces them failry vigorously and doesn’t let you stray outside the lines by getting code to different locations than the mapped workspace folders.

Merging/Conflict resolution:

The good:

Basic one way merging works pretty easily. 

Many one way merges to branches of latest can work with very little manual intervention.

The bad:

Merging is one of the weaker aspects of TFS2005.  Many users didn’t like the merge tool provided by default as it was confusing.  The messages for the user to resolve conflicts are very confusing and likely need to be reworded. 

Merging to branches merges into the targets location based on the current workspace version of the files.  Often times many users want to merge into the latest version.  Having an option to merge latest would be a nice option they should have added here.

Merging won’t merge files that were potentially deleted and re-added.  This would require a baseless merge and can only be done from the command line.

When merges started to get complex (two way merges and cherry pick), it is possible to get into scenarios where a merge is not possible or requires workarounds to continue or command line options and/or baseless merge.  The tools for looking at merge candidates are not in the UI and requires command line or third party tools (TFS sidekicks – that are a bit slow)

Merge Guidance:

As always only do as much merging as you need to do, try to avoid if appropriate and possible.  Try to limit your branch/merging set up to be doing single direction merges and not using cherry pick merges if can be avoided.

IDE Integration:

The integration works pretty well.  Though at times, it feels like the fact that full source control integration is now in the IDE wasn’t completely taken into account.  Many users coming from the VSS world complained about not having a separate IDE to work with.  Some would say you could always bring up another IDE and use that but the combination of the launch time, memory consumption and that cross IDE refreshes would be required would certainly detract.

Labels:

Labels with scoping to a directory or even files offer great flexibility.  The IDE leaves a bit to be desired here in that the IDE doesn’t display scoping and it will decide to scope labels based on the items included in the label to either the team project or the $/ root scope.  The ability to include in a new label files from a previous label is nice allowing to use other labels as baselines.

Microsoft really needs to expose the scope in the UI default always to the team project and let the user choose an alternate if appropriate. 

The interfaces lack of displaying anything about labels in history is a bit of a drawback for many users.  Loading labels to edit them is slow with TFS2005.  Editing labels in the flat list in the dialog is very cumbersome.

Branching:

Basic branching works pretty easily.  Branches can take a minute or two for creation.

It would be nice if branching could be done without having workspace locations mapped to local drive locations.

Version History:

The history supplied is changesets only with no option of expanding to show details or another pane to show details makes viewing history more difficult than it needs to be.  In addition other version control providers provide show labels applied to items and part of history, but this is not included in TFS2005 (or TFS2008 for that matter).  No history is shown beyond a branch point.

Checkouts:

Checkouts should indicate clear if the file you are checking out is the latest version or not.  This would allow users that wished to avoid excessive merging the option of remembering to do a get latest to avoid additional merging (or offering the get latest on checkout option.)  There are two add-ins that can be used that can be found on the internet that can do get latest on checkout one always does it and the other asks first.  (MS really should have built this in)

Checkins:

Checkins work as expected though the pending changes and checkin windows should give clearer indications about what files will and won’t be checked in and have better ways to sort and filter to determine what files have a check mark to go in or not.

Checkin Policies:

The checkin policies are a nice options for TFS.  The unfortunate part is they need to be enabled on the server and installed per client/user.  So if a user doesn’t have a policy installed they just get a policy error when they try to checkin.  The part is policies aren’t really enforced, they can always be overridden with a comment and checking the override box.

Renaming Folders:

Due to the versioning of folders, renaming can be a nightmare for users  especially for any users not fully trained in the nuances.  Also since GetLatest of partial paths rather than the root of the folder rename can make files disappear can further confuse users. (Yes this works as designed but offering some indications and options here might be useful).

Recommendation:  If you must rename a folder, make sure no one has any files checked out or wait till they don’t.  When no files are checked out for that folder or lower rename and tell everyone to do a getlatest from the top level folder that was renamed. 

Permissions:

The permissions are all over the board as there are somewhat different permissions needed for sharepoint, tfs projects and source control, plus reporting services.  Third party tools were created just to help manage this.

The source control permissions available work fairly well.  We did find ourselves wishing there was a separate permission for modifying labels, vs. adding files to labels.

Inheritance of permissions:

Be careful disabling inheritance of permissions for source control.  By default it does not copy but instead removes all permissions (it leaves the users and groups in view when you uncheck but removes the permissions (making you think it copied, but it does not).    So users often uncheck inheritance click a few items they wanted to change and click OK not realizing they just removed almost all permissions.

Shelvesets:

This feature allows users to save as many named copies of their checked out files with comments as they like to the server.  In effect creating a backed up checked out files without having to actually check them in.  This feature works well and is great if you need to switch tasks and come back to a task.

Migrating VSS to TFS:

If you look at the TFS forums you’ll note many complaints about the performance of the VSSConverter tool, it’s slow.  Suggest planning and testing the migration in the actual setup you plan to really do it to know  the real time it will take.  This means you will have to burn space to do it or re-migrate as a catchup migration later. 

Recommend when migrating migrate to the final resting place you want don’t rename later.  Renames  of folders are somewhat more painful in TFS since folders are versioned.

Administration:

There is a pretty serious lack of administration tools for managing the server.   Out of the box pretty much nothing to give a hint as to what the server is busy doing, etc. 

There is no IDE for deleting users old workspaces or undoing checked out files.  There is no general tool for listing users workspaces, shelvesets, analyzing storage, or anything along those lines.

Command line tools:

There seem to be many more options available from the command line then from the IDE.  From the command line you can do things like find out all of the files checked out, workspaces by a user, etc.

These are generally fairly easy to use, though it would be nice for the command line tools to not require setting up a workspace and to allow downloading files to arbitrary locations for builds machines, etc. 

General server issues found:

It seems our biggest issues tended to be running out of memory for the IIS process (so MS suggested increasing recycle times).  Also running out of disk space on our c:\ on the server (obviously our fault).

Solution Explorer source control operations:

For some reason we seemed to find the most problems/user complaints using this window to do checkins/outs.  Some definite bugs were found that seemed to be resolved by service pack and hotfixes.  In addition to that though there just seemed to be times something unexplained would seem to happen.

The best thing may be to avoid using this window for checkouts and checkins, moves and renames when you can or at least watch everything you do very carefully if you do. 

Word documents in TFS source control:

Due to the lack of get latest on checkout per file type option word documents are more painful to use as if you forget to get latest you might checkout and edit an earlier version of a document that you can’t checkin. 

Typical User issues:

During the initial migration undercheckins and overcheckins seem common.  Meaning people would somehow checkin too many files or two few files.  Sometimes we believe this was due to source files not being controlled due to binding issues during the migration from VSS to TFS.  Other times we believe this was due to developer workflow and the fact that the Pending changes window or checkin UI do not make it clear/easily viewable at a glance as to what will be checked in.  This is due to having the checkboxes required to be checked to checkin and if the developers have many files checked out they have a large number of files to look through when they are doing partial checkins, and sometimes include too many or too few files.  The UI ideally should have a way to filter to show only checked files I plan to checkin to make viewing this list easier, and in the normal mode indicate how many and if there are more checked/unchecked items above and below the view plus the total number checked/unchecked items.  

No permanent delete in TFS 2005:

This seems to be a glaring missing feature that is added but only via command line to the next version TFS2008.

Rolling back versions:

Presently rollback of changesets is only support being the add in power tools.  Otherwise rollback needs to be done manually and is quite cumbersome due to the protections from overwriting checked out/writeable files.

Work Item Tracking:

We didn’t use this functionality much on the team I was on, though I know of another team using this successfully.  My take on this is it seems to be a very basic implementation of issue tracking.  It is mildly expandable but not to the extent of other issue tracking systems available on the market.

Summary:

TFS 2005 is a nice entry point for Microsoft for a enterprise development product that supplied source control,  issue tracking, reporting, builds and more.   Compared to it’s competitors the integration is a key selling point.  The interface usability feels very much like a 1.0 entry unfortunately that we hope will be refined more in future versions.  TFS2005 is a little weak on the merge functionality, and the work item extensibility.  Developers migrating from VSS with particular workflows may find the transition more difficult than it needed to be.  Many would have expected that Microsoft would have made the migration from VSS to the TFS product a little easier to smooth the upgrade path.   The good news is there is very little maintaining required to run the product like some other products in this category.  One of the biggest selling points here may be this is a major entry for Microsoft into the enterprise developer tools area and holds some great promise for some of the future plans for TFS.

(All information is provided “as is”.  All copyrights are held by their respective owners.)