Master Git
on Linux

$ sudo apt update
$ sudo apt install git
Reading package lists... Done
Building dependency tree... Done
git is already the newest version (1:2.43.0-1ubuntu7).

$ sudo dnf install git

$ sudo pacman -S git

$ git --version
git version 2.43.0

# Set your name and email (use same email as your GitHub account)
$ git config --global user.name "Your Name"
$ git config --global user.email "you@example.com"

# Set your preferred editor (nano is beginner-friendly)
$ git config --global core.editor nano

# Name the default branch "main" (modern standard)
$ git config --global init.defaultBranch main

# View all your settings
$ git config --list
user.name=Your Name
user.email=you@example.com
core.editor=nano
init.defaultBranch=main

# Create a new project folder and initialise Git
$ mkdir my-project
$ cd my-project
$ git init
Initialized empty Git repository in /home/user/my-project/.git/

# Check what Git sees
$ git status
On branch main
Untracked files:
  index.html
  style.css

# Stage a specific file
$ git add index.html

# Stage all changes at once
$ git add .

# See exactly what's staged vs unstaged
$ git diff --staged

# Commit with a message (keep it short and descriptive)
$ git commit -m "Add homepage and base stylesheet"
[main (root-commit) a3f1d7e] Add homepage and base stylesheet
 2 files changed, 47 insertions(+)

# Stage ALL tracked files and commit in one step
$ git commit -am "Fix typo in header"

# Full log
$ git log

# Compact one-liner view
$ git log --oneline
a3f1d7e Add homepage and base stylesheet
d92c1b5 Initial commit

# Beautiful graph view
$ git log --oneline --graph --all

# Unstage a file (keeps your changes)
$ git restore --staged index.html

# Discard changes in a file (PERMANENT — use with care)
$ git restore index.html

# Fix the last commit message (before pushing)
$ git commit --amend -m "Corrected commit message"

# Undo last commit but KEEP the changes in staging
$ git reset --soft HEAD~1

# Compiled outputs
*.o
*.pyc
__pycache__/
dist/

# Environment & secrets — NEVER commit these!
.env
*.key
*.pem

# Editor / OS clutter
.DS_Store
.vscode/
Thumbs.db

# Node / PHP dependencies
node_modules/
vendor/

# List all branches (* = current)
$ git branch
* main

# Create and switch to a new branch
$ git switch -c feature/contact-form
Switched to a new branch 'feature/contact-form'

# Switch back to main
$ git switch main

# Delete a branch (after it's merged)
$ git branch -d feature/contact-form

# Make sure you're on the target branch (e.g. main)
$ git switch main

# Merge your feature branch into main
$ git merge feature/contact-form
Merge made by the 'ort' strategy.
 contact.html | 45 +++++++++++++++++++++
 1 file changed, 45 insertions(+)

<<<<<<< HEAD
<h1>Welcome to my site</h1>
=======
<h1>Hello, world!</h1>
>>>>>>> feature/contact-form
# Edit the file to keep what you want, remove the markers, then:
$ git add index.html
$ git commit -m "Merge feature/contact-form — resolve heading conflict"

# Quickly save dirty work to switch context
$ git stash push -m "half-finished nav menu"

# List stashes
$ git stash list
stash@{0}: On main: half-finished nav menu

# Restore the most recent stash
$ git stash pop

# Generate an ED25519 SSH key (modern, secure)
$ ssh-keygen -t ed25519 -C "you@example.com"
Generating public/private ed25519 key pair.
Enter file in which to save the key (/home/user/.ssh/id_ed25519): [press Enter]
Enter passphrase (empty for no passphrase): [type a passphrase]

# Start the SSH agent
$ eval "$(ssh-agent -s)"
Agent pid 12345

# Add your key to the agent
$ ssh-add ~/.ssh/id_ed25519

# Copy your PUBLIC key to clipboard (never share the private key!)
$ cat ~/.ssh/id_ed25519.pub
ssh-ed25519 AAAAC3Nza... you@example.com

# If xclip is installed, pipe it to clipboard directly
$ cat ~/.ssh/id_ed25519.pub | xclip -selection clipboard

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

# Auto-start SSH agent
if [ -z "$SSH_AUTH_SOCK" ]; then
   eval "$(ssh-agent -s)"
   ssh-add ~/.ssh/id_ed25519
fi

# Add the GitHub repo as the "origin" remote
$ git remote add origin git@github.com:username/my-project.git

# Verify the remote was added
$ git remote -v
origin  git@github.com:username/my-project.git (fetch)
origin  git@github.com:username/my-project.git (push)

# Push and set main as the upstream tracking branch
$ git push -u origin main
Enumerating objects: 5, done.
Branch 'main' set up to track remote branch 'main' from 'origin'.
 * [new branch]      main -> main

# Clone via SSH (recommended — uses your SSH key)
$ git clone git@github.com:username/repo-name.git

# Clone to a specific folder name
$ git clone git@github.com:username/repo-name.git my-local-name

# Download remote changes WITHOUT merging
$ git fetch origin

# Download AND merge remote changes into current branch
$ git pull

# Push current branch to origin
$ git push

# Push a new branch for the first time
$ git push -u origin feature/my-feature

# 1. Make sure main is up to date
$ git switch main
$ git pull

# 2. Create a feature branch
$ git switch -c feature/add-dark-mode

# 3. Make your changes, then stage and commit
$ nano style.css
$ git add style.css
$ git commit -m "Add dark mode colour variables"

# 4. Push the feature branch to GitHub
$ git push -u origin feature/add-dark-mode

# 5. On GitHub: open a Pull Request → review → merge

# 6. Back locally, clean up after merge
$ git switch main
$ git pull
$ git branch -d feature/add-dark-mode
$ git push origin --delete feature/add-dark-mode

$ git config --global alias.st status
$ git config --global alias.co switch
$ git config --global alias.lg "log --oneline --graph --all --decorate"
$ git config --global alias.unstage "restore --staged"

# Now you can use them
$ git st
$ git lg