Three Git Tricks Every Developer Should Know
Git is one of the most popular source code management systems available to developers. It was created by Linus Torvalds more than a decade ago. It is easy to get up and running with Git, but it takes time and a bit of learning to become familiar with its more subtle and more advanced features.
In this tutorial, I show you three tricks I find myself using on an almost daily basis. They are easy to pick up and they may save you a lot of time and frustration.
A very useful, yet simple, Git command is
stash. This command stashes the changes in the working directory and the staging area for later use, leaving you with a clean working directory and staging area. The stashed changes are pushed onto a stack. This means that you can create as many stashes as you want.
When should you use the
stash command? Imagine the following scenario. You are in the middle of implementing a complex feature and your working directory is littered with changes in dozens of files and folders. Your boss walks in and asks you to create a build of the release branch you created the day before.
What do you do with the changes in your working directory? Do you make a dirty commit just to make sure you don't lose your work? You could create a new branch and commit your changes on that branch. There is a more elegant solution, though.
git stash. To stash the changes in the working directory and the staging area, you execute the following command.
This is what the result looks like.
Saved working directory and index state WIP on feature/search: 5aa493e Update assets HEAD is now at 5aa493e Update assets
The changes in the working directory and the staging area are safely stored for later use. You switch to the release branch, create a build, return to the branch you were working on, and apply the stash you created earlier. It is that simple. To apply a stash, you
pop it from the stack of stashes.
git stash pop
If you frequently use stashes, it is recommended to name your stashes. This makes it easy to find stashes and apply or remove a stash by name.
git stash save "search feature"
Saved working directory and index state On feature/search: search feature HEAD is now at 5aa493e Update assets
In a way, patching is similar to stashing. Both commands group a number of changes that you can apply later. A patch combines several commits or the changes in the working directory. The changes are stored in a file with a .diff extension.
Patches are useful for several reasons. It is easy to store patches to disk or share them with other developers. You can apply patches to branches no matter what the branching model looks like. They are also a good alternative to cherry picking.
I interact with Git using a combination of the command line interface and Fournova's Tower. Creating a patch is very easy in Tower. Select the commits you want to include in the patch, right-click, and choose Save Patch for X Revisions... from the contextual menu.
Patches can be used in a wide range of scenarios. Imagine you are working with a teammate on a big, complex feature. You are both working on the same branch and firing on all cylinders, committing as if your life depended on it. You are about to push your changes to GitHub when you notice that your teammate already pushed her changes. It is time to pull and perform a nasty merge. I don't know about you, but I don't like these kinds of merges.
The solution is surprisingly simple. You create a patch, include the commits you are ahead of the remote branch, and reset your branch to
HEAD of the remote branch. You then pull the changes of your teammate and apply the patch you created earlier. If you are both working on the same branch and modifying the same files, then it is still possible that you need to perform a manual merge.
Keep in mind that a reset is a potentially dangerous operation that can lead to data loss. Always bear this in mind when using the
A project with any degree of complexity needs a robust branching model. The branching model I have come to appreciate is the one outlined by Vincent Driessen. Vincent's model may look daunting at first, but it is easy to adopt in most software projects.
The idea is simple. A project adopting Vincent's branching model has a
master and a
develop branch. If you decide to work on a feature, you create a feature branch that branches off of
develop. When a feature is ready to be released, the feature branch is merged back into
When the time comes to schedule a release, a release branch is created that branches off of
develop. The goal of the release branch is to prepare the release and fix critical bugs. A release branch is never used to implement features. After a successful release, the release branch is:
- merged into
- merged into
- merged into every downstream release branch
develop and every downstream release branch is important to guarantee that any work done on the release branch, such as bug fixes, are also included in feature and downstream release branches.
If you need to push a hotfix to the public, you create a hotfix branch that branches off of
master. After releasing a hotfix, the same merge strategy is applied as for release branches.
This branching model has worked really well for me and the projects I have worked on. Make sure to prefix branch names with
hotfix/ to avoid confusion.
Git is essential for my daily work. I really enjoy using it and appreciate its speed and flexibility. Getting up to speed with Git is easy once you understand the basic concepts. Questions? Leave them in the comments below or reach out to me on Twitter.