Git it done! Introduction to version control with git

Slide 1

Slide 1 text

Git it done! Introduction to version control with git Mario Sánchez Prada [email protected] A Coruña. 22th of July, 2010

Slide 2

Slide 2 text

“I think Git overshadows any other achievement that Linus guy ever had. He should stop working on that hobby kernel, and put more time into Git, I think it has potential.” Eitan Isaacson Open Source developer October 21st, 2009 Git it done! GUADEC-ES 2010

Slide 3

Slide 3 text

About me Computer Science Engineer by the University of Coruña Member of the Free Software company Igalia Free Software developer (GNOME & Maemo) Git it done! GUADEC-ES 2010

Slide 4

Slide 4 text

About me Computer Science Engineer by the University of Coruña Member of the Free Software company Igalia Free Software developer (GNOME & Maemo) git user since July 2008 Git it done! GUADEC-ES 2010

Slide 5

Slide 5 text

About git Distributed Version Control System (DVCS) Initially written in C by Linus Torvalds Replacement for BitKeeper in Linux kernel development Widely used nowadays, both for new and old projects http://git-scm.com Git it done! GUADEC-ES 2010

Slide 6

Slide 6 text

Basic concepts Git it done! GUADEC-ES 2010

Slide 7

Slide 7 text

The problem Handling changes in a ﬁle, a project... Git it done! GUADEC-ES 2010

Slide 8

Slide 8 text

The problem Handling changes in a ﬁle, a project... Option 0: Do nothing (unique version) Git it done! GUADEC-ES 2010

Slide 9

Slide 9 text

Slide 10

Slide 10 text

The problem Handling changes in a ﬁle, a project... Option 0: Do nothing (unique version) Option 1: Rudimentary system (manual copies) Project Project.bckp Project-20100514.bckp Project-20100514.bckp2 Project-20100514.bckp2-final Project-20100514.bckp2-last Project-20100514.bckp2-last-final Project-???????? Option 2: “Traditional” VCS’s: CVS, Subversion... They normally require a connection to a central repository Git it done! GUADEC-ES 2010

Slide 11

Slide 11 text

Slide 12

Slide 12 text

VCS vs DVCS VCS Repository work station ... work station work station update com m it commit com m it server side client side central repository? Repository push / pull push / pull push / pull commit commit DVCS Repository commit Repository Git it done! GUADEC-ES 2010

Slide 13

Slide 13 text

VCS vs DVCS VCS Repository work station ... work station work station update com m it commit com m it server side client side central repository? Repository push / pull push / pull commit DVCS Repository commit Repository Git it done! GUADEC-ES 2010

Slide 14

Slide 14 text

Slide 15

Slide 15 text

Advantages of DVCS Full repository in the local machine: new possibilities: local history (full log), branches management, ofﬂine commits... Improve the workﬂow for collaborative work Make integration of changes from external sources easier Make handling different versions for a project easier Better separation between private and public work Implicit back-up copies Don’t need network connection for most of the operations Git it done! GUADEC-ES 2010

Slide 16

Slide 16 text

Disadvantages of DVCS More complex than VCS’s. Harder learning curve Initially cloning is slower (full repository cloning) Full clones can require more hard disk space than a single checkout of the last revision (like in SVN) Git it done! GUADEC-ES 2010

Slide 17

Slide 17 text

Subversion (VCS) vs Git (DVCS) Subversion svn commit working tree Repository svn update client side server side Requires the two client / server parts to work Git another machine git push git pull Remote repository git commit -a working tree Repository git checkout Index git add git com m it local machine Doesn't require anything else but the local machine itself Git it done! GUADEC-ES 2010

Slide 18

Slide 18 text

Subversion (VCS) vs Git (DVCS) Subversion svn commit working tree Repository svn update client side server side Requires the two client / server parts to work Git git commit -a working tree another machine git push git pull Remote repository Repository git checkout Index git add git com m it local machine Git it done! GUADEC-ES 2010

Slide 19

Slide 19 text

Typical workﬂow in git Repository HEAD HEAD~1 ... HEAD~2 Index working tree Git it done! GUADEC-ES 2010

Slide 20

Slide 20 text

Typical workflow in git Repository HEAD HEAD~1 ... HEAD~2 git diff HEAD NO CHANGES Index git diff working tree NO CHANGES git diff --cached NO CHANGES Git it done! GUADEC-ES 2010

Slide 21

Slide 21 text

Typical workflow in git Repository HEAD HEAD~1 ... HEAD~2 git diff HEAD CHANGES Index git diff working tree CHANGES git diff --cached NO CHANGES Git it done! GUADEC-ES 2010

Slide 22

Slide 22 text

Typical workﬂow in git Index git add working tree Repository HEAD HEAD~1 ... HEAD~2 Add changes to the Index (prepare commit) Git it done! GUADEC-ES 2010

Slide 23

Slide 23 text

Typical workflow in git Repository HEAD HEAD~1 ... HEAD~2 git diff HEAD CHANGES Index git diff working tree CHANGES git diff --cached NO CHANGES Git it done! GUADEC-ES 2010

Slide 24

Slide 24 text

Typical workﬂow in git Repository Index working tree git com m it NEW HEAD HEAD HEAD~1 HEAD~2 ... Git it done! GUADEC-ES 2010

Slide 25

Slide 25 text

Typical workﬂow in git Index Repository working tree HEAD HEAD~1 HEAD~2 ... HEAD~3 Git it done! GUADEC-ES 2010

Slide 26

Slide 26 text

Typical workflow in git Index git diff NO CHANGES Repository git diff HEAD working tree HEAD HEAD~1 HEAD~2 ... HEAD~3 NO CHANGES git diff --cached NO CHANGES Git it done! GUADEC-ES 2010

Slide 27

Slide 27 text

Typical workﬂow in git Index Repository working tree HEAD HEAD~1 HEAD~2 ... HEAD~3 Repository HEAD HEAD~1 ... HEAD~2 Index working tree BEFORE AFTER Git it done! GUADEC-ES 2010

Slide 28

Slide 28 text

Typical workﬂow in git - git push Index Remote repository HEAD HEAD~1 ... HEAD~2 Repository working tree HEAD HEAD~1 HEAD~2 ... HEAD~3 Git it done! GUADEC-ES 2010

Slide 29

Slide 29 text

Typical workﬂow in git - git push Index Remote repository HEAD HEAD~1 ... HEAD~2 Repository working tree HEAD HEAD~1 HEAD~2 ... HEAD~3 Remote repository Repository Index working tree HEAD HEAD~1 HEAD~2 ... HEAD~3 HEAD~1 HEAD~2 ... HEAD~3 HEAD git push Git it done! GUADEC-ES 2010

Slide 30

Slide 30 text

Typical workﬂow in git - git pull HEAD HEAD~1 ... HEAD~2 Remote repository Repository HEAD HEAD~1 HEAD~2 ... HEAD~3 Index working tree Git it done! GUADEC-ES 2010

Slide 31

Slide 31 text

Typical workﬂow in git - git pull HEAD HEAD~1 ... HEAD~2 Remote repository Repository HEAD HEAD~1 HEAD~2 ... HEAD~3 Index working tree Remote repository Repository HEAD HEAD~1 HEAD~2 ... HEAD~3 HEAD~1 HEAD~2 ... HEAD~3 HEAD git pull Index working tree Git it done! GUADEC-ES 2010

Slide 32

Slide 32 text

Typical workﬂow in git - an example $ mkdir /tmp/git $ cd /tmp/git $ git init . # Initialize repository Initialized empty Git repository in /tmp/git/.git/ $ touch A B C $ git add A B C # Add new files to Index $ git commit -m "Initial commit" # First commit! [master (root-commit) fa16ae4] Initial commit 0 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 A create mode 100644 B create mode 100644 C Git it done! GUADEC-ES 2010

Slide 33

Slide 33 text

Typical workﬂow in git - an example $ git diff --stat # Working Tree <-> Index $ git diff --stat HEAD # Working Tree <-> HEAD $ git diff --stat --cached # Index <-> HEAD <<< MAKE SOME CHANGES IN THE WORKING TREE >>> $ git diff --stat # Working Tree <-> Index A | 3 +++ C | 3 +++ 2 files changed, 3 insertions(+), 0 deletions(-) $ git diff --stat HEAD # Working Tree <-> HEAD A | 3 +++ C | 3 +++ 2 files changed, 3 insertions(+), 0 deletions(-) $ git diff --stat --cached # Index <-> HEAD Git it done! GUADEC-ES 2010

Slide 34

Slide 34 text

Typical workﬂow in git - an example $ git add A C # Move changes to Index $ git diff --stat # Working Tree <-> Index $ git diff --stat HEAD # Working Tree <-> HEAD A | 3 +++ C | 3 +++ 2 files changed, 3 insertions(+), 0 deletions(-) $ git diff --stat --cached # Index <-> HEAD A | 3 +++ C | 3 +++ 2 files changed, 3 insertions(+), 0 deletions(-) Git it done! GUADEC-ES 2010

Slide 35

Slide 35 text

Typical workﬂow in git - an example $ git commit -m "My first patch :-)" # Commit changes [master 614c4e2] My first patch :-) 2 files changed, 3 insertions(+), 0 deletions(-) $ git diff --stat # Working Tree <-> Index $ git diff --stat HEAD # Working Tree <-> HEAD $ git diff --stat --cached # Index <-> HEAD $ git show --stat HEAD # Show last commit’s stats commit 614c4e224284e2719fe040b64685b790606000a6 Author: Mario Sanchez Prada Date: Mon May 3 09:31:19 2010 +0200 My first patch :-) A | 3 +++ C | 3 +++ 2 files changed, 3 insertions(+), 0 deletions(-) Git it done! GUADEC-ES 2010

Slide 36

Slide 36 text

Typical workﬂow in git - an example $ git log # Show history up-to-date commit 614c4e224284e2719fe040b64685b790606000a6 Author: Mario Sanchez Prada Date: Mon May 3 09:31:19 2010 +0200 My first patch :-) commit fa16ae4ff64b3b968ca8991c90f123e62a6a009c Author: Mario Sanchez Prada Date: Mon May 3 09:30:11 2010 +0200 Initial commit Git it done! GUADEC-ES 2010

Slide 37

Slide 37 text

Typical workﬂow in git (wrapping up) Basic commands: git init: Initializes the repository to work with git git add: Adds changes in the Working Tree to theIndex git commit: Makes changes in the Index permanent, creating a new commit and updating the HEAD. git diff: Differences between Working Tree and Index git push: Sends local commits to a remote repository git pull: Brings commits from a remote repository Git it done! GUADEC-ES 2010

Slide 38

Slide 38 text

Typical workﬂow in git (wrapping up) Basic commands (extended version): git init: Initializes the repository to work with git git add: Adds changes in the Working Tree to theIndex git add -u: Adds all the changes to the Index git add -patch: Interactively asks which changes should go to the Index (hunk by hunk) git commit: Makes changes in the Index permanent, creating a new commit and updating the HEAD. git commit -a: git add -u && git commit git diff: Differences between Working Tree and Index git diff HEAD: Diff between Working Tree and HEAD git diff -cached: Diff between Index and HEAD git push: Sends local commits to a remote repository git pull: Brings commits from a remote repository Git it done! GUADEC-ES 2010

Slide 39

Slide 39 text

Typical workﬂow in git (wrapping up) Other (extremely useful) commands: git clone : Clones a remote repository git rm : Removes file and get the Index ready with the changes for the next commit. git mv : Renames fileA as fileB and get the Index ready with the changes. git log: Shows the full (log) from HEAD git status: Shows the status of Working Tree and Index git show : Visualizes commit commitID Git it done! GUADEC-ES 2010

Slide 40

Slide 40 text

Typical workﬂow in git (wrapping up): git status <<< RIGHT BEFORE ADDING A AND C TO INDEX WITH ’git add A C’ >>> $ git status # On branch master # Changed but not updated: # (use "git add ..." to update what will be committed) # (use "git checkout -- ..." to discard changes in working directory) # # modified: A # modified: C # no changes added to commit (use "git add" and/or "git commit -a") $ git add A $ git status # On branch master # Changes to be committed: # (use "git reset HEAD ..." to unstage) # # modified: A # # Changed but not updated: # (use "git add ..." to update what will be committed) # (use "git checkout -- ..." to discard changes in working directory) # # modified: C # Git it done! GUADEC-ES 2010

Slide 41

Slide 41 text

Typical workﬂow in git (wrapping up): git show <<< RIGHT AFTER COMMITING CHANGES WITH ’git commit’ >>> $ git show commit 614c4e224284e2719fe040b64685b790606000a6 Author: Mario Sanchez Prada Date: Mon May 3 09:31:19 2010 +0200 My first patch :-) diff --git a/A b/A index e69de29..1802a74 100644 --- a/A +++ b/A @@ -0,0 +1,3 @@ +aaa +bbb +ccc diff --git a/C b/C index e69de29..1802a74 100644 --- a/C +++ b/C @@ -0,0 +1,3 @@ +aaa +bbb +ccc Git it done! GUADEC-ES 2010

Slide 42

Slide 42 text

Comparing commands: Subversion - Git Subversion Git svnadmin create repo git init svn import filepath git add filepath git commit svn checkout URL git clone URL svn add|rm|mv file git add|rm|mv file svn diff git diff svn commit git commit -a git push svn update git pull svn status git status svn log git log svn blame file git blame file Git it done! GUADEC-ES 2010

Slide 43

Slide 43 text

Repositories and branches Git it done! GUADEC-ES 2010

Slide 44

Slide 44 text

Repositories Two types of repositories: Local repository: Local working directory under version control with git (it contains a .git/ directory) They can be “created” by either: git init: Initializes the current directory to be used with git (needed to git add and git commit) git clone : Clones a remote repository in a local directory, stablishing a link to the original one, throughout the remote repository origin. Remote repositories: Any non-local repository where we have cloned our local working directory from Can be linked with git remote add git clone automatically creates one: origin Git it done! GUADEC-ES 2010

Slide 45

Slide 45 text

Slide 46

Slide 46 text

What’s a branch? A branch is a paralell line of work which allow us to make and try out certain changes from a given point on, without altering the original line of work it was created from. Once the changes done in the branch have been proved to work well, they can be integrated in the original branch, resolving the “conﬂicts” that could have appeared since its creation. Git it done! GUADEC-ES 2010

Slide 47

Slide 47 text

Slide 48

Slide 48 text

What’s a branch? - Subversion vs Git branch-1 branch-2 trunk (master branch) Subversion ... svn copy svn merge svn copy svn merge Git it done! GUADEC-ES 2010

Slide 49

Slide 49 text

What’s a branch? - Subversion vs Git branch-1 branch-2 trunk (master branch) Subversion ... svn copy svn merge svn copy svn merge master branch-2 branch-1 Git ... git branch git branch git merge git merge Git it done! GUADEC-ES 2010

Slide 50

Slide 50 text

Branches in git Create a new branch: git branch [] Delete a branch: git branch (-d | -D) Rename a branch: git branch -m List the current branches: git branch [ -r | -a ] “Move” into a branch (check it out): git checkout [-b] Git it done! GUADEC-ES 2010

Slide 51

Slide 51 text

Branches in git - an example $ git branch * master $ git branch mybranch-1 $ git branch mybranch-2 $ git branch * master mybranch-1 mybranch-2 $ git checkout mybranch-1 Switched to branch ’mybranch-1’ $ git branch master * mybranch-1 mybranch-2 Git it done! GUADEC-ES 2010

Slide 52

Slide 52 text

Branches in git - an example $ git branch -m mybranch-1 branch-1 $ git branch -m mybranch-2 branch-2 $ git branch master * branch-1 branch-2 $ git checkout master Switched to branch ’master’ $ git branch -d branch-1 Deleted branch branch-1 (was 59f1309). $ git branch -d branch-2 Deleted branch branch-2 (was e721bce). $ git branch * master Git it done! GUADEC-ES 2010

Slide 53

Slide 53 text

Why to use branches? They are fast, convenient, and really “cheap” To try an idea out (experiment) Separate public and private work One branch per bug/feature Prepare for a new release (integration) As a temporary backup (snapshot) It’s the usual way of working with git Git it done! GUADEC-ES 2010

Slide 54

Slide 54 text

Local branches and remote branches Two types of branches: Local branches: Branches created in the local machine to work on top of them, making all the needed changes. Remote branches: Branches from a remote repository that we can link to local branches to work with them. Clariﬁcations: Both the local and the remote branches are always in our local repository (local/remote concept depends on the POV). The remote branches act as a cache of non-local branches in remote repositories (they are rsync-ed). The local branches are pushed/pulled to/from the remote repositories throughout their associated remote branches. Git it done! GUADEC-ES 2010

Slide 55

Slide 55 text

Local branches and remote branches - an example $ git branch -a * master remotes/origin/master remotes/origin/other-branch $ git branch private $ git branch other-branch origin/other-branch Branch other-branch set up to track remote branch other-branch from origin. $ git branch -a * master private other-branch remotes/origin/master remotes/origin/other-branch Git it done! GUADEC-ES 2010

Slide 56

Slide 56 text

An example of repositories and branches: epiphany Local branches $ git branch 136292 539716 602547 608980 * 611400 alex master Using branches in this example: One branch per bug One experimental branch (alex) One “main” branch (master). Remote branches $ git remote origin $ git branch -r origin/HEAD -> origin/master origin/Release043 origin/bookmarks-toolbars-changes origin/bookmarksbar-separation origin/css-fonts-branch origin/eog-menu-api origin/gnome-2-10 [...] origin/master origin/mozilla-embed-strings origin/new-completion origin/new-downloader origin/pre-gnome-2-10 origin/pre-gnome-2-14 origin/pre-gnome-2-6 origin/pre-gnome-2-8 origin/release-1-2-1 origin/webcore-branch origin/webkit origin/xulrunner Git it done! GUADEC-ES 2010

Slide 57

Slide 57 text

Updating the branches Two typical situations: Add changes in a private branch to a public branch (integrate local changes) Modify a private branch with new code from a public branch where it was created from (update) Git it done! GUADEC-ES 2010

Slide 58

Slide 58 text

Slide 59

Slide 59 text

Updating the branches Two typical situations: Add changes in a private branch to a public branch (integrate local changes) We can’t alter past history in a public branch We need “clean” changes ready to be applied on top of HEAD in the public branch Modify a private branch with new code from a public branch where it was created from (update) We can alter past history in a private branch It’s more interesting to “change the past” whenever it’s needed in order to always have “clean changes” in the branch where it was created from (it could have changed) Git it done! GUADEC-ES 2010

Slide 60

Slide 60 text

Updating branches - git merge Updating a public branch: git merge There are no changes in the public branch where the private one was created from: There are changes in the public branch where the private one was created from: Git it done! GUADEC-ES 2010

Slide 61

Slide 61 text

Updating branches - git merge Updating a public branch: git merge There are no changes in the public branch where the private one was created from: master mybranch B A D C There are changes in the public branch where the private one was created from: Git it done! GUADEC-ES 2010

Slide 62

Slide 62 text

Slide 63

Slide 63 text

Updating branches - git merge Updating a public branch: git merge There are no changes in the public branch where the private one was created from: C B A D master mybranch master mybranch B A D C There are changes in the public branch where the private one was created from: Git it done! GUADEC-ES 2010

Slide 64

Slide 64 text

Slide 65

Slide 65 text

Slide 66

Slide 66 text

Slide 67

Slide 67 text

Updating branches - git rebase Update a private branch: git rebase B A D C master mybranch Git it done! GUADEC-ES 2010

Slide 68

Slide 68 text

Updating branches - git rebase Update a private branch: git rebase E B A F D C master mybranch Git it done! GUADEC-ES 2010

Slide 69

Slide 69 text

Updating branches - git rebase Update a private branch: git rebase master mybranch E B A F D C E B A F D C master mybranch Git it done! GUADEC-ES 2010

Slide 70

Slide 70 text

Updating branches - git rebase Update a private branch: git rebase master mybranch E B A F D C E B A F D C master mybranch E B A F C* master mybranch C* = [E + F] + C Git it done! GUADEC-ES 2010

Slide 71

Slide 71 text

Updating branches - git rebase Update a private branch: git rebase master mybranch E B A F D C E B A F D C master mybranch E B A F D* C* master mybranch E B A F C* master mybranch C* = [E + F] + C D* = [E + F] + D C* = [E + F] + C Git it done! GUADEC-ES 2010

Slide 72

Slide 72 text

Updating branches One personal tip (whenever it’s possible) Before updating a public branch with git merge to do a git push later on, it’s a good idea to do a git rebase ﬁrst from the private branch, in order to avoid getting a metacommit. $ git checkout mybranch # Change to private branch $ git rebase master # Rebase private branch $ git checkout master # Change back to master $ git merge mybranch # Merge changes from mybranch $ git push # Push to remote repository Git it done! GUADEC-ES 2010

Slide 73

Slide 73 text

Other things... Git it done! GUADEC-ES 2010

Slide 74

Slide 74 text

Other interesting commands Create a tag: git tag Revert a commit (create a new commit on top of HEAD): git revert Copy a speciﬁc commit on top of HEAD: git cherry-pick Show the authors of the latest changes to a ﬁle: git blame Apply diff in the Working Tree (doesn’t create new commits): git apply Create “full” patches from a given point (commit): git format-patch Apply “full” patches (keeping the author, log message...): git am Git it done! GUADEC-ES 2010

Slide 75

Slide 75 text

For further investigation Save and restore temporary changes: git stash & git stash apply Modifying HEAD, Index and the Working Tree: git reset [ -soft | -hard ] Manually rewriting the past (commits): git rebase -i git commit -amend Automatically rewriting the past: git filter-branch Check out the history of git operations (and restore data): git reflog Send patches by mail: git send-email Integration with Subversion repositories: git svn [ options ] [ arguments ] Git it done! GUADEC-ES 2010

Slide 76

Slide 76 text

Where to go from here Git from the bottom up (Excellent tutorial): http://ftp.newartisans.com/pub/git.from. bottom.up.pdf Git User’s Manual: http://www.kernel.org/pub/software/scm/git/ docs/v1.7.1/user-manual.html Git tutorial manual page (man gittutorial): http://www.kernel.org/pub/software/scm/git/ docs/v1.7.1/gittutorial.html Everyday GIT With 20 Commands Or So: http://www.kernel.org/pub/software/scm/git/ docs/v1.7.1/everyday.html Gitorious: infrastructure for open source projects with Git: http://gitorious.org Git it done! GUADEC-ES 2010