Question 1

Compare git rebase versus git merge and explain how git bisect finds regressions.

Accepted Answer

'git merge' creates a new merge commit combining two branch histories. It preserves full historical context but can clutter git graphs.

'git rebase' rewrites history by applying your branch commits sequentially on top of the target branch tip, creating a linear history.

'git bisect' uses a binary search algorithm to pinpoint the exact commit that introduced a bug between a known 'good' and 'bad' commit.

Key Takeaway: Never rebase public shared main/master branches. Use git bisect to locate bug regressions in seconds.

Question 2

What is the difference between git init and git clone?

Accepted Answer

Git repository setup starts with either initializing a new local project or cloning an existing remote repository:

### 1. 'git init':
- Initializes a brand new, empty Git repository in your current working directory.
- Creates a hidden '.git/' directory containing repository configuration, object database, and reference pointers.
- Used when starting a project from scratch on your local disk before linking to remote hosts.

### 2. 'git clone <url>':
- Downloads an existing remote repository (from GitHub, GitLab, or Bitbucket) onto your local machine.
- Automatically initializes a local '.git/' repository, sets up a remote reference named 'origin', and checks out the default branch ('main' or 'master').

Key Takeaway: Use git init to create a new empty repository locally; use git clone to download an existing remote repository.

Question 3

What are the Three Trees in Git (Working Directory, Staging Area / Index, Commit History)?

Accepted Answer

Git manages project files across three main architectural areas (often referred to as the 'Three Trees'):

### 1. Working Directory (Local Files on Disk):
The actual physical files you edit in your code editor. Changes here are untracked or unstaged until added.

### 2. Staging Area / Index (The Draft Snapshot):
An intermediate binary file ('.git/index') that stores changes staged for the next commit. Allows selecting specific modified files or line hunks to group into logical commits.

### 3. Repository / Commit History (The Permanently Recorded Graph):
The immutable Object Database ('.git/objects/') containing all committed snapshots. Once committed, changes are given a unique 40-character SHA-1/SHA-256 hash pointer.

Key Takeaway: Git workflow moves files from Working Directory to Staging Area (git add) to Commit History (git commit).

Question 4

How do git add, git commit, git status, and git diff manage everyday file tracking?

Accepted Answer

The everyday Git development workflow revolves around four essential commands:

### 1. 'git status':
Displays the current branch state, identifying untracked files, modified files, and staged changes ready for commit.

### 2. 'git diff':
Shows exact line-by-line code modifications between your Working Directory and Staging Area.

### 3. 'git add <files>':
Stages modified or untracked files into the Index ('git add .' stages all files in current directory).

### 4. 'git commit -m "message"':
Snapshots staged changes into repository history with a descriptive commit message.

Key Takeaway: Inspect state with status and diff, stage changes with git add, and record snapshots with git commit.

Question 5

How do git branch, git checkout, and git switch manage local branch navigation?

Accepted Answer

Branches represent isolated pointers to specific commits in the Git DAG history: ### 1. 'git branch': - 'git branch': Lists all local branches (* indicates active branch). - 'git branch feature-auth': Creates a new branch named 'feature-auth' without switching to it. ### 2. Legacy 'git checkout': - Historically handled both branch switching ('git checkout feature-auth') and file restoration ('git checkout -- file.js'). Overloaded responsibility caused user confusion! ### 3. Modern 'git switch' (Recommended): - Dedicated command introduced in Git 2.23 specifically for branch navigation: - 'git switch feature-auth': Switch to branch. - 'git switch -c feature-auth': Create and switch to new branch in a single command! Key Takeaway: Use modern git switch -c to create and switch branches cleanly instead of overloaded git checkout.

Question 6

What is the difference between git fetch and git pull?

Accepted Answer

Synchronizing local branches with remote repositories (like GitHub) involves two main strategies:

### 1. 'git fetch origin':
- Downloads remote commits, branches, and tags into your local '.git/' repository database without modifying your active working directory files.
- Safe inspection: Allows running 'git log origin/main' or 'git diff main origin/main' to review changes *before* integrating them.

### 2. 'git pull origin main':
- Performs 'git fetch' followed immediately by 'git merge origin/main' into your current branch.
- *Risk*: If remote changes conflict with your local edits, 'git pull' automatically triggers merge conflicts in your working tree immediately.

Key Takeaway: git fetch updates remote tracking pointers safely without altering local files; git pull fetches and merges immediately.

Question 7

How does .gitignore exclude untracked files and build artifacts from Git history?

Accepted Answer

The '.gitignore' file lists file patterns that Git should intentionally ignore and exclude from untracked file lists.

### Common Glob Patterns:
- 'node_modules/': Ignores entire directory and all subdirectories.
- '*.log': Ignores all files ending in '.log'.
- '.env*': Ignores '.env', '.env.local', etc., preventing sensitive API secrets from being accidentally committed!
- '!important.log': Negation rule (do NOT ignore 'important.log').

### Important Note:
If a file was already committed to Git history previously, adding it to '.gitignore' later will NOT stop Git from tracking it! You must untrack it first using 'git rm --cached <file>'.

Key Takeaway: Use .gitignore glob patterns to prevent committing build outputs and secrets. Untrack existing files with git rm --cached.

Question 8

How do git log and git show inspect commit history and file diffs?

Accepted Answer

Inspecting historical commits and line modifications relies on two primary commands: ### 1. 'git log': Displays historical commits in reverse chronological order: - 'git log --oneline': Compact single-line view showing short SHA hash and commit message. - 'git log --graph --oneline --all': Renders an ASCII visual tree graph of branch merges and splits. - 'git log -n 5': Limits output to the 5 most recent commits. ### 2. 'git show ': Displays full detailed metadata (author, date, commit message) and the complete unified code diff introduced by that specific commit. Key Takeaway: Use git log --oneline --graph to visualize branch DAG graphs, and git show to view individual commit code diffs.

Question 9

What is the difference between git reset --soft, --mixed, and --hard?

Accepted Answer

'git reset <commit>' moves the current branch HEAD pointer backwards to a specified target commit. The three reset flags control what happens to your staged and unstaged changes:

### 1. '--soft' (Preserves Staging Area & Working Directory):
- Moves HEAD to target commit.
- All changes from undone commits remain staged in the Index, ready to be recommitted immediately.

### 2. '--mixed' (Default — Preserves Working Directory Only):
- Moves HEAD and resets the Staging Area Index.
- Un-stages all changes, but leaves physical files in your Working Directory intact as unstaged modifications.

### 3. '--hard' (DANGEROUS — Discards Everything):
- Moves HEAD, resets the Staging Area Index, and permanently overwrites Working Directory files back to the target commit state! Uncommitted local changes are lost forever.

Key Takeaway: Use --soft to restage commits, --mixed to unstage files safely, and --hard ONLY when discarding all local changes intentionally.

Question 10

How does git stash temporarily store dirty working directory modifications?

Accepted Answer

'git stash' temporarily shelved uncommitted local modifications (both staged and unstaged files), returning your working directory to a clean HEAD state so you can switch branches cleanly.

### Stash Commands:
- 'git stash' or 'git stash push -m "work in progress"': Saves modified tracked files to a local stack.
- 'git stash -u': Includes untracked files in the stash.
- 'git stash list': Displays stored stash entries ('stash@{0}', 'stash@{1}').
- 'git stash pop': Re-applies the most recent stash entry ('stash@{0}') to your working directory and deletes it from the stack.
- 'git stash apply': Re-applies the stash entry while retaining it in the stack.

Key Takeaway: Use git stash push -u to temporarily save dirty working state, and git stash pop to restore changes after branch switching.

Question 11

How do you manage remote repository connections using git remote?

Accepted Answer

git remote -v lists configured remote shorthand aliases and fetch/push URLs. git remote add origin links your local repository to a remote server named origin. git remote set-url origin updates remote endpoints. Key Takeaway: Use git remote -v to inspect remote links and git remote add origin to connect local repositories.

Question 12

What is the difference between Annotated Tags and Lightweight Tags in Git?

Accepted Answer

Lightweight tags are simple pointers to specific commit hashes. Annotated tags (git tag -a v1.0.0 -m "message") are full checksummed Git objects storing tagger name, email, date, and message. Push tags explicitly via git push origin --tags.

Key Takeaway: Always use annotated tags (git tag -a) for software releases and push them explicitly using git push origin --tags.

Question 13

How does git restore discard uncommitted local changes?

Accepted Answer

git restore discards uncommitted changes in your working directory, reverting the file to its last committed state. git restore --staged removes the file from the Staging Area Index while preserving local edits. Key Takeaway: Use git restore to discard local uncommitted file modifications, and git restore --staged to unstage files.

Question 14

What causes Git Merge Conflicts and how do you manually resolve them?

Accepted Answer

Merge conflicts occur when Git attempts to merge two branches that modified the exact same line of a file differently. Resolving requires editing conflict markers (<<<<<<<, =======, >>>>>>>), staging files via git add , and running git commit. Key Takeaway: Resolve merge conflicts by editing conflict markers (<<<<<<<, =======, >>>>>>>), staging resolved files with git add, and running git commit.

Question 15

How does git cherry-pick apply specific commits from another branch?

Accepted Answer

git cherry-pick applies the exact changes introduced by a specific commit from another branch onto your active branch, generating a brand new commit with a new SHA hash. Key Takeaway: Use git cherry-pick to copy individual commits from another branch without merging the whole branch.

Question 16

How do git config settings configure user.name, user.email, and core.editor?

Accepted Answer

git config operates at three priority levels: --system (/etc/gitconfig), --global (~/.gitconfig), and --local (.git/config). Configuring user.name and user.email is mandatory so commits are attributed correctly on GitHub.

Key Takeaway: Set global author credentials via git config --global user.name and user.email to ensure correct commit attribution on GitHub.

Question 17

How does git blame identify who modified specific lines of code in a file?

Accepted Answer

git blame annotates every line of a specified file with the commit hash, author name, and timestamp of the last commit that modified that line. Use git blame -L 10,25 to inspect specific line ranges. Key Takeaway: Use git blame -L start,end file to identify author names and commit hashes for specific lines of code.

Question 18

What is the difference between git revert and git reset?

Accepted Answer

git reset moves the branch HEAD pointer backwards, erasing intermediate commits from current branch history (never use on shared public branches!). git revert creates a brand new commit that undoes changes safely on public branches. Key Takeaway: Use git revert for shared public branches to create inverse commits safely; use git reset for un-pushed local commits.

Question 19

What is a GitHub Pull Request (PR) and how does code review work?

Accepted Answer

A Pull Request (PR) is a GitHub feature proposing code changes from a feature branch into a target branch (main). Teammates review line-by-line diffs, automated CI status checks run, and once approved, maintainers merge the PR into main.

Key Takeaway: Pull Requests provide a collaborative web platform for code reviews, automated CI checks, and controlled branch merging.

Question 20

What is the difference between Forking a repository on GitHub and Cloning it?

Accepted Answer

Forking creates a personal copy of a repository on GitHub servers under your account, allowing pull requests to open-source projects without write access. Cloning downloads a repository from remote servers onto your local computer disk.

Key Takeaway: Forking creates a server-side copy under your GitHub account; cloning downloads files to your local machine.

Question 21

How do you stop tracking a file in Git without deleting it from local disk?

Accepted Answer

git rm --cached removes the file from Git's Staging Area Index (un-tracking it), but leaves the physical file on your disk untouched! Add the pattern to .gitignore immediately after to prevent re-staging. Key Takeaway: Use git rm --cached to remove files from Git tracking while preserving physical files on local disk.

Question 22

What is a Fast-Forward Merge in Git?

Accepted Answer

A Fast-Forward Merge occurs when merging a feature branch into a target branch where the target branch has received no intermediate commits. Git simply advances the target branch pointer forward. Running git merge --no-ff forces an explicit merge commit.

Key Takeaway: Fast-forward merges move branch pointers without merge commits. Use --no-ff to force explicit merge commit history.

Question 23

How do you configure custom Git Command Aliases?

Accepted Answer

Git aliases let you define custom shorthand shortcuts for long CLI commands inside ~/.gitconfig (e.g. git config --global alias.st status), accelerating daily terminal productivity. Key Takeaway: Define custom command shortcuts using git config --global alias. "" for terminal efficiency.

Question 24

How do you remove untracked files and directories using git clean?

Accepted Answer

git clean removes untracked files and directories from your working directory. git clean -n runs dry-run mode (always run -n first!). git clean -fd deletes untracked files and directories. git clean -fdx deletes ignored build artifacts too.

Key Takeaway: Always run git clean -n first to preview files before running git clean -fd to delete untracked files safely.

Question 25

How do GitHub Issues, Labels, and Milestones organize project tasks?

Accepted Answer

GitHub Issues track bugs and feature requests. Labels categorize issue types (bug, enhancement). Milestones group issues into target release deadlines and track percentage completion.

Key Takeaway: Use GitHub Issues for task tracking, Labels for categorization, and Milestones for sprint release management.

Question 26

What is git reflog and how does it recover "lost" commits or deleted branches?

Accepted Answer

git reflog (Reference Log) records every local pointer movement of HEAD (commits, checkouts, rebased commits, resets) in .git/logs/HEAD. Recover lost commits by running git reflog and git reset --hard <reflog-hash>.

Key Takeaway: Use git reflog to locate past HEAD pointer hashes and recover deleted branches or hard-reset commits.

Question 27

How do you modify the last commit message or add staged files using git commit --amend?

Accepted Answer

git commit --amend replaces the most recent commit on your active branch with a new commit containing newly staged files or an updated message. Never amend commits that have already been pushed to shared remote branches!

Key Takeaway: Use git commit --amend to fix typos or add forgotten files to the last local commit before pushing.

Question 28

How do you delete local branches and remote branches?

Accepted Answer

git branch -d deletes a merged local branch. git branch -D force-deletes an unmerged local branch. git push origin --delete removes the remote branch on GitHub. git remote prune origin cleans up stale tracking pointers. Key Takeaway: Delete local branches with git branch -d, delete remote branches with git push origin --delete, and prune stale references.

Question 29

How do README.md files document repositories using GitHub Flavored Markdown?

Accepted Answer

A README.md file located in the repository root directory renders as formatted HTML on the main GitHub repository homepage, providing installation steps, code snippets, status badges, and usage guides.

Key Takeaway: Write comprehensive README.md files using GitHub Flavored Markdown to provide installation and usage guides.

Question 30

What is a Detached HEAD state in Git and how do you fix it?

Accepted Answer

Detached HEAD occurs when HEAD points directly to a specific commit SHA hash rather than a named branch pointer (e.g. git checkout a1b2c3d). Preserve experimental commits by running git switch -c . Key Takeaway: Detached HEAD occurs when checking out commit hashes directly. Preserve commits by running git switch -c .

Question 31

How do you perform Interactive Rebasing to squash and reorder commits?

Accepted Answer

git rebase -i HEAD~N opens an interactive editor allowing you to clean up commit history. Use pick to keep, reword to edit message, squash to combine commits, fixup to combine and discard message, and drop to delete commits.

Key Takeaway: Use git rebase -i to squash WIP commits, fix typos with fixup, and reword commit messages before merging.

Question 32

What is the difference between Git Submodules and Git Subtrees?

Accepted Answer

Submodules link external repositories as lightweight 40-character commit pointers in .gitmodules (requires git submodule update --init). Subtrees merge external repository files directly into the parent commit tree.

Key Takeaway: Submodules store lightweight commit pointers requiring submodule init; Subtrees embed external file history directly into parent repos.

Question 33

How do Git Hooks and Husky automate code linting and formatting before commits?

Accepted Answer

Git Hooks are shell scripts in .git/hooks/ executed during Git events. Husky shares hooks across teams via package.json, and lint-staged runs linters (ESLint, Prettier) strictly on staged files before allowing commits.

Key Takeaway: Use Husky and lint-staged to run linters automatically on pre-commit hooks, enforcing code standards before commits enter history.

Question 34

How do GitHub Actions workflows automate CI/CD pipelines?

Accepted Answer

GitHub Actions executes automated workflows defined in YAML files inside .github/workflows/. Workflows define triggers (on: push, pull_request), jobs on cloud runners (ubuntu-latest), and sequential steps.

Key Takeaway: Define automated CI/CD workflows in .github/workflows/*.yml triggered by push and pull_request events.

Question 35

What is GitFlow branching strategy?

Accepted Answer

GitFlow is a structured branching model allocating distinct roles to main (production-ready releases), develop (integration), feature/* (new features), release/* (release polish), and hotfix/* (urgent production patches).

Key Takeaway: GitFlow assigns dedicated roles to main, develop, feature, release, and hotfix branches for scheduled release management.

Question 36

What is Trunk-Based Development and how does it compare to GitFlow?

Accepted Answer

Trunk-Based Development is a strategy where developers merge short-lived feature branches (1-2 days max) or commit directly to a single main branch daily, relying heavily on Feature Flags to decouple code deployment from release.

Key Takeaway: Trunk-Based Development enforces short-lived feature branches merged daily to main using Feature Flags.

Question 37

What is git worktree and how does it allow working on multiple branches simultaneously?

Accepted Answer

git worktree allows checking out multiple branches simultaneously into separate directories on your computer from a single local Git repository database, eliminating the need to stash changes when taking hotfix requests. Key Takeaway: Use git worktree add to edit multiple branches simultaneously in separate folders without stashing.

Question 38

What is Git LFS (Large File Storage) and how does it handle binary assets?

Accepted Answer

Git LFS replaces large binary files (videos, zip files, audio) in Git repositories with tiny text pointer files containing SHA-256 hashes, storing actual binary data on dedicated remote LFS servers.

Key Takeaway: Use Git LFS to replace large binary files with lightweight text pointers, keeping Git object stores fast.

Question 39

What are the 4 fundamental Git Object types (Blob, Tree, Commit, Tag)?

Accepted Answer

Git stores zlib-compressed data in .git/objects/ as 4 core object types: Blobs (raw file content), Trees (directory listings and file names), Commits (pointers to root Trees and parent commits), and Tags (annotated release pointers).

Key Takeaway: Git object database consists of Blobs (file content), Trees (directories), Commits (DAG snapshots), and Tags.

Question 40

How do SSH Keys and GPG Signature Signing work in Git and GitHub?

Accepted Answer

SSH keys authenticate Git CLI commands (fetch/push) over public-key cryptography without passwords. GPG/SSH commit signing cryptographically signs individual commits, displaying a green Verified badge on GitHub.

Key Takeaway: Use SSH keys for server CLI authentication, and configure GPG/SSH commit signing to display Verified badges on GitHub.

Question 41

What is git rerere (Reuse Recorded Resolution) and how does it automate conflict resolution?

Accepted Answer

git rerere (Reuse Recorded Resolution) remembers how you manually resolved a merge conflict hunk in .git/rr-cache/. If Git encounters the identical conflict again during rebases, it applies your previous resolution automatically.

Key Takeaway: Enable git rerere to let Git record and automatically re-apply identical merge conflict resolutions during rebases.

Question 42

How does the CODEOWNERS file automatically assign pull request reviewers?

Accepted Answer

A CODEOWNERS file located in .github/CODEOWNERS specifies individuals or teams responsible for specific code paths. When a PR modifies matching files, GitHub automatically assigns the designated owners as required reviewers.

Key Takeaway: Use .github/CODEOWNERS to automatically assign required PR reviewers based on modified file paths.

Question 43

What is git bundle and how do you transfer repositories offline without network access?

Accepted Answer

git bundle packages Git objects and references into a single binary file, allowing repository transfers via USB drive without network access. Clone or fetch directly from the bundle file as if it were a remote server.

Key Takeaway: Use git bundle create to package repository commits into a single binary file for air-gapped offline transfers.

Question 44

How do GitHub Branch Protection Rules enforce required status checks and reviews?

Accepted Answer

Branch protection rules block direct pushes to main branches, requiring signed commits, passing CI status checks, mandatory approved PR reviews, and blocking force pushes or branch deletions.

Key Takeaway: Enforce GitHub Branch Protection Rules on main to require PR approvals, passing CI checks, and block force pushes.

Question 45

How does git sparse-checkout allow cloning partial directories of giant monorepos?

Accepted Answer

git sparse-checkout configures Git to populate your local working directory with only specific sub-folders of a giant monorepo, skipping unwanted files while preserving the full repository structure.

Key Takeaway: Use git sparse-checkout set <paths> in monorepos to populate only the specific subfolders required for your work.

Question 46

What is a Shallow Clone (git clone --depth 1) and why is it used in CI/CD?

Accepted Answer

Shallow cloning (git clone --depth 1) downloads only the most recent single commit snapshot rather than full multi-year history, cutting clone time and bandwidth by 90% in automated CI pipelines.

Key Takeaway: Use git clone --depth 1 in CI pipelines to download only the latest commit, drastically speeding up build execution.

Question 47

How does GitHub Dependabot automatically detect and patch vulnerable npm dependencies?

Accepted Answer

Dependabot monitors repository dependency manifests against the GitHub Advisory Database, creating automated pull requests to update packages with known CVE security vulnerabilities.

Key Takeaway: Enable GitHub Dependabot security alerts and configure dependabot.yml to automate security patch PRs.

Question 48

How does git range-diff compare two iterations of a rebased branch?

Accepted Answer

git range-diff compares the commit changes between two versions of a rebased branch (e.g. feature-v1...feature-v2), helping reviewers inspect changes made during interactive rebase force-pushes.

Key Takeaway: Use git range-diff to inspect exact patch changes between two iterations of a rebased branch during code review.

Question 49

How do GitHub Releases link tag commits to compiled release assets?

Accepted Answer

GitHub Releases publish tagged release notes alongside attached compiled binary artifacts (.tar.gz, .exe) generated by automated GitHub Actions build pipelines.

Key Takeaway: GitHub Releases link Git tags with formatted changelogs and attached compiled binary build artifacts.

Question 50

How does git gc (Garbage Collection) pack loose objects into Packfiles?

Accepted Answer

git gc optimizes repository storage by compressing individual loose blob objects into delta-compressed Packfiles (.pack) indexed by .idx files and removing unreachable dangling objects.

Key Takeaway: git gc compresses loose object files into delta-compressed Packfiles and prunes dangling unreferenced objects.

Question 51

What is git notes and how do you attach metadata to commits without altering commit hashes?

Accepted Answer

git notes allows adding extra text metadata (such as CI build status or code audit notes) to existing commits without changing the commit's SHA-1 hash or history graph.

Key Takeaway: Use git notes to attach build status or audit metadata to existing commits without changing commit SHA hashes.

Question 52

How do GitHub Discussions provide community forums distinct from GitHub Issues?

Accepted Answer

GitHub Discussions provide a Q&A community forum for open-ended conversations, ideas, and announcements, reserving GitHub Issues for actionable code bugs and tasks.

Key Takeaway: Use GitHub Discussions for community support and open Q&A, reserving GitHub Issues for actionable code tasks.

Question 53

How do you purge accidentally committed passwords using git filter-repo?

Accepted Answer

git filter-repo rewrites complete repository history to remove sensitive credentials or giant files from all historical commits. Always force-push and rotate exposed credentials immediately.

Key Takeaway: Use git filter-repo to purge secrets from full historical commits, and rotate exposed credentials immediately.

Question 54

How does git archive create a zip or tarball of a specific commit without .git folders?

Accepted Answer

git archive exports files from a target commit or tag into a compressed .zip or .tar.gz archive, stripping internal .git metadata folders for clean deployment bundles.

Key Takeaway: Use git archive to export clean production zip or tarball release bundles stripped of .git metadata.

Question 55

How do GitHub Actions Secrets manage API keys and deployment credentials securely?

Accepted Answer

GitHub Secrets encrypt sensitive credentials stored at repository or environment levels using Sodium public-key cryptography, masking secret values with asterisks in Actions logs.

Key Takeaway: Store sensitive deployment keys in encrypted GitHub Secrets and reference them in YAML via ${{ secrets.KEY }}.

Question 56

What are Git Merge Strategies (ort, recursive, octopus, ours, theirs)?

Accepted Answer

ort (Ostensibly Recursive's Twin) is the high-performance default strategy in modern Git 2.33+. octopus handles multi-branch merges, while ours/theirs favor specific branch changes during conflict resolution.

Key Takeaway: ort is the high-performance modern default merge strategy in Git; octopus handles multi-branch merges.

Question 57

How do Issue and Pull Request Templates standardize submissions?

Accepted Answer

PR and Issue templates (.github/PULL_REQUEST_TEMPLATE.md) pre-populate markdown guidelines when users open new issues or PRs, ensuring testing steps and checklists are provided.

Key Takeaway: Use PR and Issue templates in .github/ to enforce code review standards and structured bug reporting.

Question 58

How do git format-patch and git am share commits via email patch files?

Accepted Answer

git format-patch exports commits as RFC-822 formatted email patch files (.patch), and git am applies patch files sequentially into repository history, preserving original authorship.

Key Takeaway: Use git format-patch to export commits as email patch files, and git am to apply them into commit history.

Question 59

What is the difference between GitHub Apps and legacy GitHub OAuth Apps?

Accepted Answer

GitHub Apps act as independent bot actors installed on specific repositories with fine-grained permissions. OAuth Apps act on behalf of individual user accounts with broad permissions.

Key Takeaway: Build GitHub Apps for repository integrations to enforce fine-grained permissions and independent bot identities.

Question 60

What is the Conventional Commits specification?

Accepted Answer

Conventional Commits standardizes commit message syntax (e.g. feat(auth): add JWT login), enabling automated tools (semantic-release) to bump Semantic Versions and generate CHANGELOG.md files.

Key Takeaway: Follow Conventional Commits (feat, fix, BREAKING CHANGE) to automate semantic versioning and changelog generation.

Question 61

How does git check-ignore troubleshoot why a file is ignored by Git?

Accepted Answer

git check-ignore -v inspects active .gitignore rules, returning the exact file path and line number causing a file to be ignored. Key Takeaway: Use git check-ignore -v to locate the exact .gitignore line causing a file to be ignored.

Question 62

How do GitHub Deployment Environments manage approval gates for staging vs production?

Accepted Answer

GitHub Environments configure deployment protection rules (required reviewers, wait timers) and environment-specific secrets for staging and production targets.

Key Takeaway: Use GitHub Deployment Environments to enforce manual reviewer approvals and isolate production secrets.

Question 63

What is the difference between git diff and git diff --staged?

Accepted Answer

git diff compares Working Directory edits against the Staging Area Index. git diff --staged compares staged changes in the Index against the last HEAD commit.

Key Takeaway: Use git diff to inspect unstaged working edits, and git diff --staged to inspect staged changes ready for commit.

Question 64

How do GitHub Security Advisories publish vulnerabilities and request CVE IDs?

Accepted Answer

GitHub Security Advisories allow maintainers to privately discuss, fix, and test security vulnerabilities in temporary private forks before requesting CVE IDs and broadcasting public patches.

Key Takeaway: Use GitHub Security Advisories to fix security vulnerabilities privately before public CVE disclosure.

Take Git & GitHub Skill Assessment Quiz

Showing 100 Questions

1. Compare git rebase versus git merge and explain how git bisect finds regressions.

2. What is the difference between git init and git clone?

3. What are the Three Trees in Git (Working Directory, Staging Area / Index, Commit History)?

4. How do git add, git commit, git status, and git diff manage everyday file tracking?

5. How do git branch, git checkout, and git switch manage local branch navigation?

6. What is the difference between git fetch and git pull?

7. How does .gitignore exclude untracked files and build artifacts from Git history?

8. How do git log and git show inspect commit history and file diffs?

9. What is the difference between git reset --soft, --mixed, and --hard?

10. How does git stash temporarily store dirty working directory modifications?

11. How do you manage remote repository connections using git remote?

12. What is the difference between Annotated Tags and Lightweight Tags in Git?

13. How does git restore discard uncommitted local changes?

14. What causes Git Merge Conflicts and how do you manually resolve them?

15. How does git cherry-pick apply specific commits from another branch?

16. How do git config settings configure user.name, user.email, and core.editor?

17. How does git blame identify who modified specific lines of code in a file?

18. What is the difference between git revert and git reset?

19. What is a GitHub Pull Request (PR) and how does code review work?

20. What is the difference between Forking a repository on GitHub and Cloning it?

21. How do you stop tracking a file in Git without deleting it from local disk?

22. What is a Fast-Forward Merge in Git?

23. How do you configure custom Git Command Aliases?

24. How do you remove untracked files and directories using git clean?

25. How do GitHub Issues, Labels, and Milestones organize project tasks?

26. What is git reflog and how does it recover "lost" commits or deleted branches?

27. How do you modify the last commit message or add staged files using git commit --amend?

28. How do you delete local branches and remote branches?

29. How do README.md files document repositories using GitHub Flavored Markdown?

30. What is a Detached HEAD state in Git and how do you fix it?

31. How do you perform Interactive Rebasing to squash and reorder commits?

32. What is the difference between Git Submodules and Git Subtrees?

33. How do Git Hooks and Husky automate code linting and formatting before commits?

34. How do GitHub Actions workflows automate CI/CD pipelines?

35. What is GitFlow branching strategy?

36. What is Trunk-Based Development and how does it compare to GitFlow?

37. What is git worktree and how does it allow working on multiple branches simultaneously?

38. What is Git LFS (Large File Storage) and how does it handle binary assets?

39. What are the 4 fundamental Git Object types (Blob, Tree, Commit, Tag)?

40. How do SSH Keys and GPG Signature Signing work in Git and GitHub?

41. What is git rerere (Reuse Recorded Resolution) and how does it automate conflict resolution?

42. How does the CODEOWNERS file automatically assign pull request reviewers?

43. What is git bundle and how do you transfer repositories offline without network access?

44. How do GitHub Branch Protection Rules enforce required status checks and reviews?

45. How does git sparse-checkout allow cloning partial directories of giant monorepos?

46. What is a Shallow Clone (git clone --depth 1) and why is it used in CI/CD?

47. How does GitHub Dependabot automatically detect and patch vulnerable npm dependencies?

48. How does git range-diff compare two iterations of a rebased branch?

49. How do GitHub Releases link tag commits to compiled release assets?

50. How does git gc (Garbage Collection) pack loose objects into Packfiles?

51. What is git notes and how do you attach metadata to commits without altering commit hashes?

52. How do GitHub Discussions provide community forums distinct from GitHub Issues?

53. How do you purge accidentally committed passwords using git filter-repo?

54. How does git archive create a zip or tarball of a specific commit without .git folders?

55. How do GitHub Actions Secrets manage API keys and deployment credentials securely?

56. What are Git Merge Strategies (ort, recursive, octopus, ours, theirs)?

57. How do Issue and Pull Request Templates standardize submissions?

58. How do git format-patch and git am share commits via email patch files?

59. What is the difference between GitHub Apps and legacy GitHub OAuth Apps?

60. What is the Conventional Commits specification?

61. How does git check-ignore troubleshoot why a file is ignored by Git?

62. How do GitHub Deployment Environments manage approval gates for staging vs production?

63. What is the difference between git diff and git diff --staged?

64. How do GitHub Security Advisories publish vulnerabilities and request CVE IDs?

65. What is git symbolic-ref and how does it manage the HEAD reference file?

66. How does GitHub Pages host static websites directly from GitHub repositories?

67. How do you automate bug isolation using git bisect run?

68. How does the GitHub CLI (gh) bring GitHub features to the terminal prompt?

69. How does git rebase --onto transplant a branch segment to a different base commit?

70. How does GitHub Packages host container images and npm packages?

71. How does Git handle Object Format migration from SHA-1 to SHA-256 cryptographic hashes?

72. How does Microsoft Scalar optimize Git performance for multi-gigabyte monorepos?

73. What is the Commit-Graph file (.git/objects/info/commit-graph) and how does it accelerate DAG traversal?

74. How does the FSMonitor hook eliminate working directory scan delays on macOS and Windows?

75. How does Git Delta Compression compress object data inside Packfiles?

76. How do you write custom Git Merge Drivers in .gitattributes for specialized file formats?

77. How does Git Wire Protocol v2 optimize fetch negotiation and reference advertisement?

78. How do you architect High Availability (HA) for GitHub Enterprise Server (GHES)?