The Ultimate Git Resource Hub

Welcome, First Years! Use this page during today's KUCC hands-on workshop to complete your live assignment. Bookmark it to use as a reliable reference library for your upcoming semester projects.

Repo

Today's Workshop Mission

Step 1: Fork & Star

Click the Star button on our repository to support us, then click Fork to generate a separate copy of this project directly on your GitHub profile.

Step 2: Local Clone

Open your terminal and clone down your unique forked copy to your local machine using the command below:

git clone https://github.com/YOUR-USERNAME/repo-name.git
Step 3: Modify Code

Open the folder in VS Code (`code .`). Locate the <!-- EDIT ME --> tag and append your structured profile badge block right into the list.

Step 4: Commit & PR

Stage your changes, commit them locally, and push them back out up to your remote profile. Finally, initiate a live Pull Request back to us!

Playground

Open the .html file, edit the syntax profile badge below, and push it to your fork.

Mimansh Pokhrel Neupane

Roll: 04 (CS-2nd Yr)
KUCC Exec

[Your Name]

Roll: 2 (CE-1st Yr)
Contributor

Real-World Git Command Library

Categorized reference manual for everyday local and cloud development workflows.

1. Configuration & Setup

Commands to set up your identity, start local repositories, and connect to remote servers like GitHub.

git config --global user.name "Your Name" Sets your name globally for all future commit snapshots.
git config --global user.email "you@example.com" Configures your email address associated with your Git commits.
git init Initializes a brand-new, empty Git repository in the current directory.
git clone <repo-url> Clones an existing remote repository onto your local system.
git remote add origin <repo-url> Links your local workspace to a newly created remote URL destination.
git remote set-url origin <repo-url> Changes/updates the URL destination of an existing remote target.
2. The Daily Code Pipeline

The essential everyday workflow cycle to stage, inspect, commit, and share updates.

git status Checks which files are modified, untracked, or staged.
git add <file-name> Stages a specific file ready to be committed next.
git add . Stages *all* modified, deleted, and new files in the repo.
git commit -m "feat: core tracking" Saves your staged modifications as a historical checkpoint.
git push -u origin <branch-name> Uploads local commits to a remote branch, setting upstream flags.
git pull Fetches remote adjustments and merges them automatically into your workspace.
3. Branch Management

Essential for production-level development to securely isolate feature releases and merges.

git checkout -b <branch-name> Creates a new feature branch and jumps directly into it.
git checkout <branch-name> Switches between active branches in the repository workspace.
git switch <branch-name> Modern, safer alternative to switch branches cleanly.
git branch -a Lists all local and remote branches tracked in your repository.
git merge <branch-name> Integrates history from target branch into the active branch.
git branch -d <branch-name> Safely deletes a local branch that is already merged into primary history.
4. The Git Stash (Save State)

Temporarily save local progress without committing, letting you switch context in a clean working tree.

git stash Temporarily shelves all current uncommitted adjustments to a clean slate.
git stash list Lists your historically stored stashes in descending order.
git stash pop Pulls the latest stashed files back into the working directory and clears the stash entry.
git stash apply Applies stashed modifications back into workspace but retains it inside the stash store.
5. Inspecting Project History

Browse commits, identify changes, track codebase authorship, and diagnose system changes.

git log --oneline --graph --all Displays a beautiful, scannable ASCII tree layout of all history.
git diff Shows unstaged changes between your current files and the last commit.
git diff --staged Highlights diffs between staged modifications and your last commit.
git blame <file-name> Shows authors and commit stamps for every single line inside a file.
6. The Panic Buttons (Undo)

Mistakes happen. These commands let you safely discard, revert, or overwrite faulty commits and states.

git checkout -- <file-name> Discards local uncommitted updates in a target file to match the last commit.
git restore <file-name> Modern, safer standard to revert uncommitted local modifications.
git reset HEAD <file-name> Removes a specific file from staging area, retaining physical contents.
git commit --amend -m "new message" Overwrites the latest commit description message or appends staged changes.
git reset --hard HEAD~1 Nukes the absolute latest local commit completely out of existence. Use with caution!
git revert <commit-hash> Creates a new commit reversing all changes made in specified historical commit.

Connecting Your GitHub Account

Essential initial setup steps to securely authenticate your local Git commands with GitHub.

METHOD A

SSH Key Authentication (Highly Recommended)

Secure, password-less authentication using public/private keypairs. Excellent for long-term coding.

  1. 1. Generate a new SSH Keypair:

    Open your terminal and execute the command below (press Enter to accept default storage paths):

    ssh-keygen -t ed25519 -C "your.email@example.com"
  2. 2. Copy your public SSH Key:

    Read and copy the generated public key text block to your clipboard:

    cat ~/.ssh/id_ed25519.pub
  3. 3. Add the Key to GitHub:

    Go to GitHub.com → click your Profile Photo → Settings → SSH and GPG keys → click New SSH Key → paste the copied block and save.

  4. 4. Verify the SSH Connection:

    Run this to test the handshake (type yes if prompted):

    ssh -T git@github.com
METHOD B

HTTPS with Personal Access Token (PAT)

Authenticate requests via secure API tokens. Perfect if you prefer standard HTTPS URLs.

  1. 1. Generate your Token on GitHub:

    Go to GitHub.com → Settings → Developer Settings → Personal Access Tokens → Tokens (classic).

  2. 2. Set Permissions & Scope:

    Click Generate new token (classic), set a description, choose an expiration date, check the box for repo access, and generate.

  3. 3. Copy & Secure Token:

    Copy the token immediately. Warning: GitHub will not show it again! Save it somewhere safe.

  4. 4. Authenticate in Terminal:

    The next time you execute a command (like `git push`) and Git prompts you for your GitHub Password, paste this Token instead of your normal account password.