Scenario
You were working on the dev branch.
While you were making commits locally, someone (or you) also made changes directly to the main branch on GitHub.
As a result, both branches moved forward independently.
What Happened?
Initial State
A (common commit)
│
├── main
└── dev
Both branches point to the same commit.
Changes Added to Main
A ── B ── C (main)
│
└─────────── (dev)
Example:
- B = README update
- C = CodeQL update
Changes Added to Dev
A ── B ── C (main)
│
└── D ── E ── F (dev)
Example:
- D = Base crawler
- E = Class-based crawler
- F = Concurrency implementation
Now both branches contain unique commits.
This situation is called:
Branches have diverged.
Why git pull main Did Not Work
Many developers think:
git pull main
means:
"Pull changes from main branch"
But Git interprets it differently.
main is only a local branch name.
Git expects:
git pull <remote> <branch>
Example:
git pull origin main
Where:
-
origin= GitHub repository -
main= branch on GitHub
Correct Way to Update Dev
While on the dev branch:
git fetch origin
git merge origin/main
What Does git fetch Do?
git fetch origin
Downloads the latest information from GitHub.
Before fetch:
Local Git:
main -> C
GitHub:
main -> G
After fetch:
main -> C
origin/main -> G
Git now knows about the latest remote commits.
No files are changed yet.
What Does git merge origin/main Do?
git merge origin/main
Git combines:
dev
+
latest main
Before merge:
A ── B ── C (origin/main)
│
└── D ── E ── F (dev)
After merge:
A ── B ── C
│ \
│ M (dev)
│ /
└── D ── E ── F
M = Merge Commit
Now dev contains:
- All main changes
- All dev changes
If Merge Conflicts Occur
Git may stop and show:
CONFLICT
Example:
Both branches modified:
README.md
Git cannot decide which version to keep.
You must manually fix the file.
After fixing:
git add .
git commit
Git creates the merge commit.
Push Updated Dev
git push origin dev
Now GitHub receives the merged version.
main -> C
dev -> M
Create Pull Request
dev ---> main
GitHub PR contains:
- README updates
- CodeQL updates
- Crawler changes
- Concurrency changes
Everything together.
Alternative Workflow
You may also update your local main first.
git checkout main
git pull origin main
git checkout dev
git merge main
git push origin dev
Result:
latest main
+
latest dev
=
updated dev
Simple Mental Model
Think of branches as two roads.
main road
B ── C
/
A
\
D ── E ── F
dev road
Both roads started from the same place.
Before creating a Pull Request, connect the roads:
B ── C
/ \
A M
\ /
D ── E ── F
Now everything is connected.
Safe Workflow Summary
git checkout dev
git fetch origin
git merge origin/main
# fix conflicts if needed
git add .
git commit
git push origin dev
Create PR:
dev → main
This is the safest and most common workflow when main and dev have diverged.
Top comments (0)