Master Git & GitHub

$ # Check Git is installed (download from git-scm.com if not)
$ git --version
>> git version 2.43.0

$ # Configure your identity — required ONCE per computer
$ git config --global user.name "Priya Sharma"
$ git config --global user.email "priya@example.com"

$ # Use VS Code as the editor, and 'main' as the default branch
$ git config --global core.editor "code --wait"
$ git config --global init.defaultBranch main

$ # Verify
$ git config --list
>> user.name=Priya Sharma
>> user.email=priya@example.com
>> init.defaultBranch=main

assignment.docx
assignment-v2.docx
assignment-v2-edited.docx
assignment-v2-edited-FINAL.docx
assignment-v2-edited-FINAL-ACTUALLY-FINAL.docx
assignment-v2-edited-FINAL-ACTUALLY-FINAL-2.docx

$ # ...which one did the professor grade?
$ # ...which one has your partner's latest changes?
$ # ...where did the paragraph you wrote at 2am go?

WITHOUT GIT                          WITH GIT
------------------------------       ------------------------------
project-v1/                          project/
project-v2/                            .git/            (full history)
project-v2-fixed/                       index.html
project-FINAL/                          style.css
project-FINAL-USE-THIS/                 app.js
project-FINAL-USE-THIS-2/
                                      $ git log --oneline
$ # which folder is "current"?       >> a1b2c3d Fix navbar bug
$ # copy-paste merges by hand        >> 9f8e7d6 Add contact form
$ # no record of WHO changed WHAT    >> 4c5b6a7 Initial commit

Working Directory  --(git add)-->  Staging Area  --(git commit)-->  Repository
   (your edits)                    (what's next)                    (saved forever)

$ mkdir my-portfolio
$ cd my-portfolio
$ git init
>> Initialised empty Git repository in /home/priya/my-portfolio/.git/

$ git status
>> Untracked files:
>>   (use "git add <file>..." to include in what will be committed)
>>         index.html      <-- shown in red

$ git add index.html
$ git status
>> Changes to be committed:
>>         new file:   index.html      <-- now shown in green

$ git add .          # stage every changed file in this folder
$ git add *.js       # stage only JavaScript files
$ git restore --staged index.html   # oops — unstage it (keeps your edits)

$ git add .
$ git commit -m "Add initial project files"
>> [main (root-commit) a1b2c3d] Add initial project files
>>  3 files changed, 42 insertions(+)

$ git commit -am "Fix navbar bug"   # stage all TRACKED changes + commit, in one step
$ git commit --amend -m "Add initial project files (typo fixed)"   # rewrite the last commit

$ git log
>> commit a1b2c3d4e5f6...
>> Author: Priya Sharma <priya@example.com>
>> Date:   Wed Jul 8 10:22:04 2026
>>
>>     Add initial project files

$ git log --oneline
>> a1b2c3d Add initial project files

$ git log --oneline --graph --all
>> * a1b2c3d (HEAD -> main) Add initial project files

$ git show a1b2c3d
>> # full diff of exactly what changed in that one commit

$ touch .gitignore

# --- Python / Django ---
venv/
__pycache__/
*.pyc
.env

# --- Node / MERN ---
node_modules/
dist/
build/

# --- OS / editor ---
.DS_Store
Thumbs.db
.vscode/

Step 1 — main has three commits:

  main:            A---B---C

Step 2 — git checkout -b feature/login
  (a new pointer "feature/login" is created at C; HEAD moves to it)

  main:            A---B---C
  feature/login:            C  (HEAD)

Step 3 — two commits made while on feature/login:

  main:            A---B---C
  feature/login:            \
                              D---E  (HEAD)

Step 4 — merge feature/login back into main:

  main:            A---B---C-------F
                             \     /
  feature/login:              D---E

$ git branch
>> * main

$ git branch feature/login
>>   # creates the pointer — does NOT switch to it

$ git checkout feature/login
>> Switched to branch 'feature/login'

$ git switch feature/login
>> Switched to branch 'feature/login'   # switch = modern, safer alternative to checkout

$ git branch -m old-name new-name
>>   # rename a branch

$ git branch -d feature/login
>>   # delete — SAFE, refuses if not yet merged

$ git branch -D feature/login
>>   # force-delete, even if unmerged — use with care

$ git branch -a
>>   # list every branch, including remote-tracking ones

$ git checkout -b feature/contact-form
>> Switched to a new branch 'feature/contact-form'

$ git switch -c feature/contact-form
>> Switched to a new branch 'feature/contact-form'   # -c = create; identical result to checkout -b

$ touch contact.html
$ git add . && git commit -m "Add contact form markup"
>> [feature/contact-form 7f8e9d0] Add contact form markup

$ echo "form { border: 1px solid #ccc; }" >> style.css
$ git add . && git commit -m "Style the contact form"
>> [feature/contact-form 9a1b2c3] Style the contact form

Fast-forward (main hasn't moved since branching):

  main:            A---B---C
  feature:                   \
                               D---E

  after "git merge feature" on main:

  main:            A---B---C---D---E   (main's pointer just slides forward)

Three-way merge (main moved on too — needs a new commit):

  main:            A---B---C-------F
                             \     /
  feature:                    D---E

  F is a new "merge commit" — it has TWO parents (C and E)

$ git checkout main
>> Switched to branch 'main'

$ git merge feature/contact-form
>> Updating a1b2c3d..9a1b2c3
>> Fast-forward
>>  contact.html | 1 +
>>  style.css    | 1 +

$ git branch -d feature/contact-form
>> Deleted branch feature/contact-form (was 9a1b2c3).

Your laptop        --(git push)-->   GitHub               --(git clone)-->   Colleague's laptop
  LOCAL REPO       <--(git pull)---   REMOTE REPO                              LOCAL REPO (their own copy)

$ git remote add origin https://github.com/priya/devcard.git
>>   # links your local repo to a remote, nicknamed "origin"

$ git remote -v
>> origin  https://github.com/priya/devcard.git (fetch)
>> origin  https://github.com/priya/devcard.git (push)

$ git remote set-url origin https://github.com/priya/devcard-renamed.git
>>   # updates the URL "origin" points to, e.g. after a repo rename

$ git remote remove origin
>>   # unlinks the remote — your local history is untouched

$ git push -u origin main
>> Enumerating objects: 6, done.
>> Writing objects: 100% (6/6), 1.02 KiB | 1.02 MiB/s, done.
>> To https://github.com/priya/devcard.git
>>  * [new branch]      main -> main
>> Branch 'main' set up to track 'origin/main'.

$ git push
>>   # -u only needed ONCE — after that, plain "git push" remembers where

$ git push origin feature/login
>>   # push a specific branch explicitly

$ git pull origin main
>> Updating a1b2c3d..9f8e7d6
>> Fast-forward
>>  README.md | 3 +++
>>  1 file changed, 3 insertions(+)

$ git fetch origin
>>   # downloads new commits — does NOT touch your working files yet

$ git diff main origin/main
>>   # review exactly what the remote has that you don't

$ git merge origin/main
>>   # now bring those reviewed changes into your local main

$ git clone https://github.com/priya/devcard.git
>> Cloning into 'devcard'...
>> remote: Enumerating objects: 6, done.
>> Receiving objects: 100% (6/6), done.

$ git clone https://github.com/priya/devcard.git my-folder-name
>>   # clone into a custom folder name instead of the repo's default name

$ cd devcard
$ # install dependencies for your stack, then you're ready to work

Scenario A — you already have a local repo:

$ git remote add origin https://github.com/priya/devcard.git
$ git branch -M main
$ git push -u origin main
>> Branch 'main' set up to track 'origin/main'.

Scenario B — starting fresh from GitHub:

$ git clone https://github.com/priya/devcard.git
>> Cloning into 'devcard'...
$ cd devcard
$ # "origin" is already configured — just add files and commit

$ ssh-keygen -t ed25519 -C "you@example.com"
>> Generating public/private ed25519 key pair...

$ cat ~/.ssh/id_ed25519.pub
>> ssh-ed25519 AAAAC3NzaC1lZDI1NTE5... you@example.com

$ # paste that key into GitHub Settings -> SSH and GPG keys -> New SSH key

$ ssh -T git@github.com
>> Hi priya! You've successfully authenticated, but GitHub does not provide shell access.

$ git remote set-url origin git@github.com:priya/devcard.git

# DevCard

> A one-page developer portfolio built while learning Git & GitHub.

## Features
- Responsive layout
- Dark / light theme toggle
- Contact form

## Tech Stack
- HTML5, CSS3, JavaScript

## Getting Started
```
$ git clone https://github.com/you/devcard.git
$ cd devcard
$ # open index.html in your browser
```

## Author
Your Name — [GitHub](https://github.com/you)

$ git checkout main
$ echo 'nav background: blue;' > style.css
$ git add . && git commit -m "Blue navbar"

$ git checkout -b feature/green
$ echo 'nav background: green;' > style.css
$ git add . && git commit -m "Green navbar"

$ git checkout main
$ echo 'nav background: purple;' > style.css
$ git add . && git commit -m "Purple navbar"

$ git merge feature/green
!! Auto-merging style.css
!! CONFLICT (content): Merge conflict in style.css

<<<<<<< HEAD
nav background: purple;       (your current branch — main)
=======
nav background: green;        (incoming branch — feature/green)
>>>>>>> feature/green

$ git status
>> both modified:   style.css

$ code style.css
$ # delete the markers, keep the colour you want, save the file

$ git add style.css
$ git commit
>> [main e7f8a9b] Merge branch 'feature/green'

$ git merge --abort
>> # backs the repo out of the merge completely
>> # your files return to exactly how they were before "git merge" ran