Use Git like a Senior Engineer

Jacob Mitchell
5 min readApr 9, 2023
Git Version Control System VCS Source Control Distributed Version Control DVCS Branching Merging Commit Repository GitHub Bitbucket GitLab Code Review Pull Request Push Pull Clone Fork GitignoreGit Version Control System VCS Source Control Distributed Version Control DVCS Branching Merging Commit Repository GitHub Bitbucket GitLab Code Review Pull Request Push Pull Clone Fork GitignoreGit Version Control System VCS Source Control Distributed Version Control DVCS Branching Merging Commit Reposito
Use Git like a Senior Engineer

Git is a powerful version control system that has become the industry standard for managing software projects. It allows developers to track changes to their code, collaborate with others, and easily revert to previous versions if needed. While Git is a valuable tool for developers of all levels, senior engineers have likely mastered the use of its advanced features and best practices. In this article, we will explore some of the ways in which senior engineers use Git to streamline their workflow and collaborate effectively with their team.

Use branches for feature development

Branches are one of the most important features of Git. They allow developers to work on separate versions of their code without affecting the main codebase. Senior engineers understand the importance of using branches for feature development, bug fixes, and other changes.

When starting work on a new feature or bug fix, senior engineers will create a new branch from the main branch (often called “master” or “main”). This ensures that their work is isolated from other changes happening in the codebase. Once the feature is complete and tested, the changes can be merged back into the main branch.

For example, let’s say a senior engineer is working on a new feature for a web application that involves adding a new page to the site. They would create a new branch called “add-new-page” and start making changes to the code. Once the feature is complete and tested, they would merge the changes back into the main branch.

Use commit messages effectively

Commit messages are an important part of Git. They provide a record of the changes made to the codebase and help other developers understand what was changed and why. Senior engineers know how to write effective commit messages that are clear and concise.

An effective commit message should:

  • Be brief and to the point
  • Describe what was changed
  • Explain why the change was made
  • Use present tense

For example, a good commit message might look like this:

“Add new page to website for user registration

This change adds a new page to the website that allows users to register for an account. This feature was requested by the product owner and is necessary for the site to function properly.”

Use Git aliases to save time

Git has many commands that can be time-consuming to type out repeatedly. Senior engineers often use Git aliases to save time and increase productivity.

Git aliases allow you to create shortcuts for commonly used commands. For example, instead of typing “git commit -m” every time you want to make a commit, you can create an alias called “cm” that does the same thing.

To create a Git alias, use the following command:

git config --global alias.[alias-name] '[command]'

For example, to create an alias called “cm” for the commit command, you would use the following command:

git config --global alias.cm 'commit -m'

Now, instead of typing “git commit -m”, you can simply type “git cm” to make a commit.

Use Git hooks for automation

Git hooks are scripts that can be triggered automatically when certain Git events occur, such as committing code or pushing changes to a remote repository. Senior engineers often use Git hooks to automate tasks and enforce best practices.

For example, a Git hook could be used to automatically run unit tests every time code is committed. This ensures that all code changes are thoroughly tested before being merged into the main branch.

To use Git hooks, create a script that performs the desired task and save it in the “.git/hooks” directory of your project. Git will automatically run the script when the specified event occurs.

Use Git blame to track changes

Git blame is a command that allows you to see who made changes to a specific line of code and when. Senior engineers often use Git blame to track changes and understand why certain changes were made.

To use Git blame, simply run the following command:

git blame [file-name]

This will show you the commit hash, author, and date for each line of code in the file. You can use this information to track down who made specific changes and why.

For example, let’s say you are working on a project with multiple developers and you notice a bug in a piece of code. You can use Git blame to see who last made changes to that code and reach out to them for more information.

Use Git bisect to find bugs

Git bisect is a command that allows you to find the commit that introduced a bug. Senior engineers often use Git bisect to quickly and efficiently track down the source of a bug.

To use Git bisect, follow these steps:

  1. Start the bisect process with the following command:
git bisect start

2. Mark the current commit as bad (i.e., it contains the bug) with the following command:

git bisect bad

3. Mark an earlier commit as good (i.e., it does not contain the bug) with the following command:

git bisect good [commit-hash]

Git will now automatically check out a new commit between the bad and good commits and ask you to test it. Mark the commit as either bad or good based on whether or not it contains the bug. Git will continue to check out new commits and ask you to test them until it finds the commit that introduced the bug.

For example, let’s say you notice a bug in your code and want to track down when it was introduced. You can use Git bisect to quickly find the commit that caused the issue and start debugging from there.

Conclusion

Using Git effectively is an essential skill for any software developer, but senior engineers have likely mastered the use of its advanced features and best practices. By using branches for feature development, writing effective commit messages, using Git aliases and hooks for automation, tracking changes with Git blame, and using Git bisect to find bugs, senior engineers can streamline their workflow and collaborate effectively with their team. By following these best practices, you too can use Git like a senior engineer and take your software development skills to the next level.

--

--

Jacob Mitchell

Software engineer, Technical writer, writing about software development </>