Lesson 36 of 51 ~26 min
Course progress
0%

Remotes – Push, Fetch, Pull

Master remote repositories for collaboration. Learn the differences between fetch and pull, how to push changes safely, and manage multiple remotes effectively.

Until now, we’ve lived mostly in the local world. Commits, branches, merges—all on your machine. But software rarely lives alone. Collaboration requires synchronization with remotes. In Git, remotes are references to repositories hosted elsewhere: GitHub, GitLab, Bitbucket, or even another developer’s laptop. Understanding pull, fetch, and push is how you plug your repo into the social fabric of coding.

What Is a Remote?

A remote is simply a URL shortcut pointing to another Git repository. It can be over HTTPS, SSH, or even a local path. The most common remote is origin, the default name when you clone.

Check remotes:

git remote -v

Example output:

origin  git@github.com:username/project.git (fetch)
origin  git@github.com:username/project.git (push)

Visualization:

flowchart LR
  Local[Local Repo] -->|push/pull| Origin[Remote Repo: origin]

Cloning a Remote

The first step in collaboration is cloning:

git clone git@github.com:org/project.git

This creates a local copy with origin pointing to the remote.

Fetch: Seeing What’s New

git fetch updates your local knowledge of the remote without merging anything. It pulls down commits, branches, and tags, but leaves your working directory untouched.

git fetch origin

Now you can inspect:

git log main..origin/main --oneline

This shows commits that exist on origin/main but not your local main.

Visualization:

flowchart TD
  Remote[origin/main: new commits] -->|git fetch| Local[local refs updated]

Pull: Fetch + Merge (or Rebase)

git pull is a convenience: it does fetch followed by merge (or rebase if configured).

git pull origin main

By default this merges, creating a merge commit if histories diverged. Many teams configure pulls to rebase for a linear history:

git config --global pull.rebase true

Push: Sharing Your Work

To share commits, you push:

git push origin main

This uploads commits from your local main to origin/main. If someone else pushed in the meantime, you may need to pull first.

Visualization:

flowchart LR
  LocalCommits[Local commits ahead] -->|git push| RemoteMain[origin/main updated]

Tracking Branches

When you push with -u, Git sets an upstream:

git push -u origin feature/login

Now git pull and git push without arguments will act on this branch.

Check tracking:

git branch -vv

Output shows local branches and their upstreams.

Solo Workflow Example

You code on your laptop but want backup on GitHub:

git push -u origin main

Next time, just:

git push

Your laptop and GitHub stay in sync.

Team Workflow Example

In a team, fetch is invaluable. Suppose Alice pushes changes to main. Bob fetches to see them:

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

Then Bob updates his branch:

git pull

Visualization of team sync:

flowchart TD
  Alice[Alice pushes commits] --> Origin[GitHub origin]
  Bob[Bob local repo] -->|fetch/pull| Origin

This dance of fetch, pull, and push keeps everyone in rhythm.

Remotes Beyond Origin

You can have multiple remotes. For example, upstream pointing to an open source project and origin pointing to your fork.

git remote add upstream git@github.com:org/project.git
git fetch upstream

Now you can merge or rebase changes from upstream into your fork.

Visualization:

flowchart LR
  Upstream[Upstream Repo] --> Fork[Your Fork]
  Fork --> Local[Local Repo]

Think Different Mindset

Remotes embody collaboration. Fetch is curiosity: what’s new out there? Pull is humility: let me integrate others’ work. Push is generosity: here’s my contribution. Git isn’t just data transfer—it’s philosophy. You’re not coding alone; you’re dancing in a distributed orchestra.

Remotes turn local history into shared history. Fetch to learn, pull to integrate, push to contribute. With these, you step into the collaborative flow of Git. In the next chapter, we’ll tackle conflicts and see how Git guides us through disagreements in code.