How to Use Git Tags to Improve Your Development Processes

For most development teams, Git has become an essential tool for version control. A big reason for Git’s popularity is its seamless ability to create branches. Development teams can use branches to work on specific features or releases. However, Git’s tag is an often overlooked command that can help teams simplify their workflows. In this article, we’ll dive into the what’s, how’s and why’s of Git tagging.

What Are Git Tags?

Git tags are pointers to certain commits. They are like bookmarks. You can use any kind of convention you want to create tags. But most development teams use version numbers like v1.0.1 or v.1.1-a1 to create tags.

Creating Tags

There are two types of tags in Git:

• Lightweight Tags
• Annotated Tags

Lightweight Tags

The lightweight tags are easy to create. You can simply use the following command line:

These tags are stored in the .git folder of your working repository.

Let’s create a few lightweight Git tags:

In the first case, we created a tag with “v1.0.1”. In the second case, we created a tag with “Release-20190401”. The lightweight tags don’t return any value. Also, it’s important to point out that because these two tags were done back to back, they are pointing to the same commit.

Annotated Tags

Annotated tags let you store more information. You can use the “-a” option to create these tags:

Let’s try to create an annotated tag:

It will pop-up a text window for you to enter a comment that should look like this:

Enter a comment and save it. So, now your tag v1.0.2 is saved with a comment. Alternatively, you can directly enter the comment in the command line like this:

Finding Tags in Your Code

Now that we have created a few tags, let’s see what we have:

We can see all of our tags are displayed in alphabetic order. You can get more information about the tags by using the “-n<number>” where <number> stands for the number of lines of the comments.

Here you can notice a difference between lightweight and annotated tags. In this example, “Release-20190401” and “v1.0.1” are lightweight tags. The “v1.0.2” and “v1.0.3” are annotated tags. All of them are pointing to the same commit (commit 34671):

However, the lightweight tags are showing the comments from the commit itself which is “Updated README.md”, while the annotated tags are showing the individual comments that were added to them during the tag creation process.

Tip: If you want to find the commit number of a particular tag, you can use the “git show” command:

Tagging Older Commits

You can also go back and tag an older commit. Let’s look at the logs:

We notice that the commit 161c6e5 doesn’t have an associated tag. We can tag this commit like this:

It will pop-up the comment window. After we put in the comment, we can see that we have the commit tagged now:

Removing Tags

Suppose, you decide that you don’t want the “Release-“ tags as they are confusing. You can first find all the “Release-“ tags:

Now, you can remove them with the “-d” option:

If we check the tags again, we should only see the tags that start with “v”:

Overwriting Tags

Suppose, we have a situation where “v1.0.4” tag is poing to Feature 2:

But we want the tag “v1.0.4” to be pointing at Feature 3. If we try to retag it, we get this error:

We can overcome this problem with the “-f” option:

If we check the log again, we see that the tag has moved to the commit we want:

Alternatively, you can also delete a tag and re-add it to a new commit.

Sharing Tags with Other Users

When you push your code to your remote repository, Git tags don’t get pushed automatically. If you want to share your tags with other users, you have to exclusively push them.

The tags can be pushed like this:

Now, if other users clone the remote repository, they will only see the tag that was pushed (“v1.0.4” in this case).

Using Branches vs Tags

Branches are useful for new features or experimenting. Generally, you want to branch when there is future work that needs to be done and the work is disruptive to your current development. On the other hand, tags are more useful as snapshots. You should use them to remember particular things that you have already done.

In Conclusion

Git tag is an under-utilized feature that can provide a great way to keep track of releases and special features. If you set up good practices around tags, it can help you easily communicate with your development team and simplify your development processes.

Further Study:

• https://git-scm.com/book/en/v2/Git-Basics-Tagging
• https://softwareengineering.stackexchange.com/questions/165725/git-branching-and-tagging-best-practices
• https://www.atlassian.com/git/tutorials/inspecting-a-repository/git-tag
• https://en.wikipedia.org/wiki/Software_versioning
• https://www.techopedia.com/definition/25977/software-versioning