Git & GitHub

Branches let you work on features and fixes without breaking stable code. In this lesson you will create, switch, push, rename and delete branches, understand HEAD, and adopt naming conventions used by professional teams.

---

🌿 What Is a Branch?

A branch is an independent line of work. You create one to build a feature, fix a bug or try an idea without touching the stable code on main. When the work is ready, you merge it back.

Technically a branch is just a lightweight, movable pointer to a commit. Creating one is instant, even in huge repositories, which is why Git users branch all the time.

                 C4 ── C5      ← feature/login-tests
                /
C1 ── C2 ── C3                 ← main
                       ↑
                     HEAD points to the branch you are on

HEAD is Git’s marker for “where you are now”, usually the current branch.

---

📋 List Branches

git branch          # local branches; * marks the current one
git branch -a       # local and remote-tracking branches
git branch -v       # with the latest commit of each
git branch -vv      # plus upstream and ahead/behind information

  feature/login-tests
* main

---

➕ Create and Switch Branches

Modern Git (2.23 and newer) has git switch, made just for branches:

git switch -c feature/login-tests     # create a branch and switch to it
git switch main                       # switch to an existing branch
git switch -                          # switch back to the previous branch

The older, still common equivalents use git checkout:

Task	Modern	Older
Create and switch	git switch -c name	git checkout -b name
Switch	git switch name	git checkout name
Create without switching	git branch name	git branch name
Branch from a specific commit or branch	git switch -c hotfix main	git checkout -b hotfix main

---

🧪 Work on a Branch

git switch -c feature/login-tests
# edit tests/login.spec.ts
git add tests/login.spec.ts
git commit -m "Add login tests for locked-out users"
git log --oneline --graph --all

* 7e2f1a9 (HEAD -> feature/login-tests) Add login tests for locked-out users
* 8b1d4e2 (origin/main, main) Add learning goals and initial test plan
* 3f2a91c Add README with project title

main has not moved; your new commit exists only on the feature branch.

---

☁️ Push a Branch to GitHub

git push -u origin feature/login-tests

GitHub then shows a Compare & pull request button. Opening a pull request is covered in Pull Requests Step by Step.

Work on a teammate’s branch:

git fetch
git switch feature/api-tests      # creates a local branch tracking origin/feature/api-tests

---

✏️ Rename a Branch

git branch -m new-name                 # rename the current branch
git branch -m old-name new-name        # rename another branch

Rename a branch that is already on GitHub:

git branch -m feature/login feature/login-tests
git push origin -u feature/login-tests       # push the new name
git push origin --delete feature/login       # delete the old name on GitHub

---

🗑️ Delete a Branch

git branch -d feature/login-tests      # delete if already merged (safe)
git branch -D experiment               # force delete, even if not merged
git push origin --delete feature/login-tests   # delete the branch on GitHub
git fetch --prune                      # clean up remote-tracking branches deleted on GitHub

---

🏷️ Branch Naming Conventions

Clear names make a repository easy to navigate. A common convention:

Prefix	Use	Example
feature/	New functionality or tests	feature/checkout-api-tests
bugfix/ or fix/	Bug fixes	bugfix/flaky-login-wait
hotfix/	Urgent production fixes	hotfix/payment-timeout
chore/	Maintenance, dependencies, config	chore/upgrade-playwright
docs/	Documentation	docs/readme-setup
release/	Release preparation (Git Flow)	release/2.4.0

Use lowercase, hyphens instead of spaces, and add a ticket number if your team uses one: feature/QA-123-login-tests. Strategies such as Git Flow and trunk-based development are in branching strategies.

---

📝 Assignment

1. In git-practice, create feature/notes with git switch -c, make two commits, and view the graph with git log --oneline --graph --all.
2. Switch back to main and confirm the new commits are not there.
3. Push the branch to GitHub with -u and find it in the branch dropdown on GitHub.
4. Rename it to feature/study-notes locally and on GitHub.
5. Create a throwaway branch, commit something, delete it with -D, then recover it with git reflog.
6. Delete the remote branch and clean up with git fetch --prune.

---

❓ FAQ

🤔 What is a branch in Git?

A movable pointer to a commit that lets you develop independently from other work. New commits on a branch do not affect other branches until you merge.

🤔 How do I create a new branch in Git?

git switch -c branch-name (or git checkout -b branch-name) creates it and switches to it.

🤔 What is the difference between git switch and git checkout?

git switch is a newer command only for changing branches. git checkout does that and also restores files, which made it confusing; both still work.

🤔 How do I delete a branch locally and on GitHub?

git branch -d name locally (or -D to force) and git push origin --delete name on GitHub.

🤔 How do I rename a Git branch?

git branch -m new-name for the current branch; for a pushed branch, push the new name and delete the old one on GitHub.

---

🎯 Next Steps

• 🔀 git merge: Fast-Forward and Three-Way Merges
• 🧯 Resolve Merge Conflicts Step by Step
• 📘 Git and GitHub Tutorial: full course

You have a project on your computer and want it on GitHub. This lesson gives you the exact commands for a new or existing Git repository, explains each step, and fixes the errors people hit most often on their first push.

---

🎯 The Goal

You already have a project on your computer, for example a Playwright test framework or a Python script folder, and you want it on GitHub. This lesson shows the exact steps, for a folder that is not yet a Git repository and for one that already is.

---

🧭 Step 1: Create an Empty Repository on GitHub

1. On GitHub, click + (top right), then New repository.
2. Enter a name (for example playwright-framework), an optional description, and choose Public or Private.
3. Do not tick “Add a README file”, “.gitignore” or “license”. Your local project will provide these, and an empty repository avoids a conflict on the first push.
4. Click Create repository and copy the HTTPS or SSH URL shown on the next page.

---

📁 Step 2: Prepare the Local Project

Open a terminal in your project folder. First add a .gitignore so dependencies, reports and secrets are not uploaded:

node_modules/
test-results/
playwright-report/
.env

---

🚀 Step 3: Commit and Push (Folder Not Yet Using Git)

git init
git add .
git status                       # check that only the right files are staged
git commit -m "Initial commit: Playwright framework"
git branch -M main               # make sure the branch is called main
git remote add origin git@github.com:asha-verma-qa/playwright-framework.git
git push -u origin main

Refresh the GitHub page: your files and commit are there.

Command	Why
git init	Turns the folder into a repository (first repository)
git add . and git commit	Creates the first snapshot
git branch -M main	Renames the current branch to main (some setups default to master)
git remote add origin <url>	Connects to the GitHub repository (remotes)
git push -u origin main	Uploads and sets upstream tracking (push)

---

🔁 Step 3 (Alternative): Folder Already Using Git

If the project already has commits, you only need to add the remote and push:

git remote -v                     # check: is there already an origin?
git remote add origin git@github.com:asha-verma-qa/playwright-framework.git
git push -u origin main

If origin already points somewhere else, change it: git remote set-url origin <new-url>. To push every local branch and tag: git push -u origin --all and git push origin --tags.

---

⚠️ If You Already Created a README on GitHub

Then GitHub has a commit your local repository does not, and the first push is rejected. Merge the two histories once:

git pull origin main --allow-unrelated-histories
# resolve conflicts if any (often in README.md), then:
git push -u origin main

--allow-unrelated-histories is needed because the two repositories have no common starting commit.

---

⚡ Shortcut: GitHub CLI

With the GitHub CLI you can create the GitHub repository and push in one command from your project folder:

gh repo create playwright-framework --private --source=. --remote=origin --push

---

✅ After the First Push

• Add a good README with setup and run instructions (Markdown and README).
• Add a description and topics (for example playwright, typescript, test-automation) on the repository page so people can find it.
• Add a CI workflow so tests run on every push (Playwright in GitHub Actions).

---

🐞 Troubleshooting

Error	Fix
error: remote origin already exists	Use git remote set-url origin <url> instead of add
src refspec main does not match any	No commit yet, or the branch is named differently: commit first, or git branch -M main
! [rejected] main -> main (fetch first)	GitHub has a README or other commits: use the “unrelated histories” steps above
fatal: refusing to merge unrelated histories	Add --allow-unrelated-histories to the pull
Huge upload or node_modules on GitHub	Add a .gitignore, run git rm -r --cached node_modules, commit and push

---

📝 Assignment

1. Take any existing project folder on your computer (or create one with a few files) and add a .gitignore.
2. Create an empty repository on GitHub and push the project with the commands in Step 3.
3. Create a second GitHub repository with a README, then push another local project to it using --allow-unrelated-histories.
4. Add a description, topics and a README to your repository on GitHub.
5. Bonus: install the GitHub CLI and create and push a repository with gh repo create.

---

❓ FAQ

🤔 How do I push an existing project to GitHub?

Create an empty repository on GitHub, then in your project folder run git init, git add ., git commit -m "Initial commit", git branch -M main, git remote add origin <url> and git push -u origin main.

🤔 Why should I not add a README when creating the GitHub repository?

It creates a commit on GitHub that your local repository does not have, so your first push is rejected until you merge the two histories.

🤔 What does git branch -M main do?

It renames the current branch to main, overwriting any existing branch with that name.

🤔 How do I fix “remote origin already exists”?

Change the URL with git remote set-url origin <url>, or remove it with git remote remove origin and add it again.

🤔 What does –allow-unrelated-histories mean?

It lets Git merge two repositories that do not share a common first commit, such as a local project and a GitHub repository created with a README.

---

🎯 Next Steps

• 🌿 Git Branches: Create, Switch, Rename and Delete
• 📝 Markdown and Writing a Great README
• 📘 Git and GitHub Tutorial: full course

git fetch and git pull both get changes from GitHub, but they do very different things to your work. This lesson explains the difference with examples, shows how to review changes before integrating them, and helps you choose between merge and rebase when pulling.

---

⚖️ The Short Answer

• git fetch downloads new commits and branches from the remote without changing your files or your current branch. It only updates remote-tracking branches such as origin/main.
• git pull does a fetch and then integrates the new commits into your current branch (with a merge by default, or a rebase).

git pull  =  git fetch  +  git merge   (or git rebase with --rebase)

---

🧭 Side-by-Side Comparison

	git fetch	git pull
Downloads new commits	✅	✅
Updates origin/main and other remote-tracking branches	✅	✅
Changes your current branch	❌	✅
Changes files in your working directory	❌	✅
Can cause merge conflicts	❌	✅
Safe to run any time	✅ Always	⚠️ Commit or stash your work first
Best for	Seeing what changed before integrating	Quickly updating your branch

---

🔍 git fetch in Practice

git fetch                 # fetch from origin
git fetch --all           # fetch from every remote
git fetch --prune         # also remove remote-tracking branches deleted on GitHub
git fetch upstream        # fetch from another remote, e.g. the original project of a fork

After fetching, inspect the incoming changes before they touch your work:

git status
# Your branch is behind 'origin/main' by 3 commits, and can be fast-forwarded.

git log --oneline main..origin/main     # commits on GitHub that you do not have
git log --oneline origin/main..main     # your commits that GitHub does not have
git diff main origin/main               # the actual changes

Then integrate when you are ready:

git merge origin/main      # or: git rebase origin/main

---

📥 git pull in Practice

git pull                   # fetch + merge the upstream of the current branch
git pull origin main       # fetch main from origin and merge it into the current branch
git pull --rebase          # fetch + rebase your local commits on top
git pull --ff-only        # only update if no merge is needed; otherwise stop

Merge or rebase when pulling?

Strategy	Command or setting	Result when both sides have new commits
Merge (default)	git config --global pull.rebase false	A merge commit joins the two histories
Rebase	git config --global pull.rebase true	Your local commits are replayed on top; history stays linear
Fast-forward only	git config --global pull.ff only	Pull refuses and you decide what to do

If neither is configured, recent Git versions show a hint asking you to choose; that is why the config lesson sets pull.rebase false. Many teams prefer --rebase for feature branches to avoid “Merge branch ‘main’ of github.com…” commits. See rebase vs merge.

---

🧪 A Safe Workflow Before Pushing

git status                     # 1. make sure your work is committed (or stashed)
git fetch                      # 2. see what changed on GitHub
git log --oneline main..origin/main
git pull --rebase              # 3. integrate (resolve conflicts if needed)
npx playwright test            # 4. run your tests on the combined code
git push                       # 5. share

Unfinished work? Save it temporarily with git stash before pulling.

---

🐞 Common Situations

Message	Meaning and fix
“Your branch is behind ‘origin/main’ by 3 commits, and can be fast-forwarded”	Only GitHub has new commits; git pull will fast-forward cleanly
“Your branch and ‘origin/main’ have diverged”	Both sides have new commits; pull with merge or rebase
“Your local changes would be overwritten by merge”	Commit or stash your changes, then pull
“Automatic merge failed; fix conflicts”	Resolve the merge conflicts, then commit
Deleted remote branches still listed	git fetch --prune (or set fetch.prune true)

---

📝 Assignment

Use two clones of the same GitHub repository (practice and practice-copy):

1. Commit and push a change from practice-copy.
2. In practice, run git fetch and git status. Confirm your files did not change.
3. Use git log main..origin/main and git diff main origin/main to inspect the incoming change, then git merge origin/main.
4. Create diverging commits in both clones and pull once with merge and once with --rebase. Compare the histories with git log --oneline --graph.
5. Delete a branch on GitHub and remove its remote-tracking branch with git fetch --prune.

---

❓ FAQ

🤔 What is the difference between git fetch and git pull?

git fetch only downloads new commits and updates remote-tracking branches. git pull downloads them and also merges (or rebases) them into your current branch.

🤔 Is git fetch safe?

Yes. It never changes your working files or your current branch, so it is always safe to run.

🤔 When should I use git pull –rebase?

When you want a linear history without extra merge commits, for example on your own feature branch. Avoid rebasing commits others have already based work on.

🤔 How do I see what changes will come with git pull?

Run git fetch, then git log main..origin/main for the commits and git diff main origin/main for the changes.

🤔 How do I fix “Your branch and origin/main have diverged”?

Run git pull (merge) or git pull --rebase, resolve any conflicts, then push.

---

🎯 Next Steps

• 🚀 Push an Existing Project to GitHub
• 🌿 Git Branches: Create, Switch, Rename and Delete
• 📘 Git and GitHub Tutorial: full course

Clone, push and pull are how you share work through GitHub. In this lesson you will clone repositories, push your commits with upstream tracking, pull your team’s changes, handle rejected pushes and use force-push safely.

---

🔁 The Three Commands That Connect You to GitHub

Command	Direction	What it does
git clone	GitHub → your computer (once)	Downloads a full copy of a repository, with its history
git push	Your computer → GitHub	Uploads your new commits
git pull	GitHub → your computer	Downloads new commits and merges them into your branch

---

📥 git clone: Get a Copy of a Repository

On any GitHub repository page, click the green Code button and copy the HTTPS or SSH URL:

git clone git@github.com:microsoft/playwright.git
git clone https://github.com/asha-verma-qa/git-practice.git my-practice   # into a custom folder name

Cloning into 'git-practice'...
remote: Enumerating objects: 15, done.
Receiving objects: 100% (15/15), done.

What you get:

• A new folder with all files of the default branch.
• The complete history (git log works offline).
• A remote called origin pointing to the URL (remotes).
• A local main branch that tracks origin/main.

Useful clone options

Command	Use
git clone --branch develop <url>	Check out a specific branch after cloning
git clone --depth 1 <url>	Shallow clone: only the latest snapshot (fast for CI and huge repos)
git clone --recurse-submodules <url>	Also clone submodules

---

📤 git push: Send Your Commits to GitHub

First push of a branch

git push -u origin main

Enumerating objects: 6, done.
Writing objects: 100% (6/6), 512 bytes | 512.00 KiB/s, done.
To github.com:asha-verma-qa/git-practice.git
 * [new branch]      main -> main
branch 'main' set up to track 'origin/main'.

-u (--set-upstream) links your local main to origin/main. After that, a plain command is enough:

git push

When push is rejected

! [rejected]        main -> main (fetch first)
error: failed to push some refs to 'github.com:asha-verma-qa/git-practice.git'
hint: Updates were rejected because the remote contains work that you do not have locally.

Someone else pushed first. Get their commits, then push again:

git pull
git push

Force push (use with care)

After rewriting history (for example a rebase), a normal push is rejected. Prefer the safer form:

git push --force-with-lease

--force-with-lease refuses to overwrite the remote if someone else pushed commits you have not seen. Plain --force overwrites blindly.

---

📥 git pull: Get Your Team’s Changes

git pull

Updating 8b1d4e2..c4d5e6f
Fast-forward
 tests/login.spec.ts | 12 ++++++++++++
 1 file changed, 12 insertions(+)

git pull is two commands in one: git fetch (download) and git merge (integrate). If you and a teammate changed the same lines, you get a merge conflict. The difference between fetch and pull has its own lesson.

git pull origin main        # pull a specific branch from a specific remote
git pull --rebase           # replay your local commits on top instead of merging

---

🔄 A Daily Team Routine

git pull                          # 1. start the day up to date
# ... edit files ...
git add .
git commit -m "Add API tests for orders endpoint"   # 2. commit small changes often
git pull                          # 3. integrate teammates' work before pushing
git push                          # 4. share your work

In real teams you push to a feature branch and open a pull request instead of pushing to main directly. Branches are next in Module 4.

---

🐞 Common Errors

Error	Fix
fatal: repository not found	Wrong URL or no access; check git remote -v and your GitHub permissions
Permission denied (publickey)	SSH key not set up; see SSH keys or use HTTPS
Authentication failed (HTTPS)	Passwords are not accepted; use Git Credential Manager or a personal access token
rejected (fetch first)	Run git pull, resolve any conflicts, then push
There is no tracking information for the current branch	Push once with git push -u origin <branch>

---

📝 Assignment

1. Push your local git-practice repository to GitHub with git push -u origin main and refresh the GitHub page.
2. Clone the same repository into another folder (git clone <url> practice-copy).
3. In the copy, make a commit and push it. In the original folder, run git pull and check git log --oneline.
4. Make commits in both folders, push from one, and push from the other to see the “rejected” message. Fix it with git pull and push again.
5. Clone a popular open-source repository with --depth 1 and compare its size with a full clone.

---

❓ FAQ

🤔 How do I push code to GitHub?

Commit your changes, then run git push. For the first push of a branch use git push -u origin <branch> to set the upstream.

🤔 What does git push -u origin main mean?

Push the local main branch to the remote origin and remember origin/main as its upstream, so later you can just run git push and git pull.

🤔 What is the difference between git clone and git pull?

git clone creates a new local copy of a repository once. git pull updates an existing local copy with new commits from the remote.

🤔 Why is my git push rejected?

The remote has commits you do not have. Run git pull, resolve conflicts if any, then push again.

🤔 What is the difference between –force and –force-with-lease?

--force overwrites the remote branch unconditionally. --force-with-lease only overwrites it if nobody else has pushed in the meantime, which is much safer.

---

🎯 Next Steps

• ⚖️ git fetch vs git pull
• 🚀 Push an Existing Project to GitHub
• 📘 Git and GitHub Tutorial: full course

A remote connects your local repository to a copy on GitHub. In this lesson you will add and manage remotes, understand origin and upstream, and read remote-tracking branches such as origin/main so push and pull make sense.

---

🌐 What Is a Remote?

So far your repository lives only on your computer. A remote is another copy of the same repository, usually on a server such as GitHub, that you can send commits to and receive commits from. Remotes are how teams share work and how your code is backed up.

A local repository can have several remotes. Each has a short name and a URL.

Name	Points to	Typical use
origin	The repository you cloned from, or your main GitHub repository	Push and pull your work
upstream	The original project you forked	Get updates from the original project (forks)

origin and upstream are only conventions; you could name a remote anything.

---

👀 List Your Remotes

git remote          # names only
git remote -v       # names and URLs

origin  git@github.com:asha-verma-qa/git-practice.git (fetch)
origin  git@github.com:asha-verma-qa/git-practice.git (push)

A repository created with git init has no remotes. A cloned repository automatically has origin.

---

➕ Add a Remote

Create an empty repository on GitHub (no README, .gitignore or licence), copy its URL, then:

git remote add origin git@github.com:asha-verma-qa/git-practice.git
git remote -v

Use the HTTPS URL (https://github.com/...) if you have not set up SSH keys.

---

✏️ Change, Rename or Remove a Remote

git remote set-url origin https://github.com/asha-verma-qa/git-practice.git   # switch SSH to HTTPS (or the reverse)
git remote rename origin github
git remote remove github

Changing the URL is common when a repository is renamed or moved to another organization, or when you switch between HTTPS and SSH.

---

🔎 Inspect a Remote

git remote show origin

* remote origin
  Fetch URL: git@github.com:asha-verma-qa/git-practice.git
  Push  URL: git@github.com:asha-verma-qa/git-practice.git
  HEAD branch: main
  Remote branches:
    main tracked
  Local branch configured for 'git pull':
    main merges with remote main
  Local ref configured for 'git push':
    main pushes to main (up to date)

---

🌿 Remote-Tracking Branches

When Git talks to a remote, it remembers the remote’s branches locally as remote-tracking branches, named origin/main, origin/feature-login and so on. They are read-only bookmarks of “where the remote was the last time I checked”.

git branch -r      # remote-tracking branches
git branch -a      # local and remote-tracking branches
git branch -vv     # local branches with their upstream and ahead/behind counts

* main 8b1d4e2 [origin/main: ahead 2] Add learning goals and initial test plan

“Ahead 2” means you have two local commits that are not on GitHub yet. “Behind 3” would mean GitHub has three commits you have not pulled.

Upstream (tracking) branch

A local branch can track a remote branch, its upstream. Then plain git push and git pull know where to go. You set it with git push -u (next lesson) or manually:

git branch --set-upstream-to=origin/main main

---

🍴 origin and upstream with Forks

When you contribute to someone else’s project, you usually fork it on GitHub and clone your fork:

git clone git@github.com:asha-verma-qa/playwright-demo.git     # your fork = origin
cd playwright-demo
git remote add upstream https://github.com/original-org/playwright-demo.git
git fetch upstream                                             # get the original project's updates

The full fork workflow is in Fork a Repository and Contribute to Open Source.

---

📝 Assignment

1. Create an empty git-practice repository on GitHub and add it as origin to your local git-practice repository.
2. Run git remote -v and git remote show origin (after the first push in the next lesson).
3. Switch the remote URL from SSH to HTTPS and back with git remote set-url.
4. Rename origin to github and back.
5. Run git branch -vv before and after making a local commit and explain “ahead”.

---

❓ FAQ

🤔 What is origin in Git?

The default name for the remote repository you cloned from or added first, usually your repository on GitHub.

🤔 What is the difference between origin and upstream?

origin is usually your own copy (often a fork). upstream is the original project you forked from, used to bring its latest changes into your fork.

🤔 How do I change the remote URL in Git?

git remote set-url origin <new-url>, then check with git remote -v.

🤔 What is origin/main?

A remote-tracking branch: Git’s local record of where main was on origin the last time you fetched or pulled.

🤔 How do I see all branches including remote ones?

git branch -a lists local and remote-tracking branches.

---

🎯 Next Steps

• 📤 git clone, push and pull Step by Step
• ⚖️ git fetch vs git pull
• 📘 Git and GitHub Tutorial: full course

Everyone makes mistakes in Git. The trick is knowing which undo command fits the situation. This lesson gives you a decision table and explains git restore, commit –amend, the three modes of git reset, git revert, git clean and the reflog safety net.

---

↩️ Mistakes Happen: Git Can Undo Almost Anything

Edited the wrong file? Committed too early? Pushed a bug? Git has a precise command for each situation. The key question is always: where is the change now? In the working directory, the staging area, a local commit, or a commit already pushed to GitHub?

Review the three areas in Working Directory, Staging Area and Repository if needed.

---

🧭 Quick Decision Table

Situation	Command	Safe?
Discard unsaved edits in a file	git restore file	⚠️ Edits are lost
Unstage a file (keep the edits)	git restore --staged file	✅
Fix the last commit’s message	git commit --amend -m "new message"	✅ if not pushed
Add a forgotten file to the last commit	git add file then git commit --amend --no-edit	✅ if not pushed
Undo the last commit, keep changes staged	git reset --soft HEAD~1	✅ if not pushed
Undo the last commit, keep changes unstaged	git reset HEAD~1 (mixed)	✅ if not pushed
Throw away the last commit and its changes	git reset --hard HEAD~1	⚠️ Changes are lost
Undo a commit that is already pushed	git revert <hash>	✅ Always safe
Delete untracked files	git clean -n (preview), then git clean -fd	⚠️ Files are lost

---

📝 1. Discard Changes in the Working Directory: git restore

git restore test-plan.txt     # discard edits in one file
git restore .                 # discard all unstaged edits

This replaces the file with the version from the staging area (or the last commit). Older tutorials use git checkout -- file, which does the same thing.

---

🎒 2. Unstage Changes: git restore –staged

git add .
git restore --staged secrets.txt   # remove it from the next commit, keep the file as it is

The older equivalent is git reset HEAD secrets.txt.

---

✏️ 3. Fix the Last Commit: git commit –amend

Typo in the message:

git commit --amend -m "Add login tests for locked-out users"

Forgot a file:

git add tests/logout.spec.ts
git commit --amend --no-edit

--amend replaces the last commit with a new one (new hash). Use it only for commits you have not pushed yet.

---

⏪ 4. Undo Local Commits: git reset

git reset moves your branch back to an earlier commit. The three modes decide what happens to the changes from the removed commits:

Mode	Branch moves back	Staging area	Working directory	Use it to
--soft	✅	Changes kept staged	Unchanged	Redo the commit, e.g. combine several commits
--mixed (default)	✅	Changes unstaged	Unchanged	Re-select what to commit
--hard	✅	Reset	Changes deleted	Throw work away completely

git log --oneline
# 9c7e1aa (HEAD -> main) WIP debug logs
# 8b1d4e2 Add learning goals and initial test plan
# 3f2a91c Add README with project title

git reset --soft HEAD~1    # undo "WIP debug logs", changes stay staged
git reset HEAD~1           # same, but changes become unstaged
git reset --hard HEAD~1    # undo it and delete its changes
git reset --hard 3f2a91c   # go back to a specific commit

---

🔄 5. Undo Pushed Commits Safely: git revert

git revert does not delete anything. It creates a new commit that applies the opposite changes, so history stays intact and everyone can simply pull it:

git revert 9c7e1aa
# Git opens the editor with the message "Revert "WIP debug logs"". Save and close.
git push

a1b2c3d (HEAD -> main) Revert "WIP debug logs"
9c7e1aa WIP debug logs
8b1d4e2 Add learning goals and initial test plan

	git reset	git revert
How it undoes	Moves the branch back; removes commits from history	Adds a new commit with the inverse changes
History	Rewritten	Preserved
Safe for pushed or shared branches	❌ No	✅ Yes
Typical use	Clean up local work before pushing	Undo a change that is already on GitHub

Useful options: git revert --no-edit <hash> (keep the default message) and git revert HEAD~3..HEAD (revert a range of commits).

---

🧹 6. Remove Untracked Files: git clean

git clean -n     # dry run: list what would be deleted
git clean -f     # delete untracked files
git clean -fd    # also delete untracked folders

Files listed in .gitignore are kept unless you add -x.

---

🛟 The Safety Net: git reflog

Ran git reset --hard by mistake? Commits are not gone immediately. git reflog lists every position HEAD has been in:

git reflog
# 8b1d4e2 HEAD@{0}: reset: moving to HEAD~1
# 9c7e1aa HEAD@{1}: commit: WIP debug logs

git reset --hard 9c7e1aa   # bring the "lost" commit back

Learn more in git reflog: recover lost commits.

---

📝 Assignment

In your git-practice repository:

1. Edit a file and discard the edit with git restore.
2. Stage two files and unstage one with git restore --staged.
3. Make a commit with a typo in the message and fix it with --amend.
4. Make a commit, forget a file, and add it with --amend --no-edit.
5. Make three test commits and try reset --soft, reset --mixed and reset --hard on them, noting what happens to the changes each time.
6. Make a commit, then undo it with git revert and explain how the history differs from a reset.
7. Use git reflog to recover a commit you removed with reset --hard.

---

❓ FAQ

🤔 What is the difference between git reset and git revert?

git reset moves the branch back and removes commits from history, which is fine for local work. git revert adds a new commit that undoes a previous one, which is safe for commits already pushed.

🤔 How do I undo the last commit but keep my changes?

git reset --soft HEAD~1 keeps them staged; git reset HEAD~1 keeps them unstaged in your files.

🤔 How do I undo git add?

git restore --staged <file> (or git reset HEAD <file> in older Git versions).

🤔 What does git reset –hard do?

It moves the branch to the given commit and deletes all uncommitted changes and the removed commits’ changes from your files. Use it with care.

🤔 How do I undo a commit that I already pushed?

Use git revert <commit-hash> and push the new revert commit. Avoid resetting and force-pushing shared branches.

---

🎯 Next Steps

• 🌐 Remote Repositories: origin, upstream and git remote
• 📤 git clone, push and pull Step by Step
• 📘 Git and GitHub Tutorial: full course

Some files should never be in Git: dependencies, test reports, logs and especially secrets. In this lesson you will write a proper .gitignore, understand its pattern syntax, use ready-made templates and fix the classic “.gitignore is not working” problem.

---

🙈 What Is .gitignore?

Not every file in your project folder belongs in Git. Dependencies, build output, logs, test reports and secrets should stay out of the repository. A .gitignore file is a plain text file, usually in the repository root, that lists patterns of files and folders Git should ignore.

Ignored files do not show up as “untracked” in git status, and git add . skips them.

---

🚫 What Should You Ignore?

Category	Examples	Why
Dependencies	node_modules/, venv/, .venv/	Huge, and recreated with npm install or pip install
Build output	dist/, build/, target/, *.class	Generated from source code
Test results and reports	test-results/, playwright-report/, allure-results/, coverage/	Generated on every run
Secrets	.env, *.pem, credentials.json, playwright/.auth/	Must never be shared publicly
Logs and temp files	*.log, *.tmp, .cache/	Noise
OS and editor files	.DS_Store, Thumbs.db, .idea/, .vscode/ (optional)	Personal, not project files

---

✍️ Create Your First .gitignore

In the repository root:

# Dependencies
node_modules/

# Environment variables and secrets
.env
.env.*
!.env.example

# Test output
test-results/
playwright-report/
allure-results/

# Logs
*.log

# OS files
.DS_Store
Thumbs.db

Commit the .gitignore file itself so the whole team shares the same rules:

git add .gitignore
git commit -m "Add .gitignore for dependencies, secrets and test output"

---

🧩 Pattern Syntax

Pattern	Matches
debug.log	A file named debug.log in any folder
*.log	Any file ending in .log
build/	Any folder named build (and everything inside)
/build/	Only the build folder in the repository root
docs/*.pdf	PDFs directly inside docs, not in its subfolders
docs/**/*.pdf	PDFs anywhere inside docs
**/temp	A temp file or folder at any depth
!important.log	Exception: do not ignore this file (negation)
# comment	A comment line

---

🧰 Ready-Made Templates

You rarely write a .gitignore from scratch:

• When creating a repository on GitHub, choose a template from the Add .gitignore dropdown (Node, Python, Java, VisualStudio and many more).
• GitHub maintains the official collection in the github/gitignore repository.
• Generator websites such as gitignore.io combine templates for your language, framework and editor.

Example: Playwright with TypeScript project

node_modules/
/test-results/
/playwright-report/
/blob-report/
/playwright/.cache/
/playwright/.auth/
.env

This matches what npm init playwright@latest generates, plus the folders for saved login sessions and secrets. See Install Playwright.

Example: Python project

__pycache__/
*.py[cod]
.venv/
venv/
.pytest_cache/
.env
reports/

---

🧹 Ignoring a File That Is Already Tracked

Adding a file to .gitignore does not affect files Git already tracks. Stop tracking it first:

git rm --cached .env                 # stop tracking, keep the file on disk
git rm -r --cached node_modules      # a whole folder
git commit -m "Stop tracking .env and node_modules"

---

🔎 Debugging: Why Is (or Isn’t) a File Ignored?

git check-ignore -v playwright-report/index.html

.gitignore:3:/playwright-report/	playwright-report/index.html

The output shows which file and line caused the match. List everything currently ignored with git status --ignored.

---

🌍 Personal Ignore Rules

Rules that only matter to you (your editor or OS) can live outside the project:

Location	Scope
.gitignore in the repo	Everyone working on the project (committed)
.git/info/exclude	Only this repository on your computer (not committed)
Global file, set with git config --global core.excludesFile ~/.gitignore_global	All repositories on your computer

---

📝 Assignment

1. In git-practice, create node_modules/test.js, app.log, .env and report/index.html, and check git status.
2. Write a .gitignore that ignores all four, commit it, and check git status again.
3. Add !keep.log as an exception and confirm with git check-ignore -v.
4. Commit a file called secret.txt, then stop tracking it with git rm --cached and ignore it.
5. Set up a global ignore file for your OS and editor files.
6. Bonus: generate a .gitignore for Node, Python and VS Code from a template and compare it with yours.

---

❓ FAQ

🤔 What is .gitignore in Git?

A text file that lists files and folders Git should not track, such as dependencies, build output, logs and secrets.

🤔 Why is .gitignore not working?

Usually because the file is already tracked. Run git rm --cached <file> and commit. Also check the pattern with git check-ignore -v <file>.

🤔 Should I commit the .gitignore file?

Yes. Committing it shares the same ignore rules with everyone on the project.

🤔 Should I ignore the .env file?

Yes. .env files usually contain secrets. Commit a .env.example with placeholder values instead.

🤔 How do I ignore a folder in Git?

Add the folder name with a trailing slash, for example node_modules/, to .gitignore.

---

🎯 Next Steps

• ↩️ Undo Changes: restore, reset, revert and amend
• 🌐 Remote Repositories: origin, upstream and git remote
• 📘 Git and GitHub Tutorial: full course

Git remembers everything, but only if you know how to ask. In this lesson you will explore history with git log, inspect commits with git show, compare versions with git diff and find who last changed a line with git blame.

---

📜 Why History Matters

Git’s history answers the questions every team asks: What changed? Who changed it? When? Why? In this lesson you will learn to read history with git log, inspect a single commit with git show, compare versions with git diff and find who last changed a line with git blame.

Use your git-practice repository from your first repository, with a few commits in it.

---

📖 git log: The Commit History

git log

commit 8b1d4e2c7a9f0b1e2d3c4b5a69788f7e6d5c4b3a (HEAD -> main)
Author: Asha Verma <asha.verma@example.com>
Date:   Thu Oct 30 10:15:42 2026 +0530

    Add learning goals and initial test plan

commit 3f2a91c...

Each entry shows the full commit hash, author, date and message. Newest commits are at the top. Press q to exit the pager and Space to scroll.

The most useful git log options

Command	Shows
git log --oneline	One line per commit: short hash and message
git log --oneline --graph --all --decorate	Branches and merges as a text graph
git log -n 5	Only the last 5 commits
git log --stat	Files changed and lines added/removed per commit
git log -p	The full diff of every commit
git log --author="Asha"	Commits by an author
git log --since="2 weeks ago"	Commits in a time range (also --until)
git log --grep="login"	Commits whose message contains “login”
git log -- tests/login.spec.ts	Commits that changed one file
git log -S "waitForTimeout"	Commits that added or removed that text

Custom formats

git log --pretty=format:"%h %an %ar %s"

8b1d4e2 Asha Verma 2 hours ago Add learning goals and initial test plan
3f2a91c Asha Verma 3 hours ago Add README with project title

Common placeholders: %h short hash, %an author name, %ar relative date, %ad date, %s subject.

---

🔍 git show: Inspect One Commit

git show 8b1d4e2          # a specific commit (the short hash is enough)
git show HEAD             # the latest commit
git show HEAD~1           # the commit before it
git show HEAD:README.md   # a file's content as it was in that commit
git show --stat HEAD      # only the list of changed files

Referring to commits

Reference	Meaning
HEAD	The commit you are on now
HEAD~1 or HEAD^	One commit before HEAD
HEAD~3	Three commits before HEAD
main	The latest commit on the main branch
8b1d4e2	A specific commit by its (short) hash

---

⚖️ git diff: Compare Versions

git diff                       # unstaged changes
git diff --staged              # staged changes (what you are about to commit)
git diff HEAD~2 HEAD           # changes between two commits
git diff HEAD~2 -- README.md   # one file only
git diff main feature/login    # two branches
git diff --stat main feature/login   # summary only
git diff --word-diff           # highlight changed words instead of whole lines

Reading a diff

diff --git a/test-plan.txt b/test-plan.txt
index 3b18e51..a5c1966 100644
--- a/test-plan.txt
+++ b/test-plan.txt
@@ -1,2 +1,3 @@
 Smoke tests: login, search, checkout
-API tests: none
+API tests: users, orders
+Visual tests: home page

• --- is the old version, +++ the new version.
• @@ -1,2 +1,3 @@ means “from line 1, 2 lines before; from line 1, 3 lines after”.
• Lines starting with - were removed, + were added, and lines with a space are unchanged context.

---

🕵️ git blame: Who Changed This Line?

git blame tests/login.spec.ts
git blame -L 10,20 tests/login.spec.ts   # only lines 10 to 20

8b1d4e2c (Asha Verma 2026-10-30 10:15:42 +0530 12)   await page.getByRole('button', { name: 'Login' }).click();

Each line shows the commit, author and date of its last change. Despite the name, use it to find context, not to blame people. In VS Code, extensions such as GitLens show this inline, and GitHub shows it with the Blame button on any file.

---

🌐 History on GitHub

On github.com, every repository has a commits link with the full history, each commit has a diff view, and every file has History and Blame buttons. These are the same commands, with a friendly interface.

---

📝 Assignment

1. Run git log, git log --oneline and git log --stat and describe the difference.
2. Show only commits that changed README.md.
3. Use git show HEAD~1 and git show HEAD:README.md and explain what each displays.
4. Compare your first and latest commits with git diff <first-hash> HEAD.
5. Find the commit that added a specific word with git log -S "word".
6. Run git blame on a file with several commits.
7. Bonus: build a custom --pretty=format that shows the date, author and message.

---

❓ FAQ

🤔 How do I see commit history in Git?

Run git log, or git log --oneline for a compact view and git log --oneline --graph --all to include branches.

🤔 How do I see the changes in a specific commit?

git show <commit-hash> shows the commit’s message and full diff.

🤔 What is the difference between HEAD~1 and HEAD^?

For normal commits they are the same: the parent of HEAD. They differ only for merge commits, where ^2 means the second parent.

🤔 How do I compare two branches in Git?

git diff branch1 branch2, or git diff --stat branch1 branch2 for a summary of changed files.

🤔 How do I exit git log?

Press q to quit the pager.

---

🎯 Next Steps

• 🙈 .gitignore: Ignore Files the Right Way
• ↩️ Undo Changes: restore, reset, revert and amend
• 📘 Git and GitHub Tutorial: full course

Most Git confusion disappears once you understand three places: the working directory, the staging area and the repository. This lesson explains them with diagrams, git status output and the commands that move changes between them.

---

🧩 The Three Areas of Git

Every Git project has three areas. Understanding them makes every other Git command easier.

Area	Also called	What it holds
Working directory	Working tree	The files you see and edit in your folder
Staging area	Index	The changes you have selected for the next commit
Repository	Local repo, .git	Every commit, saved permanently

┌───────────────────┐  git add   ┌──────────────┐  git commit  ┌──────────────┐
│ Working directory │ ─────────▶ │ Staging area │ ───────────▶ │  Repository  │
│  (edit files)     │ ◀───────── │   (index)    │              │   (.git)     │
└───────────────────┘ git restore└──────────────┘              └──────────────┘
                        --staged

Analogy: packing for a trip. The working directory is your room full of clothes, the staging area is the open suitcase where you put only what you want to take, and a commit closes the suitcase and labels it with the date.

---

🚦 The Four States of a File

State	Meaning	How it gets there
Untracked	New file Git has never seen	You create a file
Unmodified	Tracked and identical to the last commit	After a commit
Modified	Tracked, changed, not staged	You edit a tracked file
Staged	Change selected for the next commit	git add

---

🔎 Reading git status

git status

On branch main
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
	modified:   README.md

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
	modified:   test-plan.txt

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	login.spec.ts

Three sections, three areas: staged (green), modified but not staged (red), and untracked.

The short format

git status -s

M  README.md
 M test-plan.txt
?? login.spec.ts

Code	Meaning
M in the left column	Modified and staged
M in the right column	Modified, not staged
MM	Staged, then modified again
A	New file, staged
D	Deleted
??	Untracked

---

🔬 See the Differences in Each Area

git diff            # working directory vs staging area (unstaged changes)
git diff --staged   # staging area vs last commit (what will be committed)
git diff HEAD       # working directory vs last commit (everything)

---

🔁 Moving Changes Between Areas

Goal	Command
Stage a change	git add file
Unstage a change (keep it in the file)	git restore --staged file
Discard unstaged changes in a file	git restore file (cannot be undone)
Stop tracking a file but keep it on disk	git rm --cached file
Delete a tracked file and stage the deletion	git rm file
Rename or move a tracked file	git mv old.txt new.txt

More ways to undo things, including commits, are in Undo Changes.

---

🎯 Why the Staging Area Is Useful

The staging area lets you build clean, focused commits even when you changed many things at once:

# You fixed a bug AND reformatted some files. Commit them separately:
git add src/checkout.ts
git commit -m "Fix rounding of tax on checkout"

git add .
git commit -m "Format test files with Prettier"

With git add -p you can even stage parts of a file: Git shows each changed block (hunk) and asks y (stage), n (skip), s (split) or q (quit).

Small, focused commits make history readable, code review easier and bugs easier to find with tools like git bisect.

---

📝 Assignment

In your git-practice repository:

1. Create a new file, modify a tracked file, and stage only the modified one. Run git status and git status -s and identify each state.
2. Run git diff, git diff --staged and git diff HEAD and describe what each shows.
3. Stage a file, then unstage it with git restore --staged.
4. Make a change you do not want and discard it with git restore.
5. Rename a file with git mv and commit the rename.
6. Bonus: change two unrelated lines in one file and commit them separately using git add -p.

---

❓ FAQ

🤔 What is the staging area in Git?

A middle step between your files and the repository where you collect the exact changes for the next commit. It is also called the index.

🤔 What is the difference between git diff and git diff –staged?

git diff shows changes not yet staged. git diff --staged shows staged changes that will go into the next commit.

🤔 How do I unstage a file in Git?

git restore --staged file moves the change out of the staging area but keeps your edits in the file.

🤔 What does ?? mean in git status -s?

The file is untracked: Git has never been told to track it.

🤔 How do I stop tracking a file without deleting it?

git rm --cached file, then add it to .gitignore so it is not added again.

---

🎯 Next Steps

• 📜 View History and Changes: git log, show and diff
• 🙈 .gitignore: Ignore Files the Right Way
• 📘 Git and GitHub Tutorial: full course

Time to use Git for real. In this lesson you will turn a folder into a repository and make your first commits, learning the four commands you will use every day: git init, git status, git add and git commit.

---

🎯 What You Will Build

In this lesson you will turn an ordinary folder into a Git repository and save your first snapshots (commits). By the end you will know the four commands you will use every single day: git init, git status, git add and git commit.

Make sure Git is installed and configured with your name and email.

---

📁 Step 1: Create a Project Folder

mkdir qa-notes
cd qa-notes

---

🧱 Step 2: Initialize the Repository with git init

git init

Initialized empty Git repository in C:/Users/asha/qa-notes/.git/

git init creates a hidden .git folder. That folder is the repository: it stores every commit, branch and setting. Your files stay where they are; Git simply starts watching the folder.

---

🔍 Step 3: Check the State with git status

git status

On branch main

No commits yet

nothing to commit (create/copy files and use "git add" to track)

git status is your best friend. Run it before and after every command; it tells you exactly what Git sees and usually suggests the next command.

---

✍️ Step 4: Create a File

Create README.md with any editor, or from the terminal:

echo "# QA Notes" > README.md
git status

On branch main

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	README.md

Untracked means Git sees the file but is not managing it yet.

---

➕ Step 5: Stage the File with git add

git add README.md
git status

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
	new file:   README.md

The file is now staged: it is in the list of changes that will go into the next commit. Common ways to stage:

Command	Stages
git add README.md	One file
git add docs/	Everything in a folder
git add .	All changes in the current folder and below
git add -A	All changes in the whole repository, including deletions
git add -p	Pieces of files, interactively (great for clean commits)

---

💾 Step 6: Save a Snapshot with git commit

git commit -m "Add README with project title"

[main (root-commit) 3f2a91c] Add README with project title
 1 file changed, 1 insertion(+)
 create mode 100644 README.md

You just made your first commit. 3f2a91c is the start of the commit’s unique ID (hash). Run git status again and you will see “nothing to commit, working tree clean”.

---

🔁 Step 7: The Everyday Loop

Make a second change and commit it:

echo "- Learn Git basics" >> README.md
echo "Smoke tests: login, search, checkout" > test-plan.txt
git status
git add README.md test-plan.txt
git commit -m "Add learning goals and initial test plan"

See your history:

git log --oneline

8b1d4e2 (HEAD -> main) Add learning goals and initial test plan
3f2a91c Add README with project title

This edit, add, commit loop is 80% of daily Git work. Viewing history in detail is covered in git log and diff.

---

⚡ Shortcut: git commit -am

For files Git already tracks, you can stage and commit in one step:

git commit -am "Update test plan with API tests"

---

✍️ Writing Good Commit Messages

A commit message is a note to your future self and your team.

❌ Avoid	✅ Prefer
update	Add login tests for locked-out users
fix	Fix flaky checkout test by waiting for the API response
changes	Rename test data files to match feature names

Rules of thumb: start with a verb in the imperative (“Add”, “Fix”, “Remove”), keep the first line under about 50 characters, and describe what and why, not how. The full conventions are in commit messages and Conventional Commits.

---

🧭 What Happened Behind the Scenes?

Working directory  ──git add──▶  Staging area  ──git commit──▶  Repository (.git)
   (your files)                (next snapshot)               (saved history)

These three areas are the heart of Git. The next lesson explains them in detail.

---

📝 Assignment

1. Create a folder git-practice, run git init and check git status.
2. Create README.md and notes.txt, stage only README.md, and commit it. Run git status and explain why notes.txt is still untracked.
3. Stage and commit notes.txt with a good commit message.
4. Make three more small commits, then run git log --oneline.
5. Edit a tracked file and commit it with git commit -am.
6. Bonus: create two changes in one file and use git add -p to commit only one of them.

---

❓ FAQ

🤔 What does git init do?

It creates a hidden .git folder that turns the current folder into a Git repository, so Git can start tracking changes.

🤔 What is the difference between git add and git commit?

git add chooses which changes go into the next snapshot (staging). git commit saves the staged changes permanently in the repository history with a message.

🤔 What does git add . do?

It stages all new, modified and deleted files in the current folder and its subfolders.

🤔 How do I commit with a message in Git?

git commit -m "Your message". Without -m, Git opens your configured editor to write the message.

🤔 Why does Git say “Please tell me who you are”?

Your name and email are not configured. Run the commands from Configure Git, then commit again.

---

🎯 Next Steps

• 🗂️ Working Directory, Staging Area and Repository
• 📜 View History and Changes: git log, show and diff
• 📘 Git and GitHub Tutorial: full course