In the ever-evolving world of software development, the ability to effectively manage and track changes in code is crucial. This is where good Git hygiene comes into play. Git it's not just a tool; it's a fundamental part of modern software development practices.

A commit, in its essence, is a snapshot of your project at a specific point in time, encapsulating all your changes and updates. It's more than just a mere save point.

The Significance of a Commit

• Building Blocks of Your Project: Commits are the building blocks of your development work. They represent incremental steps towards your project's completion, each with its own unique identity.

• Facilitating Collaboration: In a team environment, commits are pivotal. They allow multiple developers to contribute to the same project without overwriting each other's work. By committing changes and merging them, teams can seamlessly integrate their efforts.

• Rollback and Error Correction: One of the most powerful features of commits is the ability to roll back to a previous state. If a new code introduces a bug, you can revert to a previous commit, ensuring stability and reducing downtime.

• Branching and Merging: Commits are integral to branching and merging strategies in Git. They allow you to diverge from the main line of development, experiment, and then bring those changes back into the main project safely.

Decoding the Components of a Git Commit: The Building Blocks of Project History

When you create a commit in Git, you're doing much more than just saving your work. You're creating a comprehensive package that records the state of your project at a particular moment. Understanding the components of a commit is essential for leveraging Git's full potential. Let's break down these components to appreciate the detailed story each commit tells.

Core Components of a Git Commit

1. Snapshot of Changes

   • Files Changed: This includes modifications to existing files. Git tracks the differences (or 'diffs') from the previous commit, allowing you to see exactly what was altered.

   • Files Added: New files that you've created and staged for the commit are listed here. They become part of the project's tracked files from this commit onwards.

   • Files Removed: If you've deleted files from your project, this removal is also captured. These files are no longer tracked by Git after the commit.

2. Commit Message

   • Essential for Communication: The commit message is where you describe what changes were made and, more importantly, why. Good commit messages are crucial for communicating with team members and your future self.

   • Structure: A good commit message typically has a short, descriptive title, followed by a detailed body explaining the context and rationale for the changes.

3. Unique Identifier (SHA-1 Hash)

   Fingerprint of Your Commit: Every commit is assigned a unique SHA-1 hash, a 40-character string that acts as the commit's fingerprint. This identifier is crucial for Git's version control mechanism.

4. Author and Committer Information

   Who Made the Changes: Git records the author's name and email address with each commit. This is typically the person who originally wrote the changes.

5. Parent Commit Reference

   • Linking the Project History: Every commit (except the initial one) in Git has a parent commit. This link forms a chain that Git uses to track the entire history of the project.

   • Branching and Merging: Understanding parent commits is key when dealing with branches and merges, as it helps Git to correctly combine different streams of work.

The Essence of a Good Commit

The Ideal Size and Scope of a Commit

• Atomicity: A commit should represent a single logical change. Regular commits after small changes are easier to track and manage.

• Small Size: Smaller commits are preferable for ease of understanding and rollback. Group related changes into a single commit.

• Testing Before Committing: Ensure that the new code does not break existing functionality.

• Cleanup code: remove commented code, fix TODOs, remove unused imports, fix linting.

• Avoid Temporal Commits: Avoid commits like "End of day commit" or "Fixing typo.". You can use these as checkpoints while iterating on the implementation, but don't push them to remote. Soft reset the changes and write comprehensive commits and changes are final.

• Example: Adding a function is a good commit size; overhauling an entire module is not.

Writing Good Commit Messages

• Start with a concise subject line: Summarize the change in 50 characters or less.

• Add a detailed description (optional): Explain the 'what' and 'why', not the 'how'.

• Use the imperative mood: "Fix bug" rather than "Fixed bug" or "Fixes bug".

Examples of Commit Messages

Good Commit Messages

1. Descriptive and Concise Title with Detailed Body:

   • Title: "ISSUE_ID: Implement user authentication in login module"

   • Body:

     • "Added JWT-based authentication mechanism."

     • "Included error handling for failed login attempts."

     • "Updated unit tests to cover new functionality."

2. Clear and Specific, Explaining the 'Why':

   • Title: "ISSUE_ID: Fix memory leak in image processing function"

   • Body:

     • "Identified and resolved a memory leak issue where buffers weren't being freed."

     • "Refactored buffer management to improve performance and reliability."

     • "Added comments for clarity on buffer handling logic."

3. Use of Imperative Mood, Reflecting Action Taken:

   • Title: "ISSUE_ID: Refactor database query functions for scalability"

   • Body:

     • "Revised SQL queries to use prepared statements, enhancing security and performance."

     • "Optimized query logic to reduce execution time for large datasets."

     • "Updated relevant documentation to reflect changes in query functions."

Most git providers provide integration with issue-tracking software. So it's a good idea to include the id of the task / issue for easy navigation between the issue and commit an vice-versa.

Bad Commit Messages

1. Vague and Non-Informative:

   • "Fixed stuff"

   • "Updates"

   • "Made changes"

2. Too Broad, Lacking Specificity:

   • "Worked on app"

   • "Changes in code"

   • "Bug fixes"

3. Personal Messages Not Useful for the Team:

   • "Trying something out"

   • "Not sure if this will work"

   • "Committing so I can leave for the day"

4. No Explanation of 'Why':

   • "Changed login"

   • "Edited queries"

   • "Updated files"

You can have temporary bad commit messages while you experiment but don't forget to soft reset the changes and replace the bad commits with good ones.

 git reset --soft $(git merge-base your_main_branch HEAD)

This will move the git history back to the head of your_main_branch and will allow you to push commit over that on your branch.

Key Takeaways for Commit Messages

• Good Commit Messages: Are specific, informative, and explain not only what was changed but why. They follow a clear structure with a concise summary and an optional detailed description.

• Bad Commit Messages: Are vague, overly broad, or too personal. They lack the necessary information to understand the context and rationale behind the changes.

• A good commit is characterized foremost by its size; it should be small and focused, encompassing a single logical change. This granularity not only simplifies understanding and review but also eases the process of troubleshooting and reverting changes if needed. The changes within each commit should be logically grouped, ensuring that all modifications contribute cohesively to a specific functionality or fix. Before committing, it's imperative that the changes are thoroughly tested to maintain the stability and reliability of the codebase. Equally important is the cleanliness of the code in a good commit. It should be free from unused imports, commented-out code, and unresolved 'TODOs'