Git
Git for Developers: Commands, Workflows and Recovery
A practical Git guide for beginners who want a clear mental model and professionals who need safer daily workflows, cleaner commits, better collaboration, recovery steps, and interview-ready explanations.
Beginner Friendly
Version Control
Commands
Collaboration
Practice Questions
Quick Summary
- Git is: a distributed version control system.
- Main use: track code changes, collaborate, branch, review, merge, and recover history.
- Beginner goal: understand working tree, staging area, commits, branches, and remotes.
- Experienced goal: use clean history, safe recovery, conflict handling, and team workflows.
- Best habit: run
git statusoften and review diffs before committing.
Who This Guide Is For
If you are new to Git, start by understanding the journey of a change: you edit a file, stage the change, commit it, and push it to a remote repository. Do not try to memorize every command on day one. Learn the small daily loop first.
If you already use Git at work, focus on the professional habits: keep commits focused, read diffs before committing, avoid rewriting shared history, write useful messages, and use recovery commands carefully. These habits matter more than knowing obscure commands.
Real project example: when a login bug is fixed, the commit should contain only the login fix and its related test. Mixing the login fix with CSS cleanup, dependency updates, and unrelated formatting makes review, rollback, and debugging harder.
Git Mental Model
| Part | Meaning | Command to inspect |
|---|---|---|
| Working tree | Files you are editing now. | git status |
| Staging area / index | Changes selected for the next commit. | git diff --staged |
| Commit | A snapshot with message, author, date, and parent links. | git show |
| Branch | A movable pointer to a commit. | git branch |
| HEAD | Your current branch or checked-out commit. | git status |
| Remote | Another repository such as origin. | git remote -v |
Daily Workflow
- Update your main branch:
git switch mainthengit pull --ff-only. - Create a feature branch:
git switch -c feature/login. - Edit files and inspect changes with
git statusandgit diff. - Stage only intended changes with
git add file. - Review staged content with
git diff --staged. - Commit with a useful message:
git commit -m "Add login form validation". - Push and open a pull request:
git push -u origin feature/login.
Setup, Remotes, and .gitignore
Configure identity and a predictable default branch
git config --global user.name "Asha Rao"
git config --global user.email "asha@example.com"
git config --global init.defaultBranch main
git config --list --show-originThe name and email become commit metadata. Use an address approved by your organization or a hosting-provider privacy address when needed; never put passwords or access tokens in Git configuration committed to a repository.
Connect and inspect a remote
git remote add origin git@github.com:example/acme-app.git
git remote -v
git push -u origin main
# Change an existing remote URL later
git remote set-url origin git@github.com:example/new-name.gitThe -u option records the upstream so later git pull and git push know which remote branch to use. A remote is a named URL, not a separate copy magically kept in sync; use git fetch --prune to refresh remote-tracking references.
Start with a project-specific .gitignore
/vendor/
/node_modules/
/dist/
.env
.env.*
!.env.example
*.log
.idea/
.vscode/Important:
.gitignore affects untracked files; it does not untrack a secret or build output already committed. Remove an intended tracked file from the index with git rm --cached path. If a secret reached history, revoke or rotate it immediately—merely deleting the file is not enough.For authoritative command behavior and version-specific options, use the official Git reference.
Important Commands Map
| Goal | Command | Point |
|---|---|---|
| Start repository | git init | Create local Git history. |
| Clone repository | git clone <url> | Copy remote repository locally. |
| Check state | git status | Shows branch, staged, unstaged, untracked files. |
| Stage changes | git add | Move selected changes into the index. |
| Commit | git commit | Create a snapshot. |
| Fetch | git fetch | Download remote refs without merging. |
| Pull | git pull | Fetch plus merge or rebase. |
| Push | git push | Upload commits to remote. |
Branching and Collaboration
- Create short-lived branches for focused work.
- Name branches by purpose, such as
feature/payment-filterorfix/login-error. - Use pull requests for review, test checks, and discussion.
- Keep main branch protected with required reviews and CI checks.
- Delete merged branches to keep repository references clean.
Merge, Rebase, and Squash
| Action | What it does | Use when |
|---|---|---|
| Merge | Combines histories and may create a merge commit. | You want to preserve branch history. |
| Rebase | Replays commits on a new base. | You want to clean private feature branch history. |
| Squash merge | Combines feature branch into one target-branch commit. | Feature commits are noisy and main should stay concise. |
Rule: do not rebase shared commits that other developers already use unless the team coordinates it.
Safer History Rewrites and Signed Commits
Prefer --force-with-lease on a rebased feature branch
git fetch origin
git rebase origin/main
git push --force-with-lease origin feature/login--force-with-lease refuses to replace the remote branch when it has moved beyond the remote-tracking state you expected. That protects against accidentally erasing a teammate's newly pushed commit. It still rewrites history, so reserve it for your own coordinated feature branch; use git revert on protected or shared branches.
Optional SSH commit signing
git config --global gpg.format ssh
git config --global user.signingkey ~/.ssh/id_ed25519.pub
git config --global commit.gpgsign true
git commit -m "Fix login validation"
git log --show-signature -1Signing lets reviewers verify that a commit was signed by a configured key; it does not prove the code is safe. Register the public signing key with your Git hosting provider and follow your team's key-storage and rotation policy.
Undo and Recovery
| Need | Command | Safe use |
|---|---|---|
| Unstage file | git restore --staged file | Removes file from staging only. |
| Discard local edits | git restore file | Deletes unstaged edits intentionally. |
| Undo pushed commit | git revert <commit> | Creates a new inverse commit. |
| Recover lost pointer | git reflog | Finds previous HEAD/branch positions. |
| Temporarily save work | git stash push -m "message" | Shelves uncommitted changes. |
Conflict Handling
- Run
git statusto find conflicted files. - Open each file and read both sides of the conflict.
- Choose the final correct behavior, not just the text you wrote.
- Remove conflict markers and run tests or manual checks.
- Stage resolved files with
git add. - Continue merge or rebase with the command Git suggests.
Advanced Tools with Practical Examples
Handle a hotfix without disturbing current work
git worktree add ../acme-hotfix -b hotfix/login main
cd ../acme-hotfix
# edit, test, commit, and push the hotfix
git push -u origin hotfix/login
# Run from the original repository after finishing
git worktree remove ../acme-hotfixA worktree gives another branch its own directory while sharing the repository's object database. This is useful for an urgent fix when the primary directory contains unfinished work.
Locate the commit that introduced a regression
git bisect start
git bisect bad
git bisect good v2.4.0
# Test the checked-out midpoint, then mark it:
git bisect good # or: git bisect bad
git bisect resetEach good/bad answer halves the remaining search range. If one command reliably returns success for good commits and failure for bad ones, automate the test with git bisect run <test-command>.
git cherry-pick: apply one selected commit to the current branch.git tag -a: create an annotated release tag.git range-diff: compare two versions of a patch series after rebase.git sparse-checkout: work with only part of a large repository.
25 Most Important Practice Questions
1. What is Git?
Answer: A distributed version control system for tracking file history and collaboration.
2. What is a commit?
Answer: A snapshot of staged changes with metadata and parent links.
3. What is the staging area?
Answer: The index containing changes selected for the next commit.
4. What does git status show?
Answer: Branch state, staged changes, unstaged changes, and untracked files.
5. What is a branch?
Answer: A movable pointer to a commit.
6. What is HEAD?
Answer: Pointer to the current branch or checked-out commit.
7. What is origin?
Answer: The default name for the remote repository cloned from.
8. Fetch vs pull?
Answer: Fetch downloads remote refs; pull fetches and integrates by merge or rebase.
9. Merge vs rebase?
Answer: Merge joins histories; rebase replays commits on a new base.
10. When should you avoid rebase?
Answer: Avoid rebasing shared commits others depend on.
11. What is a fast-forward merge?
Answer: Moving the branch pointer forward when no divergent history exists.
12. What is a merge conflict?
Answer: A situation where Git cannot automatically combine changes.
13. Safest way to undo a pushed commit?
Answer: Use
git revert.14. What does git reset --soft do?
Answer: Moves branch pointer but keeps changes staged.
15. What does git restore do?
Answer: Restores files or unstages changes depending on options.
16. What is git stash?
Answer: Temporarily stores uncommitted work.
17. What is git reflog?
Answer: A log of HEAD and branch reference movements.
18. What is cherry-pick?
Answer: Applying a selected commit onto the current branch.
19. What is bisect?
Answer: Binary search through history to find a bad commit.
20. What is a tag?
Answer: A named reference often used for releases.
21. What is GitHub Flow?
Answer: Main branch plus short-lived feature branches merged by pull request.
22. What is trunk-based development?
Answer: Frequent small merges to the main branch, often behind feature flags.
23. Why write small commits?
Answer: Easier review, revert, bisect, and understand history.
24. Why avoid force push on shared branches?
Answer: It can rewrite history others are using.
25. Best habit before committing?
Answer: Review
git diff and git diff --staged.Continue learning
Monorepo
Nx Monorepo Guide: Apps, Libraries, Caching and CI
Learn modern Nx workspace setup, inferred tasks, project graphs, affected commands, caching, module boundaries, Nx Cloud, migrations, and CI patterns.
Hosting
How to Host a Website: From DNS to Production Deployment
Learn website hosting from domains and DNS through HTTPS, shared hosting, VPS, cloud platforms, GitHub Actions, rollback, monitoring, backups, and security.
JavaScript
RxJS Guide: Observables, Operators, Angular and Signals
Learn RxJS observables, subjects, operator choice, flattening, errors, testing, sharing, Angular cleanup, and signal interoperability with migration-safe examples.
Browse Free Tutorials
Explore 500+ free tutorials across 20+ languages and frameworks.