Beyond git commit and git push

For the average user, Git is a tool for saving work and sharing it with others. For the power user, Git is a time machine, a collaboration engine, and a quality assurance platform. In this module, we will explore advanced Git patterns that allow you to maintain a clean, professional history while moving at high speed.

The Architecture of a Commit

To use Git effectively, one must understand that a commit is not a “change” (diff), but a snapshot of the entire project state. Every commit points to a “tree” object, which points to “blob” objects (files). This immutable structure is the key to Git’s performance and reliability.

The Power of the Index (Staging Area)

One of Git’s most powerful features is the staging area. It allows you to craft commits with precision.

• git add -p: Interactive staging. Allows you to stage individual “hunks” of code, ensuring that one commit contains only one logical change.
• git commit --amend: Allows you to fix the last commit without creating a new one.

Rebasing vs. Merging

This is the most debated topic in Git. A power user understands that both have their place, but prefers rebasing for local work.

Merging: Preserving History

Merging creates a new “merge commit” that joins two branches. It preserves the exact chronological history but can lead to “railroad tracks” in the Git log, making it difficult to read.

Rebasing: Rewriting History for Clarity

Rebasing “replays” your commits on top of another branch. It creates a linear history.

package "Merge Strategy" as MERGE {
[A] -right-> [B]
[B] -right-> [C]
[C] -right-> [M]
[B] -down-> [D]
[D] -right-> [M]
}
note bottom of MERGE
Merge Commit (M) joins branches.
History is preserved as it happened.
end note

package "Rebase Strategy" as REBASE {
[A'] -right-> [B']
[B'] -right-> [C']
[C'] -right-> [D']
}
note bottom of REBASE
Commits are replayed.
History is linear and clean.
end note

Rule of Thumb: Never rebase shared branches. Rebase your local feature branch onto the main branch before merging to keep history clean.

The Interactive Rebase: Your Secret Weapon

git rebase -i allows you to rewrite your local history before pushing. You can:

• Pick: Keep the commit.
• Squash: Combine multiple commits into one.
• Fixup: Combine commits but discard the commit message.
• Reword: Change a commit message.
• Drop: Delete a commit entirely.

# Starting an interactive rebase for the last 5 commits
# git rebase -i HEAD~5

Automating Quality with Git Hooks

Git hooks are scripts that run automatically at certain points in the Git workflow.

1. pre-commit: Run linters, tests, and formatting checks before a commit is allowed.
2. commit-msg: Ensure that commit messages follow a specific format (e.g., Conventional Commits).
3. post-checkout: Automatically run npm install or go mod download when you switch branches.

Example: A Simple pre-commit Hook

#!/bin/sh
# Check for focused tests (e.g., .only in Vitest)
if grep -r "\.only" src/; then
  echo "Error: You have focused tests. Please remove them before committing."
  exit 1
fi

Advanced Navigation & Information

• git reflog: The “safety net.” Git keeps a log of every change to the HEAD. If you accidentally delete a branch or perform a bad rebase, the reflog allows you to find the lost commits.
• git bisect: A binary search tool to find the exact commit that introduced a bug.
• git stash -u: Stashing including untracked files.

Collaboration Patterns for High-Performance Teams

1. Trunk-Based Development: Short-lived feature branches that are merged into the main branch daily.
2. Conventional Commits: A structured format for commit messages (e.g., feat: ..., fix: ..., chore: ...).
3. Pull Request Mastery: Using git request-pull or platform-specific tools to provide high-context code reviews.

Exercise: Crafting a Perfect History

1. Create a new Git repo.
2. Make 5 “messy” commits with typos and incomplete work.
3. Run git rebase -i HEAD~5.
4. Squash the commits into two logical units.
5. Reword the messages to follow the Conventional Commits format.
6. Check the log with git log --oneline --graph.

Conclusion

Git is not a backup system; it is a communication tool. By mastering advanced Git techniques, you ensure that your project’s history is as well-engineered as its code. This clarity is essential for long-term maintainability and for bridging the input gap in collaborative environments.