Thinking in Git

Hi

• Emily Dunham
• edunham on irc.freenode.net
• edunham@edunham.net
• no Twitter

Permanent link to these slides:

http://talks.edunham.net/openwest2015/git

Agenda

• How to look at software development

• What's Git

• How to learn it

  • Real life vs. tutorials

• Essential Git concepts & commands

• GitHub

Thinking about Software Development

• Changing files

  • Some changes manual, other changes automatic

  • Changes for different reasons

    • Add feature, fix bug, test idea
    • Sometimes have several reasons at once, want changes separate

Why version control?

Types of version control

• Formal vs. impromptu
• Scalable vs. too much work
• Centralized vs. decentralized
• Concurrent vs. locking
• Diffs/patches vs. snapshots

Goals of Distributed Version Control

• Reliability
• No SPOF
• Eliminate network dependencies

Git's buzzwords

• Decentralized
• Distributed
• Data assurance
• Porcelain vs Plumbing
• FOSS (GPLv2)

How Git sees your project

Using Git

http://www.craftychild.com/finger-painting.html

Setting Up

• Tell Git who you are:

  $ git config --global user.name "John Doe"
  $ git config --global user.email johndoe@example.com
  

• You'll need SSH keys later

  • ssh-keygen -t rsa -b 2048, or
  • ssh-keygen -t ecdsa

• Install Git (also tk and tcl if you want the GUI)

• Set preferred editor

  • export GIT_EDITOR=vim in ~/.bashrc or equivalent

• Pick a project to work on

What's a repository?

Database of snapshots of your code

$ ls .git/

Getting a repo

$ git init

$ git clone <git clone url>

# git@github.com:organization/reponame.git
# https://github.com/organization/reponame.git

Looking at a repo

$ git show
fatal: bad default revision 'HEAD'
# To be expected with nothing in the repo

$ git show
fatal: Not a git repository (or any of the
       parent directories): .git
# not in a repo

$ git log

Undo?

$ rm -rf .git

What're staged changes?

• Staging area is like backstage -- decide what changes go into your snapshot
• Files or parts of files can be added or removed

Staging changes

$ touch foo
$ git add foo

Looking at staged changes

$ touch bar
$ git status
On branch master

Initial commit

Changes to be committed:
  (use "git rm --cached <file>..."
   to unstage)
    new file:   foo
    Untracked files:
      (use "git add <file>..." to include
       in what will be committed)
        bar
$ git commit --dry-run

Undo?

• Keeping uncommitted changes

$ git rm --cached foo

• Go back to the latest committed version

$ git reset HEAD foo

Thinking about snapshots

• Represented as changes to a file plus pointers to unchanged files
• Not a diff (tracks all files)
• Not a duplicate of everything (points to unchanged files)

What's a commit?

Snapshot of changes

Includes snapshot (with pointers to unchanged files), author, date, committer (can differ from author), parent commit

Making a commit

$ git commit

$ man git-commit
-a, --all
-i, --interactive
--reset-author
--date=<date> (see DATE FORMATS in man page)
--allow-empty
--amend
-o, --only
-S, --gpg-sign

Looking at commits

# details on latest or specified
$ git show

# Summary of recent, or a range
$ git log

$ man gitrevisions # ranges

What about commits per file?

$ git blame <file>

Commit display options

$ git show

$ git show --oneline

# see PRETTY FORMATS section of
$ man git-show

# Check the GPG signature
$ git show --show-signature

# Want a GUI?
$ gitk

Undo?

# just one file
$ git checkout <commit> <filename>
$ git add <filename>
$ git commit -m "i put that file back how it was"

Or undo the whole commit

$ git revert <commit to revert to>

What's a remote?

Another clone of more or less the same repo

(remember when we cloned to get a copy?)

Adding a Remote

$ man git-remote

$ git remote add <name> <url>

Looking at Remotes

$ git config -e

# OR

$ git remote show <name>

From one of my git configs...

[remote "origin"]
  url = git@github.com:monte-language/monte.git
  fetch = +refs/heads/*:refs/remotes/origin/*
[remote "ed"]
  url = git@github.com:edunham/monte.git
  fetch = +refs/heads/*:refs/remotes/ed/*

Undo?

Do you prefer text editor...

$ git config -e
# delete or change remote

... or commands?

$ man git-remote
$ git remote rename <old> <new>
$ git remote remove <name>

What's a tag?

• Marker attached to a specific commit
• Typically used for version or release number

Adding a Tag

$ man git-tag
$ git tag -m <msg> <tagname>

Default is lightweight tag -- just a reference for SHA-1 of latest commit

Pass -s or -u <key-id> to GPG-sign

Looking at Tags

# List all available tags
$ git tag

# List tags matching regex
$ git tag -l 'regex'

# I want this version!
$ git checkout <tag name>

Undo?

$ git tag -d <tagname>

# And remove it from a remote repo
$ git push origin :refs/tags/<tagname>

What's a branch?

A parallel path of development, starting from a commit that's in the tree

Making a branch

# track remote branch by default if one matches
$ git checkout -b <branchname>

# Shorthand for:
$ git branch <branchname>   # create
$ git checkout <branchname> # check out

# Pushing a branch to a remote
$ git push <remotename> <branchname>

Looking at branches

$ git branch

$ git show <branchname>

Undo?

# delete only if fully merged
$ git branch -d

# Delete, I Don't care what I lose
$ git branch -D

# delete remote branch
$ git push <remotename> :<branchname>

What's a merge?

• Converges the divergent branches
• One branch gets updated, one branch stays unchanged

Making a Merge

# Branch you're changing
$ git checkout mywork

$ git merge master

# Merge conflicts?
$ git status
    On branch mywork
    You have unmerged paths.
      (fix conflicts and run "git commit")

Merge Conflicts

<<<<<<< HEAD
This content was in mywork but not master
=======
This content was in master but not mywork
>>>>>>> master

Replace all that stuff with what the content should be.

git add the file.

Check that you've got everything with git status, then commit.

Or consider git mergetool for an interactive option.

Looking at Merges

$ git diff <commit before> <merge commit>

# before merging, see changes
$ git log ..otherbranch
$ git diff ...otherbranch
$ gitk ...otherbranch

Undo?

$ git merge abort
$ git reset --keep HEAD@{1}

What's a rebase?

Changing history. Means others will have to force pull.

Rebasing

$ git rebase -i <commit range>
                HEAD~4
                # last 4 commits

# Oops I forgot to pull
$ git pull --rebase

Looking at the rebase

# Rebase 1a20f51..147c812 onto 1a20f51
#
# Commands:
#  p, pick = use commit
#  r, reword = use commit, but edit the commit message
#  e, edit = use commit, but stop for amending
#  s, squash = use commit, but meld into previous commit
#  f, fixup = like "squash", but discard this commit's log message
#  x, exec = run command (the rest of the line) using shell
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.

Undo?

I should never have done that

$ git reset --hard ORIG_HEAD

I'm stuck in a broken rebase, get me out

$ git rebase --abort

GitHub Stuff

Not Exactly Git

• Less distributed paradigm
• Git never told us who to trust
• Git doesn't care who you are

Watch Linus's talk for more detail

HTTP vs SSH Clones

Permission denied (publickey).
fatal: Could not read from remote
repository.

Please make sure you have the
correct access rights and the
repository exists.

HTTP clone prompts for username and password

SSH clone uses key from your account

Forking

• Parallel repos (or possibly divergent)
• Act like the "center" of the centralized VCS

Pull Requests

• Formalizes "Hi, please merge my changes"

Annoying Tricks

• Branches keep adding their content to PRs
• Group management and access rights
• No project license required

Extra Features

• Wiki
• Gist
• Issue trackers
• Cool graphs
• Repo descriptions and automatic README display

Continuous Integration

Playing Well With Others

• Change history locally, never globally

  • Never force push (unless you have to)

• Focused commits with clear commit messages

• Follow project standards for branching, tagging, etc.

Questions?

• Emily Dunham
• edunham on irc.freenode.net
• edunham@edunham.net
• no Twitter

Go to Ben Loveridge's talk at 9am Saturday: Git with the flow: maintainable branch strategies using Git[Hub] Flow

Permanent link to these slides:

http://talks.edunham.net/openwest2015/git

Other Stuff

checkout

$ git checkout branch

point HEAD at the tip of the specified branch

$ git checkout <revision> file

gitrevisions

$ man gitrevisions

• Commit hash

• Refname

  • HEAD^n is nth parent of tip of current branch
  • branchname~n is nth generation ancestor of that branch

• Regex on commit message * :/broken

• revision:path

git bisect

Binary Search:

git bisect start
git bisect bad <commit>
git bisect good <commit>
git bisect next
git bisect reset <commit>

git cherry-pick

http://pixabay.com/en/cherry-sweet-cherry-red-fruit-167341/

$ git checkout <branch that needs special commit>
$ git cherry-pick <special commit from another branch>