Git

Git is a distributed version control system for tracking source code changes.

It enables collaboration, history tracking, branching, and safe change integration.

A project directory containing files and Git metadata/history.

Creates a new local Git repository.

Copies an existing repository (including history) to local machine.

Snapshot of staged changes with metadata (author, message, timestamp).

Movable pointer to a sequence of commits.

Isolate work streams (features, fixes, experiments) safely.

Reference to current checked-out commit/branch pointer.

Intermediate area where changes are prepared before commit.

Working tree has current file edits; staging contains selected changes for next commit.

State of working tree, staged files, and branch info.

Stages file changes for commit.

Creates commit from staged changes.

Shows commit history.

Line-by-line differences between states (working, staged, commits).

Restores file content from index/commit (modern command family).

Removes file from working tree and stages deletion.

Moves/renames file and stages change.

File specifying untracked patterns Git should ignore.

Avoid committing build artifacts, secrets, temp files.

Named reference to another repository URL (e.g., origin).

Configured remotes and fetch/push URLs.

Downloads remote updates without merging into current branch.

Fetches and integrates remote changes (merge/rebase depending config).

Uploads local commits to remote branch.

Combining histories from different branches into one.

Competing changes Git cannot automatically reconcile.

Edit conflicted files, mark resolved (git add), complete merge commit.

Branch pointer moves forward without creating merge commit.

Creates explicit merge commit preserving branch topology.

Reapplies commits on top of another base commit.

Rebase rewrites commit lineage; merge preserves branch history with merge commit.

Cleaner linear history for local feature branches.

Apply specific commit(s) onto current branch.

Named pointer to specific commit, often for releases.

Annotated stores metadata/message/signature; lightweight is simple pointer.

Displays object details (commit, tag, etc.).

Lists/manages branches.

Modern command to change/create branches.

HEAD points directly to commit, not branch name.

No, useful for inspection/testing; commits may be hard to find later unless referenced.

Temporarily shelves uncommitted changes.

Quick context switching without committing partial work.

Applies latest stash and removes it from stash list.

Applies stash without removing it.

Local log of where HEAD/refs pointed over time.

Recover “lost” commits after resets/rebases/deletions.

Moves branch pointer and optionally index/working tree.

Soft keeps index/worktree, mixed resets index only, hard resets both index/worktree.

Creates new commit undoing effects of an earlier commit.

Revert preserves public history; reset rewrites local history pointers.

Default remote name created by clone.

Default remote branch relationship for pull/push.

Shows last modifying commit/author per line.

Search text patterns in tracked files quickly.

Committing generated files and secrets accidentally.

Force-pushing shared branches without coordination.

Short imperative summary + optional body explaining why.

One feature/fix per branch, small focused PRs.

Fetch often, pull before push, resolve conflicts carefully.

Use pull requests and code review before merging.

Use reflog and revert instead of panic.

Commit early, commit logically, keep changes reviewable.

Treat Git history as communication, not just backup.

Merge using common ancestor + two branch tips.

Merge of multiple branches at once (limited conflict handling use cases).

Combines branch commits into one commit at merge time.

Cleaner main history but loses individual commit granularity on target branch.

Interactive history rewrite (reorder, squash, reword, drop, edit).

Clean up local commits before opening/updating PR.

Commit marked to auto-squash into target commit later.

Automatically reorder/squash fixup!/squash! commits during rebase.

Compares two commit series (helpful after rebase).

Best common ancestor between branches.

Determines diff/merge context and conflict scope.

Binary search through history to find commit introducing bug.

Fast root-cause isolation in large histories.

Automates bisect steps with script/test command.

Removes untracked files (optionally directories/ignored files).

Can permanently delete local untracked work.

Unstages changes from index without discarding file edits.

Older way to unstage file.

Pattern syntax selecting specific paths for commands.

Stage selected hunks/lines rather than whole file.

Create small logical commits from mixed edits.

Interactive patch staging mode.

Commit cryptographically signed (GPG/SSH/S/MIME).

Authenticity and provenance verification.

Remote branch with policy rules (reviews, checks, no force push).

Prevents accidental or policy-violating direct changes.

CI/test checks that must pass before merge.

Policy requiring no merge commits on protected branch.

Serializes validated PR merges to reduce main-branch breakage/races.

File defining required reviewers for specific paths.

Ensures domain experts review sensitive components.

Contributors work on personal fork and submit PR to upstream repo.

Fork isolates permissions; branch workflow uses shared repo branches.

Reference to original repository for syncing changes.

Removes stale remote-tracking references deleted on remote.

Garbage collects and optimizes repository storage.

Compressed storage format aggregating Git objects efficiently.

Clone with truncated history depth.

Faster clone but limited history operations.

Checkout only subset of repository paths.

Improve performance in large monorepos when working on subset.

Repository embedded at specific commit inside another repository.

Operational complexity and sync pitfalls.

Vendor external repo content into subdirectory with merge support.

Subtree simpler consumption; submodule keeps strict repo separation.

Extension storing large binaries outside normal Git object store.

Prevent repository bloat and improve clone/fetch performance for binaries.

Rewriting shared history after others based work on it.

Only rewrite local/unshared branches unless team explicitly coordinates.

Safer force push that checks remote wasn’t unexpectedly updated.

Prevents overwriting others’ new remote commits accidentally.

Create annotated version tags tied to release commits.

Patch critical issue from release/main branch and merge back appropriately.

Applying fix from newer branch to older maintained release branch.

status -> log/graph -> reflog -> diff/merge-base -> targeted recovery.

Structured commit messages (feat/fix/chore…) aiding automation.

Changelog generation and release automation.

Signed commits/tags, protected branches, secret scanning hooks.

Small PRs, required checks, branch protection, rollback-ready tags.

Use shallow/sparse clones and LFS where appropriate.

Team resolves conflicts/rebases confidently without losing history integrity.

Optimize history for both humans (review) and machines (automation).

Enforce workflow via branch rules and CI, not tribal memory.

Immutable signed tags as deployment source of truth.

Prefer transparent, recoverable workflows over clever but fragile Git tricks.

Data stored as blobs, trees, commits, and tags addressed by hash IDs.

Object identity derived from content hash for integrity/deduplication.

Enables advanced recovery, performance tuning, and tooling design.

Auxiliary structure speeding history walks and queries.

Indexes accelerating clone/fetch object negotiation.

Clone that defers some object downloads until needed.

Reduced network/storage for huge repos.

Remote promising missing objects can be fetched on demand.

Huge history/tree size impacts clone/status/diff performance.

Sparse checkout, partial clone, repo maintenance, CI optimization.

Automated gc/repack/commit-graph maintenance tasks.

Server-side hooks enforcing policy on pushes.

Block secrets, enforce commit format, deny unsafe refs.

Pass custom options to server-side hooks during push.

Cryptographically signed push certificates (workflow-dependent adoption).

Initial remote authenticity assumptions can be exploited.

Verified URLs, SSH host key validation, signed tags/releases.

Build pipelines trusting unverified refs/submodules can import malicious code.

Admin overrides or misconfigured rules can weaken guarantees.

Audit logs, limited admin rights, approval workflows.

Review-centric model where changes are reviewed before landing, often rebase/cherry-pick based.

Short-lived branches, frequent integration to main.

Structured long-lived branches (develop/release/hotfix) with heavier process.

Speed/simplicity vs explicit release branching control.

Coordinate freeze, identify divergence, recover via reflog/cherry-pick/revert plan.

Use fsck, backups, alternate clones, object recovery methods.

Verifies connectivity and validity of Git object database.

Credential committed and propagated through clones/forks.

Rotate secret immediately, purge history where required, notify stakeholders, add prevention controls.

Assume secret already compromised once exposed.

Use specialized filtering tools (e.g., git-filter-repo) with coordination.

Breaks clones/branches/PR refs and downstream automation assumptions.

Signed commits/tags + attestations linking source to built artifacts.

Deterministic archive from exact commit/tag for audits.

Using blame/log/range-diff/bisect to understand why changes happened.

Faster onboarding, debugging, and safer long-term maintenance.

recursive/ort behavior tuning, ours/theirs preferences for conflict cases.

Reuse Recorded Resolution; remembers conflict resolutions for reuse.

Speeds repeated conflict resolution in long-running branches/backports.

Treating Git as file sync tool while ignoring review/governance semantics.

Define standards, templates, hooks, protections, and training.

Automated enforcement of branch, commit, and review rules.

Traceable authorship, approvals, and release tag integrity.

Balancing history permanence with legal/privacy deletion requirements.

Repo backups, geo-replication, tested restore procedures.

Make integration frequent, reversible, and policy-protected.

Verify identity/integrity of commits, tags, remotes, and CI paths.

Use advanced clone/index strategies for large repos.

Optimize for small reviews and clear historical intent.

Automate guardrails; avoid manual enforcement dependency.

Prefer revertable workflows and rehearsed recovery playbooks.

Deploy from signed immutable tags, not moving branch heads.

Standardize workflows across repos while allowing bounded team autonomy.

Align branching/release model with product delivery cadence.

Git excellence is trustworthy history, fast collaboration, and resilient recovery.