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 (SMGF2201-7370).
  2. Staying Updated: You're fetching and integrating changes from the team's development branch (develop_mlops_deployment).
  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 SMGF2201-7370
git rebase origin/develop_mlops_deployment
    • Explanation: This rewrites your feature branch's history as if you had branched off the latest develop_mlops_deployment.
    • 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_mlops_deployment
git merge --squash SMGF2201-7370
git commit -m "Merged feature branch SMGF2201-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 SMGF2201-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.

Some More Commands Revisited with Advanced Context

  1. git switch SMGF2201-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.
  2. git fetch origin develop_mlops_deployment
    • Explanation: You're fetching the latest changes from the remote develop_mlops_deployment 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.
  3. 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.
  4. git pull origin develop_mlops_deployment
    • Explanation: You're pulling (fetching and merging) the remote changes into your feature branch.
    • Advanced:
      • git pull --rebase origin develop_mlops_deployment: 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.
  5. 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.
  6. 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.
  7. 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*".
  8. 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.

Comments

Post a Comment

Popular posts from this blog

Self-contained Raspberry Pi surveillance System Without Continue Internet

Image
                                                                gemini generated A  self-contained Raspberry Pi surveillance system that: Runs autonomously (like EyeOS) — camera always active and streaming. Keeps searching for a known Wi-Fi hotspot (your phone) . Starts streaming automatically when the phone hotspot is available. Lets you view the camera feed on your phone (via browser or app). Here’s a detailed, production-ready setup: ⚙️ Step 1: Setup Raspberry Pi Camera & Software 1. Enable the camera sudo raspi-config Go to Interface Options → Camera → Enable Reboot: sudo reboot 2. Install dependencies sudo apt update sudo apt install python3-picamera2 python3-flask git -y 📸 Step 2: Create a Local Flask Streaming App Create file /home/pi/camera_stream.py : from flask import Flas...
Read more

COBOT with GenAI and Federated Learning

Image
                                                                                 generated by meta ai The integration of Generative AI (GenAI) and Large Language Models (LLMs) is poised to significantly enhance the intelligence and capabilities of cobots, taking them beyond basic automation. Here's how: 1. Enhanced Natural Language Interaction: Intuitive Communication: LLMs enable cobots to understand and respond to natural language commands, making human-robot interaction far more intuitive. Instead of complex programming, workers can simply use voice commands or text instructions. This simplifies task assignment and allows for real-time adjustments. Contextual Understanding: LLMs provide cobots with a deeper understanding of context, allowi...
Read more

AI in Education: Embracing Change for Future-Ready Learning

Image
  Executive Summary An adjunct professor advocates embracing AI in classrooms over prohibition, using historical examples of replaced skills (cursive, memorization) to argue for focusing on adaptability, creativity, and critical thinking. AI enables personalized tutoring, equity, and efficiency but demands literacy and ethics. Recommendations include shifting to debates over essays and principles over rote tasks to equip students for AI workplaces. Historical Context: Skills Evolved by Technology Education prioritizes future utility amid time constraints. Past emphases have faded: Cursive/penmanship : Graded courses in prior generations; now obsolete with keyboards—digital fluency matters more. Memorization (e.g., full periodic table) : Drills wasted time; databases provide facts—focus on conceptual understanding (e.g., element groups' properties). Manual arithmetic : Long division drills unnecessary post-fundamentals; calculators standard in higher education. Map reading : Seconda...
Read more