Demo: publishing a project and reviewing a pull request

Examples

Example 1: create the repository and publish main (simple)

On GitHub, create a new repository named bank-accounts, set it to Public, and leave "add a README", ".gitignore", and "license" unticked, so it starts empty. Then locally:

git status
git remote add origin https://github.com/you/bank-accounts.git
git remote -v
git push -u origin main

(Use the SSH address instead if you set up SSH.) A successful push prints something like:

branch 'main' set up to track 'origin/main'.
To https://github.com/you/bank-accounts.git
 * [new branch]      main -> main

Reload the repository page on GitHub: your files and commits are there. If you see "failed to push" or an authentication error, return to the authentication lesson. If your branch is not called main (older Git versions used another default name), check git branch and use the real name.

Example 2: add a README, publish it, and test it (practical)

Create README.md in the project root:

# Bank Accounts

Console app.

## Setup

Requires Java 21.

```bash
javac Main.java
```

## Usage

`java Mian`

(That Mian typo is deliberate: it is the change a reviewer will help you find.) Commit and push it straight to main this one time, because there is nothing to protect yet and no reviewer set up:

git add README.md
git commit -m "Add README"
git push

Now test your README as a stranger: run only its commands.

javac Main.java
java Mian

The second command fails, because the class is Main, not Mian. This is exactly the kind of mistake a README test finds. We will fix it on a branch, with a PR.

Example 3: the PR round, with a planned mistake (realistic)

Step 1: branch and fix.

git switch -c readme-fix
# correct java Mian to java Main in README.md
git commit -am "Fix run command in README"
git push -u origin readme-fix

branch 'readme-fix' set up to track 'origin/readme-fix'.
To https://github.com/you/bank-accounts.git
 * [new branch]      readme-fix -> readme-fix

Step 2: open the PR. On GitHub, open the "Compare & pull request" banner for readme-fix. Base: main. Title: "Fix run command in README". Description, with what, why, and how to check: "What: java Mian becomes java Main. Why: the command failed. How to check: follow the Setup and Usage sections in a fresh clone." Create it, and send the link to your peer.

Step 3: the review. Your peer opens Files changed, comments on a line in the diff ("Please also show what the program prints"), and submits the review as a comment or request changes. You answer by editing the file on the same branch:

# add "Expected output: Bank accounts ready" to the Usage section
git commit -am "Show expected output"
git push

   ee03114..ec7c262  readme-fix -> readme-fix

No new PR was needed: the new commit appears on the same PR page. Reply to the comment and ask your peer to review again and approve.

Step 4: the planned mistake. While waiting you are on main, you make "a tiny tweak", and you commit on main straight away, because your hands know git commit -am:

git switch main
# edit README.md
git commit -am "Quick tweak"
git status -sb

## main...origin/main [ahead 1]

ahead 1 is the alarm: main has a commit that GitHub's main lacks and that no one reviewed. There are two situations.

Not pushed yet. Save the commit on a branch, then move main back to match the remote:

git branch rescue
git reset --hard origin/main
git status -sb

HEAD is now at d583ca2 Add README
## main...origin/main

The work now lives on rescue, ready to push as a proper PR. git reset --hard discards uncommitted changes and moves the branch, so only use it after saving the commit on a branch, and only for commits you have not pushed.

Already pushed. Do not rewrite the shared history. Add a new commit that undoes the old one with git revert:

git revert --no-edit HEAD
git push

[main 1be1905] Revert "Quick tweak 2"
 1 file changed, 1 deletion(-)

The history keeps both commits, and the revert cancels the change. It is honest and safe, because nobody who pulled the earlier commit has their history changed. Both fixes show why teams protect main: with a branch protection rule requiring a PR, the accidental push would have been refused. If your own repository allows it, switch on a rule for main in the repository settings afterwards and try the mistake again: the push should be rejected. (The setting's exact menu location may change; search GitHub's documentation for "protected branches".)

Step 5: merge. Once the PR is approved, press the merge button, then update your computer:

git switch main
git pull
git branch -d readme-fix

Run the README commands one last time in a fresh clone: javac Main.java, then java Main. The output should be Bank accounts ready. In the scratch run I compiled and ran this one-line program under JDK 21, and that was the output.