git checkout -b my-first-branch
```
When you commit changes on this branch, your changes will be saved separately from the common code base. This way both team members can make changes at the same time.
> Exercise: Add your name and a sentence about yourself to the `index.html` file. Then `git add` and `git commit` to commit to your personal branch.
Now you have two branches: `master` and `my-first-branch`. These branches have *diverged*, which means you have changes in one that don't appear in the other. You can check this by running `git checkout master`, then looking at your `index.html` file.
When you're done, run `git checkout my-first-branch` to go back to the branch with your changes. Git saves your changes in both branches and lets you switch between them. That's why we call it "version control". It saves different versions so you can switch between them.
Right now, your new branch only exists on your computer. Let's push it up to GitHub so you can see it in your profile.
```
git checkout my-first-branch
git push -u origin my-first-branch
```
Now both students in each pair, the "leader" and the other student, should have branches with changes. Now let's try to merge these changes together into the "leader's" master branch.
> Exercise: Browse to the "leader's" GitHub repository and open a new Pull Request. The Pull Request should ask to merge your `my-first-branch` branch into the "leader's" `master` branch. Ask a mentor for help if you have trouble figuring out how to issue a Pull Request. When both students have issued a Pull Request to the correct place, merge *one* of them but not the other.
Congrats, you've merged one student's changes with the common code base in the `master` branch. If you check the other Pull Request, you'll see you have a problem. It can't be merged automatically because there's a conflict. Why?
Conflicts emerge whenever the same file has been edited, and git can't determine what changes should be kept and what changes should be discarded. A human -- that's you -- needs to step in and sort it out. To help us, git writes into our code so we can see where it is confused. Here's an example of a merge conflict in our code:
```
<<<<<<< HEAD
+ Mozafar
+ I am a mentor at CodeYourFuture.
=======
- Daniel
- I like to ride bikes
>>>>>>> my-first-branch
```
To resolve a conflict, we decide which lines to keep and which lines to remove. When we're done, we remove the extra lines that git added (`<<<<< HEAD`, `========` and `>>>>>>>`).
Let's see how we can resolve this conflict with your branches. First we need to fetch the latest changes from the leader's `master` branch. If you're the **leader**, just do:
```
git checkout master
git pull
```
If you're the **other student**, you need to set up the remote and pull from that master:
```
git checkout master
git remote add upstream
git pull upstream master
```
Now everyone's `master` branch should include the Pull Request that was merged. Whichever student still needs to get their Pull Request merged can bring those changes into their branch like this:
```
git checkout my-first-branch
git merge master
```
You probably received a **merge conflict**.
> Exercise: Follow the steps we discussed before about how to resolve a merge conflict by editing the file. Make sure both students changes are included in the final version. When you're done, use `git add`, `git commit` and `git push` to share your changes with GitHub. If everything has gone correctly, you can now merge the Pull Request.
Now everyone can sync their changes. If you're the **leader**, just do:
```
git checkout master
git pull
```
If you're the **other student**, do this:
```
git checkout master
git pull upstream master
```
> Exercise: As a group, discuss why the `git pull` command is different for the **leader** and the **other student**.
>
> Exercise: Try to do the pull requests again, but this time switch the pull requests so that the other student must manage the merge conflict.
If you're feeling confused, don't worry. Version control is one of the most difficult things you'll learn and we'll be going over it again and again and again.
### Merging and advanced Git commands
* `git fetch` //fetch latest changes from origin and all branches (no merge)
* `git pull` //fetch latest changes from origin and all branches (with merge)
* `git merge`
Branches:
* `git branch test` //creates a new local branch
* `git checkout test` //move to branch test
* `git checkout master` //move to branch master
* `git checkout -b test` //create a new local branch and move into it
* `git push origin test` //push the branch and all commits to the server
* `git branch -d test` //remove a local branch
* `git checkout -b test origin/test`
* `git fetch --all` //to get all branches from server