Git-TF vs Git-TFS

TLDR; While both offers a bridge to TFS they do it slightly differently. Git-TF is the only choice if you plan cross platform use. Git-TFS is written for Windows and on top of the TFS-SDK. More on these differences here on StackOverflow. After that their biggest difference is in how they make use of branches and checkins. While Git-TFS can respect and sync a branch-tree from TFS, that is not possible in Git-TF. On the other hand Git-TF provides the –deep option which makes each commit a TFS checkin aswell, which I haven’t found in Git-TFS.

Cross platform

If your need is cross platform, then you don’t really have a choice, Git-TF is the only way to go. Built on Java it runs pretty much anywhere. Git-TFS is built on top of the TFS SDK, which means nearly Windows only. Saying nearly, because I’m unsure weather or not it can run under Mono but I’m guessing not.

Performance

Because Git-TFS is built on the TFS SDK it has very nice performance. Connections are quick and swift. Git-TF is notably slower, especially when connecting. Though, in my opinion, it is still not slow enough to be disturbing.

Branches

Branching is one of the main differences between the two. Still being quite a n00b in the Git space, but learning, I get the feeling Git-TF respects the Git-way of working with branches more. Not that Git-TFS hinders you to do anything, more that it uses some automagic I’m not comfortable with.
In Git-TF you always push your changes, as well as pull, from the master branch, there is no other way. This also encourages you to keep the master-branch clean if something else comes up.
In Git-TFS you can push from any local git branch. It then also automatically downloads anything from TFS you do not currently have, and merges it in. Git-TFS can also keep your TFS branch tree in sync and keep track of it, which is not available to my knowledge in Git-TF. This is done with the --with-branches flag.

TFS checkins

This is the other point where they really differ from each other. In Git-TF you can use the --deep option to make each commit a checkin in TFS. While this is very nice and preserves all history between the two systems, it does put some contraints on how you work. If you have gated checkins activated on your TFS project, this will not work. Either you have to use --shallow which takes all commits and makes a single TFS checkin, or --deep --bypass which bypasses the gated checkin. This may not be what you want.
Git-TFS on the other hand does not have any option to make each commit a checkin in TFS. But it does have a nice checkin-tool (git tfs checkintool) which takes all your commits and builds a massive (depending on number of commits) comment of all your commit messages since last push. Git-TFS does not have any trouble with gated checkins, I’m guessing this is due to all commits are checked in as a single checkin instead of preserving them. The problem probably being that it would be hard to tell the user everything happening with a gated checkin on every single commit.

Further reading

Tagged ,