Git in Practice: Real-World Examples for Developers

Git is the bedrock of modern software development, yet many developers rely on a limited subset of its commands. Moving beyond basic commits and pushes allows teams to maintain cleaner history, resolve complex integration issues, and automate quality control. This guide explores practical, real-world Git scenarios that help you move from simply tracking changes to mastering professional source control workflows.

Mastering Branching Workflows

In a professional environment, branching is not just about isolation; it is about managing the lifecycle of features. Most teams adopt either Gitflow or Trunk-Based Development. In practice, the key is keeping branches short-lived.

Feature Branching Strategy

When working on a new feature, always create a descriptive branch name. Avoid generic names like fix or update. Use a naming convention such as feature/user-authentication or bugfix/api-timeout-issue.

# Create and switch to a new feature branch
git checkout -b feature/add-oauth-support

# Perform work and commit
git add .
git commit -m "feat: implement OAuth2 flow for user login"

By keeping branches focused on a single task, you simplify code reviews and minimize the risk of massive merge conflicts later. If a feature takes more than a few days, consider breaking it into smaller, mergeable chunks.

Resolving Merge Conflicts Like a Pro

Merge conflicts are inevitable in collaborative environments. They occur when two branches modify the same line of code or when one branch deletes a file that another branch modified. The trick is to stay calm and approach the conflict systematically.

When git merge fails, Git marks the files with conflict markers. You can use git status to identify these files. Open the file and look for the following structure:

<<<<<<< HEAD
const apiBase = 'https://api.production.com';
=======
const apiBase = 'https://api.staging.com';
>>>>>>> feature/new-environment

To resolve this, choose the correct implementation, remove the markers (<<<<<<<, =======, >>>>>>>), and finalize the merge:

# After editing the file
git add <filename>
git commit -m "fix: resolve merge conflict between staging and production config"

Cleaning Up History with Interactive Rebase

Sometimes, your local commit history is messy, filled with "wip" or "typo fix" commits. Before merging into the main branch, use an interactive rebase to squash these into logical, atomic units of work. This makes the project history much easier to audit.

# Rebase the last 3 commits
git rebase -i HEAD~3

An editor will open, allowing you to change pick to squash for the commits you want to combine. This results in a clean, professional commit log that explains why changes were made, rather than showing the chaotic process of how they were made.

Automating Quality with Git Hooks

Git hooks allow you to run scripts automatically when specific events occur. For example, you can prevent developers from pushing code that fails linting or unit tests. The pre-commit hook is particularly useful for ensuring code quality before it ever reaches the repository.

Create a file at .git/hooks/pre-commit:

#!/bin/bash
# Run linting before allowing a commit
npm run lint
if [ $? -ne 0 ]; then
  echo "Linting failed. Please fix your code."
  exit 1
fi

Ensure the script is executable with chmod +x .git/hooks/pre-commit. This simple automation saves hours of CI/CD pipeline failures by catching errors locally.

Essential Git Best Practices

1. Commit Often, Push Regularly: Small, frequent commits are easier to revert and understand than massive, monolithic changes.
2. Write Descriptive Messages: Use the conventional commits standard (e.g., feat:, fix:, docs:) to provide context at a glance.
3. Pull Before You Push: Always sync your local branch with the remote repository to ensure you are building on the latest code.
4. Use .gitignore: Never commit sensitive credentials or build artifacts. Maintain a clean .gitignore file to keep the repository lightweight.

Conclusion

Git is a powerful tool that rewards those who invest time in learning its advanced features. By adopting structured branching, mastering conflict resolution, cleaning up your history, and utilizing hooks, you improve not only your productivity but also the reliability of your team's codebase. Start by implementing one of these techniques in your next sprint, and you will quickly see the benefits in your daily development workflow.

Frequently Asked Questions

How do I undo a commit I just made?

If you haven't pushed yet, use git reset --soft HEAD~1 to undo the commit while keeping your changes staged. If you need to discard changes entirely, use git reset --hard HEAD~1.

What is the difference between merge and rebase?

git merge creates a new commit that joins two histories, preserving the timeline. git rebase moves your changes onto the tip of another branch, resulting in a linear, cleaner history.

When should I use git stash?

Use git stash when you need to switch branches to address an urgent issue but your current work is not ready to be committed. It saves your changes in a temporary area so you can return to them later.