Remotes and Collaboration

Introduction

Git is a distributed system. Everyone has a full copy of the repository, and they exchange commits with shared copies called remotes. Knowing exactly what push, fetch and pull do saves you from many confusing moments.

Clone

git clone copies a whole repository, with its history, to your computer.

git clone https://github.com/your-name/project.git
cd project
git remote -v

git remote -v shows the remote, usually named origin, and its address.

Remote-tracking branches

Git keeps a read-only record of where each remote branch was the last time you checked, named like origin/main. Your own main branch is separate. You can compare them:

git log main..origin/main --oneline

This lists commits that are on the remote but not yet on your local main.

Fetch versus pull

• git fetch downloads new commits and updates origin/main, but does not change your files or branches. It is always safe.
• git pull is fetch followed by a merge (or a rebase) into your current branch.

A careful habit is to fetch first, look at what arrived, then merge:

git fetch
git log HEAD..origin/main --oneline
git merge origin/main

Rejected push

If someone else pushed first, your push is rejected, because your history is behind theirs:

! [rejected]        main -> main (fetch first)

Fix it by bringing in their work first, then pushing again:

git pull
git push

Never force a push on a shared branch just to make the error go away. It can erase other people's work. If you must rewrite your own branch, use git push --force-with-lease, which refuses to overwrite commits you have not seen.

Upstream and tracking

When you push a new branch the first time, set its upstream so later git push and git pull know where to go:

git push -u origin add-footer

Forks and multiple remotes

When you do not have write access to a project, fork it on GitHub, clone your fork, and add the original as a second remote named upstream:

git remote add upstream https://github.com/original-owner/project.git
git fetch upstream
git merge upstream/main

You push to origin (your fork) and open a pull request to the original.

Try it yourself

Clone a public repository. Run git remote -v, then git fetch, then look at git branch -a to see the remote-tracking branches.

Summary

• Remotes are shared copies, and origin/main records where the remote branch was last seen.
• Fetch is safe and only downloads. Pull is fetch plus a merge.
• A rejected push means you are behind. Pull first, and avoid force pushes on shared branches.