Master of Commits

Photo by Brett Jordan on Unsplash

Co-authored-by: Onur Yilmaz, Gokhan Karadas and Hüseyin Celal Öner

Table of Contents

· Writing Good Commit Messages
∘ Descriptive
∘ Consistent
· Signing Commits
∘ GPG
· Using Git Hooks
∘ pre-commit
· Conclusion

In this post, we'll talk about the Git commit standards we use daily lives.

Git is a powerful tool for version control and collaboration, but its effectiveness can be limited without good commit practices. This post will discuss some best practices for git commits, including writing descriptive commit messages, using consistent formatting, commit signing, hooks, and other valuable tips.

Best practices for making commits

1. Writing Descriptive and Consistent Commit Messages
2. Signing Commits with GPG
3. Using Git Hooks

Writing Good Commit Messages

Descriptive

A good commit message should be clear, concise, and descriptive of the changes made in the commit. On the other hand, a lousy commit message can be confusing and difficult to understand. For example, a commit message that says “fix bug” doesn’t provide enough information about the bug or how it was fixed.

Here are some tips for writing descriptive commit messages:

• Start with a summary of the changes made in the commit.
• Provide additional details about the changes in the body of the commit message.
• Use the imperative mood (e.g., “Fix bug” instead of “Fixed bug”)
• Limit the line length to 72 characters. This helps you understand when viewing commits within GitHub, GitLab, or git log.

Bonus: Co-Authors

It’s a good practice to mention every people worked on making the commit. You can mention your pairs while adding a line to the commit message, like the following.

fix unit tests

Co-authored-by: User Name <user.name@mail.com>

You can write this manually with your hand, or the co-author tool helps you fulfill this information quickly.

Consistent

Standardized commit messages make reading and understanding a project’s commit history easier, especially when working with a large team.

One popular standardized commit message format is the ConventionalCommits specification. This format uses a prefix to indicate the type of change being made (e.g., “feat” for a new feature, “fix” for a bug fix), followed by a summary of the changes made in the commit.

Such a standard helps you automatically produce tags by looking at the commit history. For example, suppose you've made a commit with fix prefix. Now you can increase the patch part in your version from v1.2.3 to v1.2.4. You can do it yourself or use a tool. There're ready to use tools for this.

Here’s an example of a commit message using the Conventional Commits format:

feat: Add new login page

This commit adds a new login page to the application, allowing users to log in with their email and password.

There are also tools available for enforcing consistent formatting, such as commitlint.

Signing Commits

Signing Git commits is an important practice for maintaining the integrity of the codebase and ensuring that contributions are authentic. When you sign a Git commit, you attach a cryptographic signature to the commit, which verifies that you made it and has not been tampered with since it was created.

There’s a good example of it. Here someone deleted all the Linux codebase by using Torvalds’s email information. It looks like Torvalds did that, but it’s fake because the commit is not signed. That’s why you should always sign your commits and never trust unsigned ones.

GPG

You can use GPG to sign your commits. You generate a public and private key by using the GPG tool. You use the private key to sign the commit and share your public key to GitHub or GitLab, or somewhere else so they can ensure that you make your commits. Here are the resources about it.

• GitHub GPG Tutorial
• GitLab GPG Tutorial

Bonus: Sign your commits with your fingerprint

If you use macOS and have a TouchID sensor, pinentry-touchid helps you sign your commits with your fingerprint.

Using Git Hooks

Git hooks are scripts that can be executed automatically by Git in response to certain actions, such as committing changes or pushing code to a remote repository. For example, the pre-commit hook can help ensure that code is high quality, free of issues, and adheres to a consistent set of standards. By catching potential problems early in the development process, developers can save time and effort and deliver more reliable and maintainable code.

Some specific examples of tasks that a pre-commit hook can perform include:

• Running linting tools to ensure that code meets certain quality standards.
• Running automated tests to catch potential issues before they are committed.
• Check for formatting consistency to ensure the code follows a consistent style guide.
• Scanning for security vulnerabilities or other potential issues in the code.

pre-commit

The pre-commit tool is a popular open-source project that provides a simple way to manage Git hooks, including the pre-commit hook. It allows developers to define a set of pre-commit checks that are automatically executed whenever a new commit is created in a Git repository.

Using the pre-commit tool is relatively simple. Once installed, developers can create a configuration file specifying the checks to be run and any options or arguments needed for each check. When a developer creates a new commit, the pre-commit tool automatically runs the configured checks and provides feedback on any issues found.

pre-commit hooks are stored in a Git repository. That means you can create and use your hook library in all projects. There’re so many community-driven pre-commit hook repositories. You can find many of them here.

• pre-commit/pre-commit-hooks: Official common hooks
• dnephin/pre-commit-golang: Good starter pack for Go projects

Conclusion

In conclusion, good git commit practices are essential for effective version control and collaboration. By following the best practices outlined in this post, you can improve the quality and maintainability of your project and make it easier for others to contribute.