Ours vs theirs in conflicts in Git - Trade-offs & Expert Analysis

Overview - Ours vs theirs in conflicts

What is it?

When two people change the same part of a file in Git, a conflict happens. 'Ours' and 'theirs' are ways to decide which change to keep. 'Ours' means keeping your version, and 'theirs' means keeping the other person's version. This helps fix conflicts quickly and clearly.

Why it matters

Without understanding 'ours' and 'theirs', resolving conflicts can be confusing and error-prone. This can slow down teamwork and cause mistakes in code. Knowing these terms helps teams work smoothly and avoid losing important changes.

Where it fits

You should know basic Git commands like commit, branch, and merge before learning this. After this, you can learn advanced conflict resolution tools and strategies for smoother collaboration.

Mental Model

Core Idea

'Ours' means your current branch's changes, and 'theirs' means the other branch's changes during a conflict.

Think of it like...

Imagine two friends writing on the same page of a notebook at the same time. 'Ours' is what you wrote, and 'theirs' is what your friend wrote. Choosing 'ours' keeps your words; choosing 'theirs' keeps your friend's words.

Conflict in Git Merge
┌───────────────┐
│   Base File   │
└──────┬────────┘
       │
       ▼
┌───────────────┐       ┌───────────────┐
│   Our Branch  │       │ Their Branch  │
│   (Ours)      │       │   (Theirs)    │
└──────┬────────┘       └──────┬────────┘
       │                       │
       └───────────┬───────────┘
                   ▼
             Merge Conflict
                   │
          Choose 'Ours' or 'Theirs'
                   │
          Resolved File Saved

Build-Up - 6 Steps

1

Foundation

What is a Git conflict?

Concept: Introduce the idea of a conflict when merging branches.

When you try to combine two branches in Git, sometimes both branches change the same lines in a file. Git cannot decide which change to keep and stops with a conflict. You must fix this before continuing.

Result

Git shows conflict markers in the file and stops the merge until you fix it.

Understanding conflicts is the first step to knowing why 'ours' and 'theirs' choices exist.

2

Foundation

Understanding 'ours' and 'theirs' terms

Concept: 'Ours' and 'theirs' refer to the two versions in conflict.

'Ours' means the version from the branch you currently have checked out. 'Theirs' means the version from the branch you are merging in. These labels help you decide which change to keep.

Result

You can now identify which side of the conflict is yours and which is the other person's.

Knowing these terms helps you communicate clearly when resolving conflicts.

3

Intermediate

Using 'ours' and 'theirs' in git checkout

🤔Before reading on: do you think 'git checkout --ours ' replaces the whole file or just the conflicted parts? Commit to your answer.

Concept: Learn how to pick one side's version using git checkout commands.

During a conflict, you can run 'git checkout --ours ' to keep your branch's version of the file. Or 'git checkout --theirs ' to keep the other branch's version. This replaces the conflicted file with the chosen version.

Result

The conflicted file is replaced by the chosen side's version, ready to be staged and committed.

Knowing these commands speeds up conflict resolution by letting you pick a whole side quickly.

4

Intermediate

Manual conflict markers and editing

🤔Before reading on: do you think manually editing conflict markers is safer or riskier than using 'ours'/'theirs' commands? Commit to your answer.

Concept: Understand how Git marks conflicts inside files and how to edit them manually.

Git adds markers like <<<<<<<, =======, and >>>>>>> around conflicting parts. You can open the file and choose which lines to keep or combine both. After editing, remove the markers and save the file.

Result

The conflict is resolved manually, allowing a mix of both changes if desired.

Manual editing gives fine control but requires careful attention to avoid mistakes.

5

Advanced

Using git merge strategies with ours/theirs

🤔Before reading on: does the 'ours' merge strategy keep your changes or discard them? Commit to your answer.

Concept: Learn about merge strategies that automate conflict resolution using 'ours' or 'theirs'.

Git has merge strategies like 'ours' that keep your branch's changes entirely, ignoring the other branch. You can run 'git merge -s ours ' to do this. There is no built-in 'theirs' strategy, but you can simulate it with other commands.

Result

Merge completes automatically by choosing one side's changes for all conflicts.

Knowing these strategies helps automate conflict resolution in special cases, saving time.

6

Expert

Surprises in 'ours' and 'theirs' meanings

🤔Before reading on: do you think 'ours' always means your local changes, even in rebase? Commit to your answer.

Concept: Explore how 'ours' and 'theirs' meanings change depending on Git commands like merge or rebase.

In a merge, 'ours' is your current branch, and 'theirs' is the branch being merged. But in a rebase conflict, 'ours' is the branch being rebased (the new commits), and 'theirs' is the base branch. This can confuse users and cause wrong conflict resolutions.

Result

Understanding this prevents mistakes when resolving conflicts during rebase versus merge.

Knowing context-dependent meanings avoids costly errors in complex workflows.

Under the Hood

Git stores snapshots of files for each commit. When merging, it compares the base commit, 'ours' commit, and 'theirs' commit to find differences. Conflicts happen when the same lines differ between 'ours' and 'theirs'. Git marks these conflicts in files and waits for user input to resolve them.

Why designed this way?

Git uses 'ours' and 'theirs' to give users clear control over which changes to keep. This design balances automation with manual control, allowing safe merges without losing work. Alternatives like automatic overwrites risk losing important changes.

Git Merge Conflict Flow
┌───────────────┐
│   Base Commit │
└──────┬────────┘
       │
       ▼
┌───────────────┐       ┌───────────────┐
│   Our Commit  │       │ Their Commit  │
│   (Ours)      │       │   (Theirs)    │
└──────┬────────┘       └──────┬────────┘
       │                       │
       └───────────┬───────────┘
                   ▼
          Compare Changes
                   │
          Conflict Detected?
                   │
          ┌────────┴────────┐
          │                 │
        Yes                No
          │                 │
  Mark Conflict       Auto Merge
  in Files & Stop     and Commit
  for User

Myth Busters - 4 Common Misconceptions

Quick: Does 'ours' always mean your local changes no matter the Git command? Commit to yes or no.

Common Belief: Many think 'ours' always means the local branch's changes.

Reality: In rebase conflicts, 'ours' refers to the rebased commits, not the local branch, which can be confusing.

Why it matters: Misunderstanding this causes wrong conflict resolutions during rebase, leading to lost or incorrect code.

Quick: Does 'git merge -s theirs' exist as a built-in strategy? Commit to yes or no.

Common Belief: Some believe Git has a 'theirs' merge strategy like 'ours'.

Reality: Git does not have a built-in 'theirs' merge strategy; you must use other commands to simulate it.

Why it matters: Expecting a 'theirs' strategy can waste time and cause confusion during merges.

Quick: Can you safely resolve conflicts by always choosing 'ours' without reviewing? Commit to yes or no.

Common Belief: Choosing 'ours' blindly is safe and fast.

Reality: Blindly choosing 'ours' can discard important changes from others, causing bugs or missing features.

Why it matters: Ignoring others' changes risks breaking the project and losing teamwork benefits.

Quick: Does manual editing of conflict markers always produce better results than automated commands? Commit to yes or no.

Common Belief: Manual editing is always better than using 'ours' or 'theirs' commands.

Reality: Manual editing is powerful but error-prone; sometimes automated commands are safer and faster.

Why it matters: Over-relying on manual edits can introduce syntax errors or miss conflicts.

Expert Zone

1

During rebase conflicts, 'ours' and 'theirs' swap meanings compared to merge, which can confuse even experienced users.

2

The 'ours' merge strategy ignores all changes from the other branch, which is useful for keeping your branch's history but can hide important updates.

3

Using 'git checkout --ours' or '--theirs' only replaces conflicted files, not partial hunks, so sometimes manual edits are still needed.

When NOT to use

Avoid using 'ours' or 'theirs' blindly when both sides have important changes; instead, manually merge or use specialized merge tools. Also, do not use the 'ours' merge strategy if you want to keep updates from both branches.

Production Patterns

Teams often use 'ours' and 'theirs' commands during hotfix merges to quickly keep urgent fixes. In complex rebases, they carefully check meanings to avoid mistakes. Automated CI tools sometimes run scripts to auto-resolve trivial conflicts using these options.

Connections

Conflict resolution in human communication

Both involve choosing between competing versions or opinions.

Understanding how to fairly choose or combine conflicting ideas in communication helps grasp why Git offers 'ours' and 'theirs' options.

Version control branching models

Ours/theirs decisions happen during merges in branching workflows.

Knowing branching models like Git Flow clarifies when and why conflicts arise and how to resolve them effectively.

Database transaction conflict handling

Both handle conflicts between concurrent changes to shared data.

Seeing how databases use locks or rollbacks to resolve conflicts helps understand Git's manual conflict resolution approach.

Common Pitfalls

#1 Choosing 'ours' without reviewing the other branch's changes.

Wrong approach:

git checkout --ours conflicted_file
git add conflicted_file
git commit -m "Resolved conflict by choosing ours"

Correct approach:

Review conflicted_file carefully before choosing 'ours' or manually merge changes.
Use git diff to compare versions.

Root cause:

Assuming your changes are always correct and ignoring others' contributions.

#2 Confusing 'ours' and 'theirs' meanings during rebase conflicts.

Wrong approach:

During rebase conflict, running 'git checkout --ours file' expecting local branch version.

Correct approach:

Understand that during rebase, 'ours' is the rebased commit; check carefully before resolving.

Root cause:

Not knowing that 'ours' and 'theirs' meanings depend on the Git operation context.

#3 Expecting a 'theirs' merge strategy to exist and trying to use it.

Wrong approach:

git merge -s theirs feature_branch

Correct approach:

Use 'git checkout --theirs ' on conflicts or other commands to simulate 'theirs' behavior.

Root cause:

Misunderstanding Git's available merge strategies.

Key Takeaways

'Ours' and 'theirs' help you decide which side's changes to keep during Git conflicts.

Their meanings depend on the Git command context, especially between merge and rebase.

Using 'git checkout --ours' or '--theirs' replaces conflicted files with one side's version quickly.

Manual editing of conflict markers allows fine control but requires care to avoid errors.

Blindly choosing one side can cause lost work; always review changes before resolving.