think git

What is git?

If you've ever worked on a paper using Word, you've probably created a verison control system that works for you by saving a file with different "version" tags. The reason someone might do this is because they like having a backup of all their past changes. If someone wants to delete a paragraph, you keep a copy of the old version just in case And when you are collaborating with someone, this becomes more challenging. Tracking changes and merging content added by different people is time consuming. As you can imagine, this presents a problem in software development. It is likely that multiple people will work on the same file sometimes even at the same time. Even small software projects can have tens of files in multiple folders. Additionally, developers frequently experiment with features and this should never affect the "master" copy of the project

Link

git is a supplement to your workflow

Workflow

Edit files

$EDITOR

Save changes

git commit

Before we talk about git, let's talk about workflow. This is a simple example of a workflow. You edit a file and you save the file. SPC. Once you reach what you consider a stable state, you can save the file as a different name as backup, or save it on dropbox or however you usually implement a version control system When you use git however, you don't have to save a different version of the file. When you are ready to save the current version of the file as a backup, you do that in git by taking a snapshot of the current state. You can take a "snapshot" of the current state of a file by using a command called git commit. What really happens is that when you can create a "snapshot", it records the current state of all the files in the directory being tracked.

`git commit`

So what does a snapshot look like? Let's assume that a snapshot looks like this circle over here. As I mentioned earlier, a snapshot contains the current state of the file or directory. When git creates a snapshot, it also creates a number and attaches that number to it. git uses an algorithm to calculate this number and this number is unique, it is very unlikely that two such numbers will be the same Every snapshot / commit you create will have its own number attached to it. And this number is called a HASH. You can typically you can use the first 6 or 7 characters to uniquely identify a snapshot in your project. Let's say you have created this first commit, and now you make more changes to the file. and want to save them. When you make changes to your files, and save them using git commit, git creates a new snapshot with a new HASH. git also does a few other things. 1) It allows you to create a message that goes along with that commit. A commit has to have a message! 2) When a new commit is created, it saves a reference to the parent commit. A snapshot can have multiple parents - i.e. you can take changes from two commits and merge them into one. The current commit HASH number depends on the path, i.e. it depends on what the parent is. If you change the parent hash i.e. change the content in the parent, every commit hash after that will be different. 3) Whatever commit represents the current project state, git stores a reference to that current commit in the label HEAD In the word document VCS, we created multiple versions but we did not track how we got to each state. git allows us to do that by storing all this information You may be wondering, where does git store all this - we will get to that. This, as you can imagine, forms a graph.

What's your story

and like with any graph, you can choose to tell a story. In this case, we want to work on a feature of a software, and while working on it we get a new idea. You can go back to a previous state of the project, and branch off to work on a new idea - not affecting your current work. And, when you are ready, you can pull these changes back to your master branch You can go back and review individual changes made in any commit. You can even undo changes, apply these changes to different state of your project. You could also discard a branch entirely, or switch between branches. Branches are awesome, and we'll talk more able branches a little later. The point here is that this graph exists. This graph is the documentation of how your project came to be, i.e. the history of your project is a graph that you can traverse at will.

Big idea #1

git history is a graph

git functions


git help --all
usage: git [--version] [--help] [-C ] [-c name=value]
           [--exec-path[=]] [--html-path] [--man-path] [--info-path]
           [-p|--paginate|--no-pager] [--no-replace-objects] [--bare]
           [--git-dir=] [--work-tree=] [--namespace=]
            []

available git commands in '/Applications/Xcode.app/Contents/Developer/usr/libexec/git-core'

  add                       clone                     fast-import               interpret-trailers        notes                     remote-testsvn            submodule
  add--interactive          column                    fetch                     log                       p4                        repack                    subtree
  am                        commit                    fetch-pack                ls-files                  pack-objects              replace                   svn
  annotate                  commit-tree               filter-branch             ls-remote                 pack-redundant            request-pull              symbolic-ref
  apply                     config                    fmt-merge-msg             ls-tree                   pack-refs                 rerere                    tag
  archimport                count-objects             for-each-ref              mailinfo                  patch-id                  reset                     unpack-file
  archive                   credential                format-patch              mailsplit                 prune                     rev-list                  unpack-objects
  bisect                    credential-cache          fsck                      merge                     prune-packed              rev-parse                 update-index
  bisect--helper            credential-cache--daemon  fsck-objects              merge-base                pull                      revert                    update-ref
  blame                     credential-osxkeychain    gc                        merge-file                push                      rm                        update-server-info
  branch                    credential-store          get-tar-commit-id         merge-index               quiltimport               send-email                upload-archive
  bundle                    cvsexportcommit           grep                      merge-octopus             read-tree                 send-pack                 upload-pack
  cat-file                  cvsimport                 gui--askpass              merge-one-file            rebase                    sh-i18n--envsubst         var
  check-attr                cvsserver                 hash-object               merge-ours                receive-pack              shell                     verify-commit
  check-ignore              daemon                    help                      merge-recursive           reflog                    shortlog                  verify-pack
  check-mailmap             describe                  http-backend              merge-resolve             relink                    show                      verify-tag
  check-ref-format          diff                      http-fetch                merge-subtree             remote                    show-branch               web--browse
  checkout                  diff-files                http-push                 merge-tree                remote-ext                show-index                whatchanged
  checkout-index            diff-index                imap-send                 mergetool                 remote-fd                 show-ref                  write-tree
  cherry                    diff-tree                 index-pack                mktag                     remote-ftp                stage
  cherry-pick               difftool                  init                      mktree                    remote-ftps               stash
  citool                    difftool--helper          init-db                   mv                        remote-http               status
  clean                     fast-export               instaweb                  name-rev                  remote-https              stripspace

git commands available from elsewhere on your $PATH

  loglive

'git help -a' and 'git help -g' list available subcommands and some
concept guides. See 'git help ' or 'git help '
to read about a specific subcommand or concept.

So we know that git history is a graph, right? And This graph that we created has to be stored somewhere, right? This graph is stored in a .git folder Every folder on your computer that has a .git folder is git repository. There is only one such .git folder in a git repo. all git commit does, is add content to that .git folder. and git commit is only just one function that git provides what if you wanted to do more, like manipulate an existing snapshot, delete a set of changes, reorder your history. git offers you other tools to do that. git is essentially a toolkit that contains a bunch of functions that help organize snapshots of content. This is a list of all the functions available to you. Note - git is not github. what is github? github stores git repository in the internet and that's basically all it does So, as I was saying this is the list of functions


git help --all
usage: git [--version] [--help] [-C ] [-c name=value]
           [--exec-path[=]] [--html-path] [--man-path] [--info-path]
           [-p|--paginate|--no-pager] [--no-replace-objects] [--bare]
           [--git-dir=] [--work-tree=] [--namespace=]
            []

available git commands in '/Applications/Xcode.app/Contents/Developer/usr/libexec/git-core'

  add                       clone                                                                                                                             submodule
  add--interactive                                    fetch                     log
  am                        commit
  annotate
  apply                                                                                                                                                       tag
                                                                                                                                    reset
  archive                                             format-patch
  bisect                                                                        merge
  bisect--helper                                                                                          pull                      revert
  blame                                               gc                                                  push                      rm
  branch
                                                      grep
                                                      gui--askpass                                        rebase

                            daemon                    help                                                reflog

                            diff                                                                          remote
  checkout


  cherry-pick                                         init                                                                          stash
                                                                                mv                                                  status
  clean                                               instaweb

git commands available from elsewhere on your $PATH

  loglive

'git help -a' and 'git help -g' list available subcommands and some
concept guides. See 'git help ' or 'git help '
to read about a specific subcommand or concept.

Workflow

git init

Edit files

$EDITOR

Group changes

git add

Review changes

git status

Save changes

git commit

Let's talk about our workflow again. To actually use git we need to add a couple of steps to the workflow we talked about earlier. We group changes before committing them. And we do this using the git add command. if we open a folder and try to "git add" a file, git will throw us an error. it doesn't know where to add the file to. We need to create a .git folder first and we do that using git init. You only need to do this once for a project, at the every beginning. If a project is already using git, then that .git folder exists and you can run any git command. the git add command, adds the content you specify to a "staging area" You can add multiple files at the same time to the staging area And then, when you call the git commit function, git takes everything that is in the staging area and pushes it into a new snapshot Think of the content in the staging area as the changes you would like your next snapshot to represent SPC Before you commit these changes to a new snapshot, you might want to review your changes. SPC git status is used to review your changes, SPC And to actually save this snapshot you can use git commit

git operations
Link

demo

.git folder is the database of key value pairs that track your project history. You can start a git repository by typing `git init`. When you add a file, git runs a SHA1 hash on the file which returns a hash. This hash is stored in a tree object and a commit object. If you create a file on your machine called `readme` and write `# farm` in it, and `git add` it to an empty repo, you should get the following folder in your .git repo ├── b8 │ └── fa28116ec360ae79b59da237ca991ab31a696e Computes the hash of the file. Stores the contents of the README file using the hash of the file to name the file. Adds a reference to the README file to the git index because git only cares about content. git uses content as a heuristic to find if a file has been renamed. if too much of the content has been changed between two commits when a rename occured, git will think it is a different file. and you can manually set this heuristic, I believe the default is 50%. When you git commit the staged file, git creates a blob and a tree. git does calculate a diff though, only when it needs to push. Again, this can be set manually. You can say - take longer than you usually do, but make me the smallest patch you can.

commit structure
Link

demo

Big idea #2

Difference between Head, Index and Working directory
Link

Branches

`git branch master`

`git checkout -b feature`

`git checkout master`

`git merge master`

Big idea #3

branches are just labels

Merge Conflict

demo

Best Mergetools

Link

Changing history

`git rebase master`

demo

Big idea #4

Local commits are yours to do with what you like

Remote

git operations
Link

`git pull = git fetch + git merge`

demo

Big idea #5

Remote is special branch, but a branch nonetheless

Review of big ideas

Difference between working directory, staging area and .git repository

Branches are just labels

Remote is a branch too

Local history is whatever you make it

Best practices

Commit often

Branches are inexpensive

Push to master only if tests pass

Write good commit messages!

Discuss workflow with team

Less of this and more of this

git-history

Source code for this presentation

Additional slides

Advantages of git

Free
Fast
Secure
Supports multiple non linear workflows
Easy to learn

Free as in [beer, speech]

git-scm
Link

Small

The Mozilla project's CVS repository is about 3 GB; it's about 12 GB in Subversion's fsfs format. In Git it's around 300 MB.

Fast

Link

Distributed non linear workflows

Subversion-Style Workflow Workflow A
Link

Distributed non linear workflows

Integration Manager Workflow Workflow B
Link

Distributed non linear workflows

Dictator and Lieutenants Workflow Workflow C
Link

git is not GitHub
git is not Dropbox
git is not svn

CVS

Git

A brief history of Git

git is British English slang for "unpleasant person".

- Linus Torvalds likes to name projects after himself

The Parable by Tom Preston-Werner (Founder of GitHub)
The Git Parable
Link

git blame README git readme
Link

Article on Git in 2005
Link

think git

What is git?

git is a supplement to your workflow

Workflow

git commit

What's your story

Big idea #1

git functions

Workflow

demo

demo

Big idea #2

Branches

git branch master

git checkout -b feature

git checkout master

git merge master

Big idea #3

Merge Conflict

demo

Best Mergetools

Changing history

git rebase master

demo

demo

Big idea #4

Remote

git pull = git fetch + git merge

demo

Big idea #5

Review of big ideas

git history is a graph

Difference between working directory, staging area and .git repository

Branches are just labels

Remote is a branch too

Local history is whatever you make it

Best practices

Commit related changes

Commit often

Branches are inexpensive

Push to master only if tests pass

Write good commit messages!

Discuss workflow with team

Less of this and more of this

Source code for this presentation

Additional slides

Advantages of git

Free as in [beer, speech]

Small

Fast

Distributed non linear workflows

Distributed non linear workflows

Distributed non linear workflows

CVS

Git

A brief history of Git

`git commit`

`git branch master`

`git checkout -b feature`

`git checkout master`

`git merge master`

`git rebase master`

`git pull = git fetch + git merge`