Git Project: Learning Journal

Initialize a real journal repo with a README, ignore rules, two meaningful commits, and a status check you can explain.

Project brief

Build a personal learning journal that records durable technical understanding. The repository is local in this project: do not create a remote or publish personal notes. Every committed path should help a future reader understand the journal or add a structured entry.

Constraints that make the project meaningful

Required repository structure

learning-journal/
├── .gitignore
├── README.md
├── entries/
│   └── YYYY-MM-DD-git-foundations.md
├── templates/
│   └── entry-template.md
└── drafts/
    └── rough-notes.md       ← local and ignored

The committed tree contains .gitignore, README.md, one dated entry, and one reusable template. The drafts directory exists only in the working tree and is proven ignored.

Acceptance criteria

1. 01
   Repository root is intentional

   git rev-parse --show-toplevel resolves to learning-journal, not a parent or home directory.

2. 02
   Ignore policy is tested

   The draft matches the root /drafts/ rule, appears with !! under ignored status, and never enters the index.

3. 03
   Commit one establishes the system

   README, template, and ignore policy form one usable baseline with a message that names that outcome.

4. 04
   Commit two records learning

   One dated entry is the only new committed path, and its message describes the learning artifact.

5. 05
   Final evidence is reproducible

   Status, log, commit count, latest commit summary, and recursive tree agree with your written explanation.

Milestone 1: plan before initializing

Create a short project plan outside the future repository or on paper. Record the intended root path, public files, local-only paths, two commit purposes, and the evidence commands you will run.

Repository root: .../learning-journal

Commit 1 purpose: establish a documented journal structure
Commit 2 purpose: record one Git foundations reflection

Committed: README, .gitignore, template, dated entry
Untracked by policy: drafts/

Risk check: no live credentials or sensitive personal content

Then create the folder, enter it, print the current location, list its contents, and initialize Git on main. Your earlier init.defaultBranch configuration should choose it; if you deliberately skipped that configuration, use git init -b main. Verify both git rev-parse --show-toplevel and git branch --show-current before creating history.

Milestone 2: establish the safety boundary

Create .gitignore before broad file creation so the rule becomes part of the project’s first design:

# Unfinished local writing
/drafts/
*.tmp

# Machine-specific files
.DS_Store
Thumbs.db

Create drafts/rough-notes.md with an obviously fictional sentence, then prove the rule rather than assuming it works:

git check-ignore -v drafts/rough-notes.md
git status --short --ignored
git ls-files --error-unmatch drafts/rough-notes.md

The first command should name /drafts/. Ignored status should show the directory with !!. The final command should fail because the draft is not tracked; that failure is expected evidence.

Milestone 3: prepare the journal system

Write the README from its contract and create templates/entry-template.md with this minimum structure:

# Topic

## What I learned
Explain the idea in your own words.

## Evidence
Record a command, output, or observation that proved it.

## What is still unclear
Name one precise question, or write "Nothing yet."

## Next action
Choose one small follow-up you can complete.

Do not create the final dated entry yet. Commit one must be a reusable empty journal system, not a mixture of setup and content.

Milestone 4: create commit one

Stage exactly .gitignore, README.md, and templates/entry-template.md. Your commit subject should complete “This commit will…” and describe the system-level outcome.

git add .gitignore README.md templates/entry-template.md
git status
git diff --cached
git commit -m "Create learning journal structure"

After committing, run status. It should be clean under the normal view even though the intentionally ignored draft still exists.

Milestone 5: create commit two

Copy the template into entries/ using today’s date and a short lowercase topic. Replace every instruction with your own reflection on snapshots, the index, the first-commit workflow, or ignore rules.

Stage only the dated entry. Review status and the cached diff. A suitable subject is Record Git foundations reflection, but improve it if your entry has a more precise focus.

git add entries/YYYY-MM-DD-git-foundations.md
git status
git diff --cached
git commit -m "Record Git foundations reflection"

Milestone 6: audit the finished repository

git status
git status --short --ignored
git branch --show-current
git log --oneline --decorate
git show --stat --oneline HEAD
git ls-tree -r --name-only HEAD
git rev-list --count HEAD

Write a short audit paragraph in your own notes: name what HEAD contains, what the index proposes, what status reports, why the ignored draft is absent from the tree, and why no remote is involved.

Failure drills before submission

Choose any two drills. Predict the result, run the safe check, and explain what prevented a bad snapshot.

Submission evidence

Keep a plain-text evidence note outside the repository, or submit terminal screenshots if your learning environment requires them. Include:

• The repository root printed by Git.
• The verbose ignore match for the draft.
• Status immediately before each commit.
• The cached diff reviewed for each commit.
• The final one-line log and exact commit count.
• The recursive HEAD tree and final normal/ignored status.
• A two-sentence explanation of why the draft is not protected like an encrypted secret.

Self-assessment rubric: 20 points

Optional extension

Add a second entry only after the required audit is complete. That creates a third commit and therefore belongs outside the scored “exactly two commits” version. Before extending, save the required evidence so your assessed result remains reproducible.

Project checklist

• The Git top-level path is the intended learning-journal directory.
• The committed README, template, ignore policy, and dated entry satisfy their contracts.
• The local draft is ignored, verified, untracked, and free of sensitive content.
• Exactly two commits exist and each snapshot has one clear purpose.
• The final status, history, commit summary, and tree provide consistent evidence.
• I can explain every command used and did not rely on a remote or GitHub UI.