Some Handy Git Use Cases

Let’s dive deeper into Git commands, especially those that are more advanced and relate to your workflow.

Understanding Your Workflow

Your provided commands outline a common workflow:

1. Feature Branch Development: You’re working on a feature branch (STGF2201-7370).
2. Staying Updated: You’re fetching and integrating changes from the team’s development branch (develop_backtest_integ_v3).
3. Reviewing Changes: You’re using git log -p, gitk, and git show to examine differences and commit details.
4. Tagging: You’re using git tag to mark specific commits.

Advanced Git Commands and Concepts

Here’s a breakdown of related and advanced commands, organized for clarity:

1. Branching and Merging (Beyond Basic Pulls)

• git rebase:
• Purpose: Integrates changes from one branch into another by reapplying commits on top of the target branch. This creates a cleaner, linear history.
• Usage:
• Bash
• git checkout GTNF2201-7370 git rebase origin/develop_backtest_integ_v3
• Explanation: This rewrites your feature branch’s history as if you had branched off the latest develop_backtest_integ_v3.
• Caution: Rebase rewrites history, so avoid rebasing branches that have already been pushed and shared with others.
• git merge --squash:
• Purpose: Combines all changes from a feature branch into a single commit on the target branch.
• Usage:
• Bash
• git checkout develop_backtest_integ_v3 git merge --squash GTNF2201-7370 git commit -m "Merged feature branch GTNF2201-7370"
• Explanation: This is useful for creating a clean history when merging feature branches, especially when those branches contain many small commits.
• git cherry-pick:
• Purpose: Applies specific commits from one branch to another.
• Usage:
• Bash
• git checkout target_branch git cherry-pick <commit_hash>
• Explanation: This is useful for selectively incorporating changes from other branches.
• git branch -D <branch_name>:
• Purpose: Force deletes a branch.
• Explanation: Use this when a normal git branch -d fails because the branch hasn't been fully merged.

2. Inspecting Changes (Advanced)

• git diff:
• Purpose: Shows differences between commits, branches, or files.
• Usage:
• git diff: Shows changes since the last commit.
• git diff <commit1> <commit2>: Shows changes between two commits.
• git diff <branch1> <branch2>: Shows changes between two branches.
• git diff --staged: Shows changes that are staged for commit.
• git diff --name-status <commit1> <commit2>: shows only the file names that changed, and the type of change (A=added, M=modified, D=deleted).
• git bisect:
• Purpose: Helps find the commit that introduced a bug by performing a binary search through the commit history.
• Usage:
• Bash
• git bisect start git bisect bad <bad_commit> git bisect good <good_commit>
• Explanation: Git will automatically check out commits, and you’ll mark them as “good” or “bad” until the problematic commit is identified.
• git blame:
• Purpose: Shows who last modified each line of a file and when.
• Usage:
• Bash
• git blame <file_name>
• Explanation: This is useful for understanding the history of specific lines of code.

3. Rewriting History (Use with Caution)

• git commit --amend:
• Purpose: Modifies the last commit.
• Usage:
• Bash
• git commit --amend
• Explanation: This allows you to change the commit message or add/remove files from the last commit.
• git rebase -i (Interactive Rebase):
• Purpose: Allows you to edit, reorder, squash, or drop commits during a rebase.
• Usage:
• Bash
• git rebase -i <commit_hash>
• Explanation: This is a powerful tool for cleaning up your commit history.
• git reset:
• Purpose: Resets the current branch to a specific commit.
• Usage:
• git reset --soft <commit_hash>: Keeps changes staged.
• git reset --mixed <commit_hash>: Keeps changes unstaged.
• git reset --hard <commit_hash>: Discards all changes.
• Caution: git reset --hard can result in data loss, so use it carefully.
• git reflog:
• Purpose: Shows a log of all changes to the HEAD pointer, including branch switches, resets, and commits.
• Explanation: This is a safety net that allows you to recover from mistakes.

4. Stashing

• git stash:
• Purpose: Temporarily saves changes that are not ready to be committed.
• Usage:
• git stash: Saves changes.
• git stash list: Lists stashed changes.
• git stash apply: Applies the last stashed changes.
• git stash pop: Applies and removes the last stashed changes.
• git stash drop <stash_id>: Removes a specific stash entry.

Example scenarios:

• You need to work on a hotfix while in the middle of your feature branch:

1. git stash
2. git checkout main
3. Create hotfix branch, make changes, commit, and merge.
4. git checkout STNF2201-7370
5. git stash pop

Important Considerations

• Collaboration: When working in a team, communicate before rewriting shared history.
• Understanding History: Learn how to interpret Git logs and visualize commit graphs.
• Practice: The best way to learn Git is to use it regularly.

Let’s integrate your specific commands into the explanations and expand on them:

Your Commands Revisited with Advanced Context

1. git switch STNF2201-7370

• Explanation: You’re switching to your feature branch.
• Advanced:
• git switch -c new_branch: Creates and switches to a new branch in one command.
• git switch -: switch back to the last branch.

1. git fetch origin develop_backtest_integ_v3

• Explanation: You’re fetching the latest changes from the remote develop_backtest_integ_v3 branch.
• Advanced:
• git fetch origin: Fetches all branches from the remote.
• git fetch --prune origin: removes remote-tracking references to remote branches that no longer exist on the remote. This is very useful for cleaning up local clutter.

1. git log -p HEAD..FETCH_HEAD or gitk HEAD..FETCH_HEAD

• Explanation: You’re inspecting the changes between your local HEAD and the fetched FETCH_HEAD.
• Advanced:
• git log --graph --oneline --decorate: Provides a concise graphical representation of the commit history.
• git log --author="Your Name": Filters logs by author.
• git log --since="YYYY-MM-DD" --until="YYYY-MM-DD": Filters logs by date range.
• git log --grep="search term": filters commits by commit message content.
• git log -S"string": Find commits that change addition or removal of particular strings.

1. git pull origin develop_backtest_integ_v3

• Explanation: You’re pulling (fetching and merging) the remote changes into your feature branch.
• Advanced:
• git pull --rebase origin develop_backtest_integ_v3: Pulls and rebases instead of merging, creating a cleaner history.
• If merge conflicts arise, use git status to locate the files, manually resolve the conflicts, git add the resolved files, and then git commit.

1. gitk HEAD...FETCH_HEAD

• Explanation: You’re viewing the symmetric difference between your HEAD and FETCH_HEAD.
• Advanced: This is very good for seeing what changes are unique to each branch.

1. git show c82a22c39cbc32576f64f5c6b3f24b99ea8149c7, git show HEAD^, git show HEAD^^, git show HEAD~4

• Explanation: You’re viewing the details of specific commits.
• Advanced:
• git show --stat: Shows the statistics of the changes in a commit.
• git show --name-only: Shows only the names of the files changed in a commit.

1. git tag v3 1b2e1d63ff

• Explanation: You’re creating a tag named v3 for the commit 1b2e1d63ff.
• Advanced:
• git tag -a v3 -m "Release v3": Creates an annotated tag with a message. Annotated tags are recommended.
• git tag -d v3: Deletes the tag v3.
• git push origin v3: Pushes the tag to the remote repository.
• git tag -l "v*": Lists all tags matching the pattern "v*".

1. git log v3..v2, git log v2.., git log --since="2 weeks ago", git log v2.. Makefile

• Explanation: You’re filtering the commit log based on tags, dates, and file paths.
• Advanced: Combine these filters for complex queries. For example, git log --author="Your Name" --since="1 week ago" Makefile.

Workflow Enhancements

• Pre-commit Hooks:
• Create scripts that run automatically before each commit to enforce code style, run tests, or prevent committing certain files.
• This can be done by placing executable scripts inside the .git/hooks/ directory.
• Git Aliases:
• Create shortcuts for frequently used Git commands.
• Example: git config --global alias.co checkout allows you to use git co instead of git checkout.
• Using a GUI Client:
• Tools like GitKraken, SourceTree, or GitHub Desktop can provide a visual interface for Git, making complex operations easier.
• Commit Message Conventions:
• Establish clear and consistent commit message conventions within your team.
• This makes it easier to understand the history and track changes.
• Code Reviews:
• Use pull requests or merge requests to facilitate code reviews before merging changes into the main branch.
• This helps to catch bugs and improve code quality.

By mastering these commands, you’ll be able to manage your Git repositories more effectively and collaborate more efficiently.