A person trying to put a fire out with gasoline

Commit often, perfect later, publish once

Why git?

Everything is local
Fast, works offline
Based on simple rules
Branching and merging is rather easy
Very flexible regarding workflows
Corrections are possible
Good documentation, lots of articles and Q&A online
Available on all platforms

Hello, git

A completely ignorant, childish person with no manners.
— Urban Dictionary

$ /dont-panic/

note to self, use the bloody command line. It works!
— Channing Walton (@channingwalton) January 20, 2012

$ git <verb>

$ git help <verb>
$ git <verb> --help

$ git init
Initialized empty Git repository in /scratch/.git/

$ echo hello, world > hello.txt

$ git add hello.txt

$ git commit --message 'my first commit!'
[master (root-commit) deadbee] my first commit!
 1 file changed, 1 insertion(+)
 create mode 100644 hello.txt

$ git show
commit deadbeef16165bb95a541321a7acf9cef9731c1d
Author: Alexander Groß <agross@therightstuff.de>
Date:   Sat Feb 6 12:41:24 2010 +0100

    my first commit!

diff --git a/hello.txt b/hello.txt
new file mode 100644
index 0000000..4b5fa63
--- /dev/null
+++ b/hello.txt
@@ -0,0 +1 @@
+hello, world

Content Lifecycle

Staging Area = Power

Take-aways

Partial operations

$ git add --patch
$ git reset HEADrestore --staged --patch
$ git checkoutrestore --patch

Temporarily ignore changes to tracked files
```
$ git update-index --[no-]skip-worktree
```
List ignored changes
```
$ git ls-files -v | grep '^h'
```

Branching

Simple history

Here are some better alternative names for the "master" branch in your source code repository:

- bleeding-edge
- nevergreen
- works-on-my-machine
- happy-merging-XD
- there-be-real-users
- features-come-here-to-die
- (L°O°)L_|_|_
— Markus Tacker 🇳🇴 (@coderbyheart) March 6, 2018

The `HEAD` pointer

Creating a branch

$ git branch topic [<where>]

(<where> defaults to HEAD)

Current branch = where `HEAD` is

$ git checkoutswitch topic

A Shortcut

$ git checkout -bswitch -c <name> [<where>]

==

$ git branch <name> [<where>] && git checkoutswitch <name>

Advancing the `topic` branch

$ git commit -am "work on topic"

Rule #1

The only branch that can change is the current branch.

Back to `master`

$ git checkoutswitch master

Rule #2

When `HEAD`'s position changes your working copy will be updated.

Uncommitted changes will be attempted to be preserved.

Advancing the `master` branch

$ git commit -am "work on master"

Detached `HEAD`

$ git checkoutswitch --detach deadbeef
Note: checking out 'deadbeef'.

You are in 'detached HEAD' state. You can look
around, make experimental changes and commit them…HEAD is now at deadbeef

You're on no branch when you checkout a SHA, tag or remote branch.

Restoring unreachable commits

$ git reflog
6bbd21d HEAD@{0}: commit (amend): JUG WIP
e7d4298 HEAD@{1}: commit: JUG WIP
71ab831 HEAD@{2}: checkout: moving from gh-pages to jug
71ab831 HEAD@{3}: commit: Support more than one fade
76cd1b0 HEAD@{4}: commit: Tabs -> spaces

$ git fsck --unreachable | grep commit
unreachable commit 60c5758f209c63e5cc2d00f4c8e3ab8fc7037609
unreachable commit 6bc882d6491597250a2baa880e19f0759e1f585b
unreachable commit 74cfdec6a9ba5b3e70c7bd1128fc3347440539b8
unreachable commit b76bb1f752afaaedc1b21d35c75c3acdce3d46e5

Making corrections

Modifying the last commit

$ git commit --amend -m 'C was bad'

Undoing recent commits

$ git reset --hard B

# Like a pro:
$ git reset --hard HEAD~

Applying a negated commit

$ git revert [--no-commit] B

Rewriting the whole graph 💣

Extracting libraries from projects

$ git filter-branch --subdirectory-filter src/lib -- --all

Ensuring no internal files are published when a project is open-sourced
```
$ git filter-branch --index-filter 'git rm secret.txt' HEAD
```
Converting Subversion repositories with svn:externals (there be 🐉)
```
$ git svn-clone-externals svn://…
```

Rewriting parts of the graph

🔜

I'll tell my story after I heard yours

$ git checkoutswitch topic
$ git rebase master

Commits C, D and E are copied on top of master as C', D' and E'.

Complex Rebase

How to get rid of C when rebasing client on master?

Complex Rebase

$ git rebase --onto master server client

A Second Variant

$ git rebase --onto B server client

$ git rebase origin/master pic.twitter.com/pAHtrPrm84
— Alejandro AR (@kinduff) January 16, 2015

git rebase -i ;) pic.twitter.com/Qy2k7Q0EQJ
— nixCraft (@nixcraft) May 7, 2017

Preparing for code review

$ git rebase --interactive A

Integration

Your options:

git merge (2 variants)
git rebase

Visualizing a "Git Merge" pic.twitter.com/RQJ2AV7JRQ
— David Rousset (@davrous) August 20, 2016

Diverged History

Recursive Merge

$ git checkoutswitch master
$ git merge topic

Recursive merge (~ ORT merge since git 2.34): Integrates two diverged branches.

Undoing The Merge

$ git reset --hard F

# Like a pro (covers recursive and ff merges):
$ git reset --hard @@{1}

Linear History

Fast-Forward Merge

$ git checkoutswitch master
$ git merge topic

Fast-forward merge: The master pointer can be moved from C to E without losing commits reachable from master.

Controlling `git merge` behavior

$ git merge --ff-only

Enforces a fast-forward merge, aborts if history is diverged.

$ git merge --no-ff

Enforces a recursive merge, even if a fast-forward merge would be possible.

Controlling `git merge` recursive strategy

$ git merge --strategy-option ours

Prefer our changes when encountering conflicts.

$ git merge -X theirs

Prefer their changes when encountering conflicts.

Squash merge 🍋

$ git merge --squash [--commit] topic

Merge HEAD's and topic's snapshot, create a new commit, but only assign HEAD as its parent.

Octopus merge 🐙

$ git merge perf css report

Integrate any number of non-conflicting branches with a single merge commit.

Cherry-pick 🍒

$ git cherry-pick [--no-commit] D

Apply a commit from somewhere else.

More options

Make obsolete's commits reachable, but keep tree as-is
(i.e. archive obsolete)
```
$ git merge --strategy=ours obsolete
```

Craft merge commit with release's tree
(i.e. no file-based merging)

$ git commit-tree release^{tree}
                  -m "Merge branch 'release'"
                  -p HEAD
                  -p release

Branching Strategies

Branches Provide Isolation

git merge if you want to keep information about integrated branches
git rebase if you do not care

OneFlow – Features

OneFlow – Releases

OneFlow – Hotfixes

git-flow

HubFlow

Gerrit

Workflows

$ git config --global alias.pfusch 'push -f'

May the 4th be with you 😁 pic.twitter.com/TnOUaGeoyU
— Jen Gentleman 🌺 (@JenMsft) May 4, 2018

Centralized

Integration Manager

Benevolent Dictator

Ad-hoc

Server (9418/tcp)

$ git daemon --base-path=. --export-all --verbose
[4242] Ready to rumble

Client

$ git clone git://host/relative/path/to/repo/.git foo
Cloning into 'foo'...

$ git remote add hans git://host/relative/path/to/repo/.git
$ git fetch hans
remote: Counting objects: 42, done.
…
From git://host/relative/path/to/repo/.git
   e3205a5..0282413  master        -> hans/master

Git Internals

Commit = Trees + Blobs

A commit object has references to tree and blob objects

Commit = Trees + Blobs

History = Linked Commits

The history is a sequence of commits objects

Pointers Everywhere

Pointers Everywhere

Pointers Everywhere

Pointers Everywhere

Delta Storage

Snapshot Storage

Advanced Topics

Throw-Away Integration Branches

Use temporary pu branches
Do not base any work off of pu

Enable “Reuse recorded resolution”

git config --global rerere.enabled true
git config --global rerere.autoUpdate true

# All branches were tested in isolation

Three features are done and work in isolation

$ git checkout -bswitch -c pu master

Create a temporary branch for proposed updates

$ for b in perf css report; do git merge $b; done

Merge topics and resolve conflicts, test all feature together

$ git reset --hard master

$ for b in css report; do git merge $b; done

The second integration attempt is successful

$ git checkoutswitch master; git merge pu; git branch -d pu

Bisecting

Attempts to find bug-introducing commits by testing a minimum set of revisions
Enters detached HEAD state while searching
After the bad commit has been found, undo it
```
git revert [--no-commit] <bad-commit>
```
Automate testing
```
git bisect run <some-script>
```
some-script can do things like cherry-picking reproductions, demo available

`v1.0` works but `v1.1` contains a regression

$ git stash push -m "whatever you're doing"

v1.0 works but commits between v1.0 and v1.1 broke something

Start looking for the bug

$ git bisect start v1.1 v1.0

Test commit `D`

$ make test # => error

Give feedback about `D`

$ git bisect bad

Test commit `B`

$ make test # => success

Give feedback about `B`

$ git bisect good

Test commit `C`

$ make test # => success

Give feedback about `C`

$ git bisect good

Culprit found!

# D is the first bad revision

Exit search

$ git bisect reset

`bisect` and `cherry-pick`

$ git checkout -bswitch -c repro v1.1 && git commit -m 'repro'

Start looking for the bug

$ git bisect start v1.1 v1.0

Apply `repro` commit

$ git cherry-pick repro

Test commit `D` + `R'`

$ make test # => error

Undo `R'`

$ git reset --hard HEAD~

Give feedback about `D`

$ git bisect bad

Repeat!

$ git cherry-pick repro

Documentation

Written by Experts

git-rebase - Forward-port local commits to the updated upstream head
— git-rebase 2.6.5 manpage

Image Credits

Git Logo by Jason Long is licensed under the Creative Commons Attribution 3.0 Unported License
Git Comic by xkcd is licensed under the Creative Commons Attribution-NonCommercial 2.5 Generic License
SVN Search Volume by GitPrime
Portrait of the Emperor Marcus Aurelius by Walters Art Museum is licensed under CC BY-SA 3.0 via Wikimedia Commons
Non-linear vs. linear history by Waldo Bronchart is licensed under MIT
git-flow by Vincent Driessen
hubflow by DataSift
Gerrit Workflow by CollabNet, Inc.
Le Petit Robert by Éditions Le Robert
Pro Git by Apress

Show a printable version of this presentation. Use your browser to print.

Commit often, perfect later, publish once

Why git?

Hello, git

Content Lifecycle

Staging Area = Power

Take-aways

Branching

Simple history

The HEAD pointer

Creating a branch

Current branch = where HEAD is

A Shortcut

Advancing the topic branch

Rule #1

The only branch that can change is the current branch.

Back to master

Rule #2

When HEAD's position changes your working copy will be updated.

Advancing the master branch

Detached HEAD

Detached HEAD

Restoring unreachable commits

Making corrections

Modifying the last commit

Undoing recent commits

Applying a negated commit

Rewriting the whole graph 💣

Rewriting parts of the graph

🔜

I'll tell my story after I heard yours

Complex Rebase

Complex Rebase

A Second Variant

Preparing for code review

Integration

Diverged History

Recursive Merge

Undoing The Merge

Linear History

Fast-Forward Merge

Controlling git merge behavior

Controlling git merge recursive strategy

Squash merge 🍋

Octopus merge 🐙

Cherry-pick 🍒

More options

Branching Strategies

Branches Provide Isolation

OneFlow – Features

OneFlow – Releases

OneFlow – Hotfixes

git-flow

HubFlow

Gerrit

Workflows

Centralized

Integration Manager

Benevolent Dictator

Ad-hoc

Git Internals

Commit = Trees + Blobs

Commit = Trees + Blobs

Commit = Trees + Blobs

History = Linked Commits

Pointers Everywhere

Pointers Everywhere

Pointers Everywhere

Pointers Everywhere

Delta Storage

Snapshot Storage

Advanced Topics

Throw-Away Integration Branches

Bisecting

v1.0 works but v1.1 contains a regression

Start looking for the bug

Test commit D

Give feedback about D

Test commit B

Give feedback about B

Test commit C

The `HEAD` pointer

Current branch = where `HEAD` is

Advancing the `topic` branch

Back to `master`

When `HEAD`'s position changes your working copy will be updated.

Advancing the `master` branch

Detached `HEAD`

Detached `HEAD`

Controlling `git merge` behavior

Controlling `git merge` recursive strategy

`v1.0` works but `v1.1` contains a regression

Test commit `D`

Give feedback about `D`

Test commit `B`

Give feedback about `B`

Test commit `C`

Give feedback about `C`

`bisect` and `cherry-pick`

Apply `repro` commit

Test commit `D` + `R'`

Undo `R'`

Give feedback about `D`