GitHub Workflow,  Merge and Rebase
Tags: beginners, github, merge, rebase
Published: 2021-09-10 19:16:34

If you are just getting into coding and are working on projects, ether solo or in a group, you probably use GitHub, a platform to house your projects. Or you use it at your job and are always doing adds and commits, waiting for you superior to approve the merge. If you already know how all of that works, then you most likely won't need to read this post. I am writing this as more of a quick reference guide for us newbies... and there is a lot of additional good documentation from GitHub and lots of extra resources on the web.

There are 2 major ways to update a main/master branch in GitHub: the first is the good old `git merge`, and the second is `git rebase`. Both of these commands accomplish the same thing: they update the main/master branch with your newly written code.

This is coming from the view point that you are working on a branch that is not the main. Make sure you have the most up-to-date version of the main repository by running `git pull`. To make your own branch, you can run
```
git branch 
#this will display all of the branches in the current repo
git branch example_branch
#this will make a branch off the main if you are currently on the main branch
```

Now we need to get into the new branch we just made. We can do this with
```
git checkout example_branch
```

So you have been working on a feature for the main code file; let's talk about when you are ready to have your code reviewed and potentially merged into the main branch. First we check the status to make sure we only edited the files we were supposed to.
```
git status
```
Then we add all of our changes to the staging area to be committed by running one of the following commands:

``` 
git add .
git add -A
git add 'file name'
```
Now your code is ready for a commit. This is where we are able to leave a detailed message about what we did with our code. Here are some commit commands:
```
git commit -m "message"
git commit -am "message"
#This command will add your changes and commit them in one go
```

Then once you have your code committed, you can push your code to the origin branch with

```
git push
```

Finally it is ready to be reviewed and sent back for editing, or it can be merged into the main. If there is no more code for you to add, when your branch and the main branch are merged, you have the option to delete your branch. If you will need to use it again soon, then you can just leave it be.

To merge to 2 branches, we will want to go into the main/master branch, then run `git pull`, just in case there have been any changes (it will let you know if you are up to date, or it will automatically load the changes). Our commands can look like this:
```
#currently not on main branch

git checkout main
#now we are on the main branch

git pull
# just to double check for any changes

git merge example_branch   
#now the branch has been merged into main
```
Hopefully there are no merge conflicts, and if not, you are done! That is the easy way to do a merge and its called a "fast forward merge."

If you do get some merge conflicts you will need to resolve those conflicts before you can move on. 

 A merge is pretty self explanatory, you are combining the contents of 2 items into 1.  There are a few ways that a merge can happen, 1) you can do it strait in your terminal, 2) you can use the GitHub webpage, 3) Github also has an app for OSX that works pretty well.
![Merge Sign](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/53brudbvuzzlixtlx6bd.jpeg) 

When there are commits on the main branch that are added after you made your branch, it will prompt what is called a "merge commit," once the merge is initiated. You can leave a message and move on to write more code.

![Merge commit image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/htznp8biw1ckvwyv67y5.jpg)

A merge commit will have a lot of "~" symbols and you need to leave a message to move forward in the commit, it would look like so:
```
~
~
~
~
~
~
~
~
```
 You can hit the _escape_ key, then type _**: w q**_ which will save the commit and get you through the merge commit. Then you should double check with `git log` to make sure all the commit history looks correct to you. 

"Rebase" is a git command that will get us a similar result of adding our code to the main branch, but it works very differently. Rather than having branches come together into the main, you are basically adding your 'example_branch' onto the end of the master branch. To do this you follow all of the same steps above, but when it comes time to merge, you will instead run

```
#you will want to be in your "example_branch" when you run this command

git rebase main/master
```

![Rebase example](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/833qgimnve3370t1taxk.png)


The links below are some good resources that I found, and they go into greater detail of whats going on behind the scenes.






Resources 
[GITHUB PULL REQUEST, Branching, Merging & Team Workflow](https://www.youtube.com/watch?v=oFYyTZwMyAg)
[Git Rebase Vs. Merge](https://www.youtube.com/watch?v=7Mh259hfxJg)
[Git Cheat Sheet](https://education.github.com/git-cheat-sheet-education.pdf)