Until recently we used Microsoft TFS for all of our source control. It worked well enough for small, simple projects where all that was necessary was basic check in/check out functionality.
As our business grew, we started running into limitations with TFS. We found that our clients for the larger projects would request new features that would take multiple months to complete, but still have smaller spot-changes for the project as those features were being worked on. In a standard source control system, branching allows you to work on a feature while the existing codebase is still available for modifications, but in TFS when those branches needed to be merged back together it usually ended up being a massive headache.
We had also recently started focusing more on code reviews to ensure good code quality, and having a source control system able to see the history of changes made code reviews much easier. Unfortunately, TFS also made this process cumbersome. Finally, our clients have increasingly been providing their own resources to aid in development of their projects, and granting those resources access to our TFS usually ended up being more annoying than helpful.
So to summarize, TFS was giving us headaches in the following areas:
- Maintaining and merging multiple branches for a codebase
- Code reviews
- Client access to source code
It was time to make the switch to Git, specifically GitHub. Although there is a learning curve with Git (we all prefer to use the Git Shell instead of any GUI since we know exactly what’s happening), it’s been well worth the investment. With Git, managing, maintaining and merging branches are a breeze (even if there are conflicts) and the GitHub website provides an excellently formatted summarized history of any changes to your source control, which makes code review much, MUCH easier. To top it all off, GitHub is available anywhere you have internet access, without having to fuss around with VPNs, so your source code is always available to either your own team or a client’s team.
Since switching to Git, I’ve had the pleasure of working on a code base where the client had SIX different projects running concurrently, all modifying the code base. To make things more interesting, as each of these projects started, the client had no idea what order they’d be released in! Putting each of these projects into their own branches made maintaining each one relatively easy though, and reviewing the code changes was a snap with GitHub’s site.
This client also had their own developer on staff who was helping with one of the projects. In the past we had given him access to our TFS system, but it was always a pain. Now, with Git, collaborating with him as so much easier. The client ended up releasing 5 of the projects all at once, so 5 branches got merged together with minimal overhead. I couldn’t even imagine what a nightmare this would have been to manage in TFS. I truly think Git was critical in making the release of all 5 of those projects as successful as it was.