git pull and resolve conflicts

Question

I am learning git and I have a scenario:

1. My coworker makes changes and pushes the changes to the master.
2. I make changes locally to my master.

Answer 1

I believe git sync would be good. Git sync commits your changes, pulls any changes existing in master, then pushes all the changes together to master.

Answer 2

One (simple*) way to handle this without branching or stashing:

1. stage/commit your changes locally
2. pull remote
3. at this point you'll be notified of any merge conflicts. If git cannot automatically resolve merge conflicts, it will open the two versions in whatever editor you have set up as your default merge editor. I recommend BeyondCompare.
4. commit your merge, push your merge and commits remote master

Answer 3

If you're both working on the same file(s), you'll inevitably run into conflicts. You'll just have to learn how to resolve conflicts.

If you want to avoid having to resolve conflicts, then maybe you guys should delegate tasks to each other that involve working on a different files.

Answer 4

Best way from my experience is:

1. When working on a new feature, make a new branch cloned from the master. Always keep the branches up to date with the master.
2. After writing and committing your new features to the created branch, you test your app.
3. Then merge master into the working branch, if there are new commits in the master, you may have merge-conflict. After resolving it - test again.
4. If everything is working as supposed to merge your branch to the master.

That's how you can develop many new features and merge only the working ones when you need to deploy. Good luck and check this -> https://www.codeschool.com/courses/try-git

Answer 5

If there are different changes on both the remote and the local branch, instead of just pulling the master by git pull, I rather would do:

git pull --rebase

I even have it in my default config so that it will always will do a rebase if required on git pull:

git config --global pull.rebase true

A rebase avoids a merge commit and keeps your changes on top of the current remote branch.

Yet you still have to resolve any occurring merge conflicts when different people are working on the same branch, which is a bad practice especially because it leads to conflicts.

(Also be aware that in the scope of a rebase, the meaning of theirs and ours is switched.)

In cases with minor changes, yours are just applied on the top.

You are changing the history, yet only your local one, not the remote's.

You won't need to git push --force. You just git push it as you are used to it.

In general, you should be working on feature branches and merge those back to the master branch.

When working on master branches one can also keep the feature branch close to the master by:

git checkout feature-branch
git fetch && git rebase origin/master

Yet here one would need to git push --force the feature-branch, so one should be careful not to use this strategy if more than one person is working on the same feature-branch.

If one wants to use rebase and push forcing, consider using git push --force-with-lease over git push --force as it prevents accidentally deleting other's commits on the remote.