Git as Archiving: MySpace-Style Pages (90 min)

Agenda (90 min)

1. Context: what Git is, what it does, who uses it (10 min)
2. Install + quick sanity check (10 min)
3. Core concepts + core commands (20 min)
4. Forgejo: accounts + clone/push permissions (10 min)
5. Exercise: branch a page, publish live, iterate (35 min)
6. Wrap-up: good practices + next steps (5 min)

What is Git

• Distributed version control system
• Tracks changes over time
• Enables: - history (time) - collaboration (many authors) - experimentation (branches) - traceability (who/what/when/why)

Archiving analogy:

• commit = deposit with metadata
• log = inventory / finding aid
• branch = parallel dossier / alternative interpretation

What Git is not

• Not a backup system (though it can help)
• Not a file sync tool
• Not a CMS
• Not magic: it stores snapshots + metadata, you still choose what to record

Ecosystem

• Git = the tool + file format
• Hosting platforms: - GitHub, GitLab, Bitbucket - Forgejo / Gitea (self-hosted)

Typical workflow terms:

• remote (server copy)
• clone (get a copy)
• push (send your commits)
• pull/fetch (receive updates)

Workshop outcome

Each participant will:

• clone a repo
• create a branch
• edit a simple profile website
• commit changes with a clear message
• push branch to Forgejo
• see it appear in the live gallery

Install Git

Check first:

git --version

If missing:

• macOS: Xcode Command Line Tools
• Windows: Git for Windows
• Linux: package manager (apt/dnf/pacman)

Minimum requirement: you can run git in a terminal.

Configure identity (once)

git config --global user.name  "Your Name"
git config --global user.email "you@example.com"

Check:

git config --global --list

Core concept: three areas

1. Working tree: your files right now
2. Staging area (index): selection for the next deposit
3. Repository history: commits (deposits)

This is why Git feels "archival":

• you intentionally select what becomes part of the record.

Commands: the essential set

You listed most, but for usability we add 3:

• git status (always)
• git log (history)
• git diff (what changed)

Recommended minimal set for today:

• init, status, add, commit, branch/checkout, push, pull
• plus: log, diff

Command: git init

Create a repository in the current folder.

git init

Creates a .git/ directory containing history + metadata.

Command: git status (your dashboard)

git status

Shows:

• current branch
• staged vs unstaged changes
• untracked files

If you only remember one command: remember this.

Command: git add (selection)

Stage files for the next commit (deposit).

git add index.html
git add assets/

Stage everything (use carefully):

git add .

Command: git commit (deposit + metadata)

git commit -m "Add MySpace-style profile page"

Good commit message pattern:

• What changed
• Why it changed (reason/intent)
• Scope stays small

Command: git diff (what changed)

Unstaged changes:

git diff

Staged changes:

git diff --staged

Command: git log (inventory)

git log --oneline --decorate --graph -n 10

Gives a quick "finding aid" of deposits.

Command: git branch and git checkout

List branches:

git branch

Create a branch:

git branch people/yourname

Switch to branch:

git checkout people/yourname

Shortcut (create + switch):

git checkout -b people/yourname

Command: git push / git pull

Push your branch to the server:

git push -u origin people/yourname

Pull updates from server:

git pull

Optional: git rm

Remove a tracked file and stage the removal:

git rm old.html
git commit -m "Remove old page"

For this workshop you probably will not need it.

Forgejo: what we use today

• Forgejo hosts the central repository (remote)
• You will: - create an account - clone via HTTPS/SSH - push your branch

Rules for today:

• do NOT push to main
• create your branch under people/<slug>

Forgejo: account setup

1. Create account at: git.<your-domain>
2. Confirm you can sign in
3. Add SSH key (optional) OR use HTTPS credentials

We will provide:

• repo URL
• branch naming convention
• live gallery URL: braids.<your-domain>

Exercise overview

You will build a deliberately simple “MySpace-style” page:

• "Hi, I'm …"
• one gif
• one link
• optional: background, glitter, bad taste encouraged

Workflow loop:

clone -> branch -> edit -> status -> add -> commit -> push -> view -> iterate

Exercise: step 1 (clone)

git clone <REPO_URL>
cd <REPO_NAME>

Sanity check:

git status
git branch

Exercise: step 2 (create your branch)

Choose a slug: lowercase, no spaces. Example: people/alex.

git checkout -b people/<your-slug>

Confirm:

git status

Exercise: step 3 (edit the page)

Edit the root index.html (and optionally style.css, assets/).

Make a visible change first:

• your name
• one gif
• one link

Then check changes:

git diff
git status

Exercise: step 4 (stage + commit)

git add index.html
git commit -m "Customize profile page for <your-slug>"

If you added assets:

git add assets/
git commit -m "Add assets for <your-slug>"

Exercise: step 5 (push your branch)

git push -u origin people/<your-slug>

If prompted for credentials, use your Forgejo login method.

Exercise: step 6 (view live)

Open the gallery:

• https://braids.<your-domain>/

Find your card:

• people/<your-slug>/

Iterate:

edit -> status -> add -> commit -> push -> refresh

Common problems (fast fixes)

Wrong branch:

git branch
git checkout people/<your-slug>

Nothing staged:

git status
git add index.html

Push rejected (main protected):

• You are on main. Switch to your branch.

Auth issues:

• HTTPS: check username/token/password
• SSH: check key added to Forgejo + ssh -T

Concept recap in archiving terms

• commit = deposit (with minimal metadata)
• log = inventory / chain of custody
• diff = conservation report (what changed)
• branch = parallel dossier
• push = deposit to institutional archive (remote)

Suggested “good enough” commit messages

Bad:

• "update"
• "stuff"
• "changes"

Better:

• "Add animated gif and profile link"
• "Change background and typography"
• "Fix broken image path"
• "Refactor layout: move link block above gif"

Rule: message should still make sense in 6 months.

Optional extension (if time remains)

• Compare two branches visually (gallery view)
• Add a second commit that intentionally breaks something, then fix it with a third commit
• Show git log to narrate your work as a documented process

Wrap-up

You should now be able to:

• create a branch safely
• record changes as commits
• publish to a remote
• read history and differences

Next steps:

• merging via PRs (review workflow)
• tags/releases (archival milestones)
• basic collaboration patterns (feature branches)