Intro to Git & GitHub

# Intro to Git and GitHub Note: - By show of hands. How many people have used Git and or GitHub before? - This workshop is designed for people who are new to Git and GitHub and is created in the context of Code for Greensboro's workflow

# What is Git?

### According to XKCD:

## According to git-scm.com:

> Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency.

## But what does that mean and what problem does Git solve?

### Have you ever worked on project that starts out like this?

```bash
						project
						└── my_project_2018-09-25.txt
						```

Note: Have you ever worked on a paper or a project where maybe after you finished your first draft and got some feedback and before you start working on the next draft you name the file something like `my_project_2018-09-25.txt`
						Then you start on the next draft and you repeat the process and name it like `my_project_2018-10-18.txt`
						And so on and so forth and eventually you end up with a directory that looks like this:

### And after a few iterations your project looks like this?

```bash
						project
						├── my_project_2018-09-25.txt
						├── my_project_2018-10-18.txt
						├── my_project_final.txt
						├── my_project_final_final.txt
						└── my_project_final_final_THIS_ONE.txt
						```

Note: Now imagine you and a team were working on this project and you were saving files like this and each person was making their own changes and sharing the files back and forth.

## Git provides a way to track incremental changes and share those changes with others

And, when using Git correctly it gives you the confidence to break stuff

Note: 
							In our example what would happen if two people made changes to the same file at the same time?  
							They would have to manually figure out what to keep and what to get rid of. Git can do this automatically and when it can't it provides a convient interface for doing it yourself.

## Step 1 - Clone your newly forked repo

Mac/Linux - Open terminal  
						Windows - Open Git Bash Type the following

```sh
						git clone https://github.com/YOUR_GITHUB_USERNAME/github-workshop-site.git
						# You can copy the URL from GitHub page
						cd github-workshop-site
						ls -a # List all files in the directory
						```

### "What did I just do?"

#### You cloned a repo!

Cloning is when you download a copy of a Git project to your computer

## Step 2 - Branches

## So I downloaded the project. Now what?

Note:  
						Alright, so you have the project on your machine and it's time for you to make some changes to it
					    Let's assume your team wants you to _change something on the website_. Using Git, how do we go about this?  
						there are many ways to do this with Git, but we are making the assumption that you're are working on a team. And for that assumption, this is a common workflow you would see.

### Let's make a change!

```bash
						git branch my-changes # Creates a branch called my-changes
						git branch # Shows you a list of all your local branches. Press `q` to exit
						git checkout my-changes # Switches from your current branch to the my-changes branch
						```

### "What did I Just do?"
						
						You created a branch!

Note:  
						A branch is just code that _branches_ from the another development branch.  
						A lot people use branching for something called "feature branching". This means you create a new branch for each logical group of changes.  
						For example your working on a website and your boss asks you to add the navbar.  
						You might then create a branch called `add-navbar`. This would allow you to create and push as many changes as you want without affecting the main development branch.

# Branches and Forks and Repos. Oh My!
						Note:
							We've covered several terms so far and they all sound kind of similar. So lets take a moment to recap and clarify things

### Terms

> 
						- Repo (repository) -> This is your project
						- Fork -> Creating a repo by copying another repo
						- Branches -> Groups of logical code changes (Or, groups of commits)

## An analogy

A **repo** is like a tree

**Forking** is making copy of another person's tree

**Branches** are (kind of) like real life branches

Note: 
							Maybe an analogy would make things clearer:  
							A repo is a tree.  
							When you fork someone's repo, you make an identical copy of their tree and plant it in your front yard.  
							The branches on the tree represent your Git branches. These branches stem from the trunk (typically called the `master` branch) and in Git - unlike a real tree - these branches will rejoin the `master` or another branch

## Is that any clearer?

## Let's make one more commit, and this time we are going to leave it

### Checkout master
						```bash
						git checkout master
						```

### Run 
						```bash
						# Checkout a new branch
						git checkout -b add-github-username
						```

Note: `checkout -b` is just a shorter way of creating a new branch and checking it out

Go to line 129 or so and add your Github username and a link to your profile with the listed template

Example:

```html
						<li>
							<a href="https://github.com/SchaeStewart">SchaeStewart</a>
						</li>
						```

Run

```bash
						git add index.html
						git commit -m "Add GitHub username"
						```

### Time to upload your change

```bash
						git checkout master
						git merge add-github-username
						git push origin master
						```

Note: 
							What did this do?  
							You moved back to your master branch and merged you changes with it. Then you pushed your changes to GitHub.