Git tutorial

I am going to assume you know the purpose of Git: it saves your code remotely and has many tools to help lots of people work on the same project in parallel.

Why is git so powerful? It allows you to control your work through short commands. All work is tracked neatly in branches and commits.

Let's go over the vocabulary first:

repository: a project being tracked by git. These are created by git init or through GitHub and other GUIs.
commit: a group of file changes. Use git commit -m"your commit message" to make a commit
branch: a list of commits. The main branch is called master but you can make as many branches as you want and they can merge back together and branch off from each other.

My recommended setup

Git Bash - nice command line environment with ssh tools (and nice colors)
GitHub Desktop - nice diff tool (works along side command line Git)

Like this picture shows, you can easily switch between these two windows to use their best functionalities for a smooth workflow.

Use the command line git commands because they are much more powerful than the GUI buttons of GitHub Desktop and they perform much faster and have fewer problems getting stuck. So, the only thing I recommend using GitHub Desktop for is the diff tool which is amazing. If you keep it open next to your command line window you can just click on the window and it will update to the branch you are on and show you all the commits and file changes.

Hopefully your branches and commits start out mostly looking like this simple one. Most of the time this person probably just worked on the master branch making commits directly there. The small feature branch was probably a short experiment that turned out to work well and was easily merged back into master. The larger feature branch might never have turned out to be something that worked well and can be left on it's own branch. The larger feature branch work can always be gotten later if it does turn out to be useful to someone.

Here I will give some general steps for how to use Git.

Commit and pull regularly. Work that has been committed somewhere is difficult to lose and you can rearrange and organize your work pretty easily later too. Sometimes it is hard to pull and merge other peoples' work often, but when you get a chance you should.
Use branches a lot because they are wonderful. They make it safe for you to experiment without messing up other peoples' work and you can have pretty much as many as you want.
Use Git like a time machine. With a single command you can go back in time easily to test old versions of your project and you can even make changes to history and correct things if you wish.

Here is my cheat-sheet of the most common and important git commands to learn like the back of your hand:

Basics of commiting your work:

git status will show you which files are modified, added, staged, and deleted. (it gives you the status of everything so use it all the time.)
git pull tries to get the latest work from the remote repository, but it won't work if you have changes that might be lost by being overwritten so either commit them or stash them first
git add <filename> will stage a file making it ready to commit. Staged files are shown in green by 'git status'
- git add -u will stage all your modified files
git commit -m"your commit message" will commit all staged files.

Basics of using branches:

git branch will list your local branches
- git branch -a will lists all branches in this repository local and remote
git checkout <branch> will switch your project to the state of branchname and you will now be working on that branch
git checkout -b <branch> will create a new branch from the current branch you are on
git merge <branch> will merge 'branch' into the branch you are currently on
git push -u origin <branch> pushes a local branch to remote

Basics of git time travel:

git log will show a log of recent commits and their SHA id numbers (optional parameters: --oneline --graph --pretty)
git checkout <SHA> (if you don't have changes) will put you back in time to that commit (you can make a new branch from here or just test the state of the project as it was back then, tip: git stash can help you save your changes quickly to do this)
git checkout <SHA> <filepath> will grab a file from commit SHA and make it the same as it was in that commit
git stash will take all your changes and save them on a special stack that you can get later
git stash list will show you all your stashes each with an id # and description (generated from a recent commit message)
git stash apply will apply the last stash you did to your current branch
- git stash apply <#> applies stash #

OK, now let's see some more advanced ones

In this more complicated example you can see the master branch at the bottom with one initial commit (black dot) of file changes. Then a new branch called sprint integration (red) was created to try out some changes to the project. 4 people then branched off of this new branch to try their own changes, most of which made their way back into master before the end of the sprint which is where red merges back into the master branch which has changes from 3 people that sprint. The blue person just took longer to merge their work into the sprint branch so their feature will not make it back into master probably until the end of the next sprint.

What if I made a commit that I don't like any more and I want to remove it?

git reset --soft HEAD~ will remove the last commit and also save your changes by just making them unstaged file changes

Google Sites

Report abuse