Your SlideShare is downloading. ×
Version control with Git
Upcoming SlideShare
Loading in...5

Thanks for flagging this SlideShare!

Oops! An error has occurred.


Saving this for later?

Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime - even offline.

Text the download link to your phone

Standard text messaging rates apply

Version control with Git


Published on

Version control with Git

Version control with Git

Published in: Technology

1 Like
  • Be the first to comment

No Downloads
Total Views
On Slideshare
From Embeds
Number of Embeds
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

No notes for slide


  • 1. Version ControlProposal with GitAug - 2012cm@paybook.meThursday, August 9, 12
  • 2. DistributedVersion Control SystemsIn a DVCS (such as Git, Mercurial, Bazaar or Darcs), clients don’t justcheck out the latest snapshot of the files: they fully mirror therepository.Thus if any server dies, and these systems were collaboratingvia it, any of the client repositories can be copied back up to the serverto restore it. Every checkout is really a full backup of all the data.Thursday, August 9, 12
  • 3. Git Basics• Snapshots, Not DifferencesThe major difference between Git and any otherVCS (Subversion and friendsincluded) is the way Git thinks about its data. Conceptually, most other systemsstore information as a list of file-based changes.These systems (CVS,Subversion, Perforce, Bazaar, and so on) think of the information they keep as aset of files and the changes made to each file over time, as illustratedThursday, August 9, 12
  • 4. Git Basics• Snapshots, Not DifferencesGit doesn’t think of or store its data this way. Instead, Git thinks of its datamore like a set of snapshots of a mini filesystem. Every time you commit, orsave the state of your project in Git, it basically takes a picture of what all yourfiles look like at that moment and stores a reference to that snapshot.To beefficient, if files have not changed, Git doesn’t store the file again—just a link tothe previous identical file it has already stored. Git thinks about its data morelikeThursday, August 9, 12
  • 5. Git Basics• Nearly Every Operation Is LocalMost operations in Git only need local files and resources to operate —generally no information is needed from another computer on your network. Ifyou’re used to a CVCS (CentralizedVersion Control System) where mostoperations have that network latency overhead, this aspect of Git will makeyou think that the gods of speed have blessed Git with unworldly powers.Because you have the entire history of the project right there on your localdisk, most operations seem almost instantaneous.Thursday, August 9, 12
  • 6. Git Basics• Git Has IntegrityEverything in Git is check-summed before it is stored and is then referred toby that checksum.This means it’s impossible to change the contents of any fileor directory without Git knowing about it.This functionality is built into Git atthe lowest levels and is integral to its philosophy.You can’t lose information intransit or get file corruption without Git being able to detect it.The mechanism that Git uses for this checksumming is called a SHA-1 hash.This is a 40-character string composed of hexadecimal characters (0–9 and a–f) and calculated based on the contents of a file or directory structure in Git.ASHA-1 hash looks something like this:24b9da6552252987aa493b52f8696cd6d3b00373Thursday, August 9, 12
  • 7. Git Basics• The Three StatesGit has three main states that your filescan reside in: committed, modified, andstaged. Committed means that the datais safely stored in your local database.Modified means that you have changedthe file but have not committed it toyour database yet. Staged means thatyou have marked a modified file in itscurrent version to go into your nextcommit snapshot.This leads us to the three main sectionsof a Git project: the Git directory, theworking directory, and the staging area.Thursday, August 9, 12
  • 8. Git Basics• The Three StatesThe Git directory is where Git stores the metadata and object database for your project.This is themost important part of Git, and it is what is copied when you clone a repository from anothercomputer.The working directory is a single checkout of one version of the project.These files are pulled out ofthe compressed database in the Git directory and placed on disk for you to use or modify.The staging area is a simple file, generally contained in your Git directory, that stores informationabout what will go into your next commit. It’s sometimes referred to as the index, but it’s becomingstandard to refer to it as the staging area.The basic Git workflow goes something like this:1. You modify files in your working directory.2. You stage the files, adding snapshots of them to your staging area.3. You do a commit, which takes the files as they are in the staging area and stores that snapshotpermanently to your Git directory.Thursday, August 9, 12
  • 9. Installing Git• Linux• Debian / Ubuntu: apt-get install git-core• Fedora: yum install git-core• Mac• Win, August 9, 12
  • 10. Setting up GitYour Identity$ git config --global "John Doe"$ git config --global johndoe@example.comCheckingYour Settings$ git config, August 9, 12
  • 11. RepositoryInitializing a Repository in an ExistingDirectoryIf you’re starting to track an existing project in Git,you need to go to the project’s directory and type$ git initThis creates a new subdirectory named .git thatcontains all of your necessary repository files a Gitrepository skeleton.At this point, nothing in yourproject is tracked yet.Thursday, August 9, 12
  • 12. RepositoryChecking the Status ofYour FilesThe main tool you use to determine which files are inwhich state is the git status command. If you run thiscommand directly after a clone, you should seesomething like this:$ git status# On branch masternothing to commit (working directory clean)This means you have a clean working directoryThursday, August 9, 12
  • 13. RepositoryChecking the Status ofYour FilesLet’s say you add a new file to your project, a simple README file. If the filedidn’t exist before, and you run git status, you see your untracked file like so:$ vim README$ git status# On branch master# Untracked files:# (use "git add <file>..." to include in what will be committed)## READMEnothing added to commit but untracked files present (use "git add" to track)Thursday, August 9, 12
  • 14. RepositoryTracking New FilesIn order to begin tracking a new file, you use the command git add.To begintracking the README file, you can run this:$ git add READMEIf you run your status command again, you can see that your README file is nowtracked and staged:$ git status# On branch master# Changes to be committed:# (use "git reset HEAD <file>..." to unstage)## new file: README#Thursday, August 9, 12
  • 15. RepositoryStaging Modified FilesLet’s change a file that was already tracked. If you change a previously tracked file calledbenchmarks.rb and then run your status command again, you get something that looks like this:$ git status# On branch master# Changes to be committed:# (use "git reset HEAD <file>..." to unstage)## new file: README## Changed but not updated:# (use "git add <file>..." to update what will be committed)## modified: benchmarks.rb#Thursday, August 9, 12
  • 16. RepositoryStaging Modified FilesThe benchmarks.rb file appears under a section named “Changed but not updated”— which means that a file that is tracked has been modified in the workingdirectory but not yet staged.Let’s run git add now to stage the benchmarks.rb file, and then run git status again:$ git add benchmarks.rb$ git status# On branch master# Changes to be committed:# (use "git reset HEAD <file>..." to unstage)## new file: README# modified: benchmarks.rb#Thursday, August 9, 12
  • 17. RepositoryStaging Modified FilesBoth files are staged and will go into your next commit.At this point, suppose you remember one littlechange that you want to make in benchmarks.rb before you commit it.You open it again and make thatchange, and you’re ready to commit. However, let’s run git status one more time:$ vim benchmarks.rb$ git status# On branch master# Changes to be committed:# (use "git reset HEAD <file>..." to unstage)## new file: README# modified: benchmarks.rb## Changed but not updated:# (use "git add <file>..." to update what will be committed)## modified: benchmarks.rb#Thursday, August 9, 12
  • 18. RepositoryStaging Modified FilesNow benchmarks.rb is listed as both staged and unstaged. How is that possible? It turnsout that Git stages a file exactly as it is when you run the git add command. If you commitnow, the version of benchmarks.rb as it was when you last ran the git add command ishow it will go into the commit, not the version of the file as it looks in your workingdirectory when you rungit commit. If you modify a file after you run git add, you have torun git add again to stage the latest version of the file:$ git add benchmarks.rb$ git status# On branch master# Changes to be committed:# (use "git reset HEAD <file>..." to unstage)## new file: README# modified: benchmarks.rb##Thursday, August 9, 12
  • 19. RepositoryIgnoring FilesOften, you’ll have a class of files that you don’t want Git toautomatically add or even show you as being untracked.These are generally automatically generated files such as logfiles or files produced by your build system. In such cases,you can create a file listing patterns to match themnamed .gitignore.$ cat .gitignore*.inc.php*.ttftmp/log/b file without staging it. If you run your status command, you once again seeThursday, August 9, 12
  • 20. RepositoryViewingYour Staged and Unstaged ChangesIf the git status command is too vague foryou — you want to know exactly whatyou changed, not just which files werechanged — you can use the git diffcommand.Thursday, August 9, 12
  • 21. RepositoryViewingYour Staged and Unstaged ChangesLet’s say you edit and stage the README file again and then edit the benchmarks.rb filewithout staging it. If you run your status command, you once again see something like this:$ git status# On branch master# Changes to be committed:# (use "git reset HEAD <file>..." to unstage)## new file: README## Changed but not updated:# (use "git add <file>..." to update what will be committed)## modified: benchmarks.rb#Thursday, August 9, 12
  • 22. RepositoryViewingYour Staged and Unstaged ChangesTo see what you’ve changed but not yet staged, type git diff with no other arguments:$ git diffdiff --git a/benchmarks.rb b/benchmarks.rbindex 3cb747f..da65585 100644--- a/benchmarks.rb+++ b/benchmarks.rb@@ -36,6 +36,10 @@ def main@commit.parents[0].parents[0].parents[0]end+ run_code(x, commits 1) do+ git.commits.size+ end+run_code(x, commits 2) dolog = git.commits(master, 15)log.sizeThursday, August 9, 12
  • 23. RepositoryViewingYour Staged and Unstaged ChangesIf you want to see what you’ve staged that will go into your next commit, you can use git diff--cached.$ git diff --cacheddiff --git a/README b/READMEnew file mode 100644index 0000000..03902a1--- /dev/null+++ b/README2@@ -0,0 +1,5 @@+grit+ by Tom Preston-Werner, Chris Wanstrath+ is a Ruby library for extracting information from a Git repositoryThursday, August 9, 12
  • 24. RepositoryCommittingYour ChangesNow that your staging area is set up the way you want it, youcan commit your changes. Remember that anything that isstill unstaged — any files you have created or modified thatyou haven’t rungit add on since you edited them — won’t gointo this commit.They will stay as modified files on yourdisk. In this case, the last time you ran git status, you saw thateverything was staged, so you’re ready to commit yourchanges.The simplest way to commit is to type git commit:$ git commitDoing so launches your editor of choice to type thecomments or messages.Thursday, August 9, 12
  • 25. RepositoryCommittingYour ChangesAlternatively, you can type your commit message inline with thecommit command by specifying it after a -m flag, like this:$ git commit -m "Story 182: Fix benchmarks for speed"[master]: created 463dc4f: "Fix benchmarks for speed"2 files changed, 3 insertions(+), 0 deletions(-)create mode 100644 READMENow you’ve created your first commit!You can see that thecommit has given you some output about itself: which branch youcommitted to (master), what SHA-1 checksum the commit has(463dc4f), how many files were changed, and statistics about linesadded and removed in the commit.Thursday, August 9, 12
  • 26. RepositorySkipping the Staging AreaAlthough it can be amazingly useful for crafting commits exactly how you want them, thestaging area is sometimes a bit more complex than you need in your workflow. If you wantto skip the staging area, Git provides a simple shortcut. Providing the -a option to the gitcommit command makes Git automatically stage every file that is already tracked beforedoing the commit, letting you skip the git add part:$ git status# On branch master## Changed but not updated:## modified: benchmarks.rb#$ git commit -a -m added new benchmarks[master 83e38c7] added new benchmarks1 files changed, 5 insertions(+), 0 deletions(-)Thursday, August 9, 12
  • 27. RepositoryViewing the Commit HistoryAfter you have created several commits, or if you have cloned a repository with an existing commit history, you’llprobably want to look back to see what has happened.The most basic and powerful tool to do this is the git logcommand.$ git logcommit ca82a6dff817ec66f44342007202690a93763949Author: Scott Chacon <>Date: Mon Mar 17 21:52:11 2008 -0700changed the version numbercommit 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7Author: Scott Chacon <>Date: Sat Mar 15 16:40:33 2008 -0700removed unnecessary test codecommit a11bef06a3f659402fe7563abf99ad00de2209e6Author: Scott Chacon <>Date: Sat Mar 15 10:31:28 2008 -0700first commitThursday, August 9, 12
  • 28. RepositoryChangingYour Last CommitOne of the common undos takes place when youcommit too early and possibly forget to add somefiles, or you mess up your commit message. If youwant to try that commit again, you can run commitwith the --amend option:$ git commit -m initial commit$ git add forgotten_file$ git commit --amendThursday, August 9, 12
  • 29. Working with remotesTo be able to collaborate on any Git project,you need to know how to manage yourremote repositories. Remote repositories areversions of your project that are hosted onthe Internet or network somewhere.You canhave several of them, each of which generallyis either read-only or read/write for you.Collaborating with others involves managingthese remote repositories and pushing andpulling data to and from them when you needto share work.Thursday, August 9, 12
  • 30. Working with remotesShowingYour RemotesTo see which remote servers you have configured, you can run the git remote command. Itlists the shortnames of each remote handle you’ve specified. If you’ve cloned yourrepository, you should at least see origin — that is the default name Git gives to the serveryou cloned from:$ git clone git:// empty Git repository in /private/tmp/ticgit/.git/remote: Counting objects: 595, done.remote: Compressing objects: 100% (269/269), done.remote:Total 595 (delta 255), reused 589 (delta 253)Receiving objects: 100% (595/595), 73.31 KiB | 1 KiB/s, done.Resolving deltas: 100% (255/255), done.$ cd ticgit$ git remoteoriginYou can also specify -v, which shows you the URL that Git has stored for the shortname to beexpanded to:$ git remote -vorigin git:// you have more than one remote, the command lists them all. For example, my Gritrepository looks something like this.Thursday, August 9, 12
  • 31. Working with remotesAdding Remote RepositoriesI’ve mentioned and given some demonstrations ofadding remote repositories in previous sections, buthere is how to do it explicitly.To add a new remoteGit repository as a shortname you can referenceeasily, run git remote add [shortname] [url]:$ git remoteorigin$ git remote add pb git://$ git remote -vorigin git:// git://, August 9, 12
  • 32. Working with remotesFetching and Pulling fromYour RemotesThe command goes out to that remote project and pullsdown all the data from that remote project that you don’thave yet.After you do this, you should have references to allthe branches from that remote, which you can merge in orinspect at any time.$ git fetch pbremote: Counting objects: 58, done.remote: Compressing objects: 100% (41/41), done.remote:Total 44 (delta 24), reused 1 (delta 0)Unpacking objects: 100% (44/44), done.From git://* [new branch] master -> pb/master* [new branch] ticgit -> pb/ticgitThursday, August 9, 12
  • 33. Working with remotesPushing toYour RemotesWhen you have your project at a point that youwant to share, you have to push it upstream.Thecommand for this is simple: git push [remote-name][branch-name]. If you want to push your masterbranch to your origin server (again, cloning generallysets up both of those names for you automatically),then you can run this to push your work back up tothe server:$ git push origin masterThis command works only if you cloned from a server to whichyou have write access and if nobody has pushed in themeantime.Thursday, August 9, 12
  • 34. Working with remotesInspecting a RemoteIf you want to see more information about a particularremote, you can use the git remote show [remote-name]command. If you run this command with a particularshortname, such as origin, you get something like this:$ git remote show origin* remote originURL: git:// branch merged with git pull while on branch mastermasterTracked remote branchesmasterticgitThursday, August 9, 12
  • 35. Working with remotesRenaming RemotesIf you want to rename a reference, innewer versions of Git you can run gitremote rename to change a remote’sshortname. For instance, if you want torename pb to paul, you can do so with$ git remote rename pb paul$ git remoteoriginpaulThursday, August 9, 12
  • 36. Working with remotesRemoving RemotesIf you want to remove a reference forsome reason — you’ve moved the serveror are no longer using a particular mirror,or perhaps a contributor isn’tcontributing anymore — you can use gitremote rm:$ git remote rm paul$ git remoteoriginThursday, August 9, 12
  • 37. TaggingLike mostVCSs, Git has the ability to tag specificpoints in history as being important. Generally,people use this functionality to mark releasepoints (v1.0, and so on). In this section, you’lllearn how to list the available tags, how tocreate new tags, and what the different types oftags are.Thursday, August 9, 12
  • 38. TaggingListingYour TagsListing the available tags in Git is straightforward. Just typegit tag:$ git tagv0.1v1.3You can also search for tags with a particular pattern.The Git source repo, forinstance, contains more than 240 tags. If you’re only interested in looking at the 1.4.2series, you can run this:$ git tag -l v1.4.2.*v1.4.2.1v1.4.2.2v1.4.2.3v1.4.2.4Thursday, August 9, 12
  • 39. TaggingCreating TagsGit uses two main types of tags: lightweight andannotated.A lightweight tag is very much like a branchthat doesn’t change — it’s just a pointer to a specificcommit.Annotated tags, however, are stored as fullobjects in the Git database.They’re checksummed;contain the tagger name, e-mail, and date; have a taggingmessage; and can be signed and verified with GNUPrivacy Guard (GPG). It’s generally recommended thatyou create annotated tags so you can have all thisinformation; but if you want a temporary tag or forsome reason don’t want to keep the otherinformation, lightweight tags are available too.Thursday, August 9, 12
  • 40. TaggingAnnotated TagsCreating an annotated tag in Git is simple.The easiest way is to specify -a when yourun the tagcommand:$ git tag -a v1.4 -m my version 1.4$ git tagv0.1v1.3v1.4Thursday, August 9, 12
  • 41. TaggingAnnotated TagsYou can see the tag data along with the commit that was tagged by using the gitshow command:$ git show v1.4tag v1.4Tagger: Scott Chacon <>Date: Mon Feb 9 14:45:11 2009 -0800my version 1.4commit 15027957951b64cf874c3557a0f3547bd83b3ff6Merge: 4a447f7... a6b4c97...Author: Scott Chacon <>Date: Sun Feb 8 19:02:46 2009 -0800Merge branch experimentThursday, August 9, 12
  • 42. TaggingLightweight TagsAnother way to tag commits is with a lightweight tag.This isbasically the commit checksum stored in a file — no otherinformation is kept.To create a lightweight tag, don’t supplythe -a, -s, or -m option:$ git tag v1.4-lw$ git tagv0.1v1.3v1.4v1.4-lwv1.5Thursday, August 9, 12
  • 43. TaggingLightweight TagsThis time, if you run git show on the tag, you don’t seethe extra tag information.The command just showsthe commit:$ git show v1.4-lwcommit 15027957951b64cf874c3557a0f3547bd83b3ff6Merge: 4a447f7... a6b4c97...Author: Scott Chacon <>Date: Sun Feb 8 19:02:46 2009 -0800Merge branch experimentThursday, August 9, 12
  • 44. TaggingTagging LaterYou can also tag commits after you’ve moved past them.Suppose your commit history looks like this:$ git log --pretty=oneline15027957951b64cf874c3557a0f3547bd83b3ff6 Merge branch experimenta6b4c97498bd301d84096da251c98a07c7723e65 beginning write support166ae0c4d3f420721acbb115cc33848dfcc2121a started write support9fceb02d0ae598e95dc970b74767f19372d61af8 updated rakefile964f16d36dfccde844893cac5b347e7b3d44abbc commit the todo8a5cbc430f1a9c3d00faaeffd07798508422908a updated readmeNow, suppose you forgot to tag the project at v1.2, which wasat the "updated rakefile" commit.You can add it after the fact.To tag that commit, you specify the commit checksum (orpart of it) at the end of the command:$ git tag -a v1.2 9fceb02Thursday, August 9, 12
  • 45. TaggingTagging LaterYou can see that you’ve tagged the commit:$ git tagv0.1v1.2v1.3v1.4v1.4-lwv1.5$ git show v1.2tag v1.2Tagger: Scott Chacon <>Date: Mon Feb 9 15:32:16 2009 -0800version 1.2commit 9fceb02d0ae598e95dc970b74767f19372d61af8Author: Magnus Chacon <>Date: Sun Apr 27 20:43:35 2008 -0700updated rakefile...Thursday, August 9, 12
  • 46. TaggingSharing TagsBy default, the git push command doesn’t transfer tagsto remote servers.You will have to explicitly push tagsto a shared server after you have created them.Thisprocess is just like sharing remote branches — youcan run git push origin [tagname].$ git push origin v1.5Counting objects: 50, done.Compressing objects: 100% (38/38), done.Writing objects: 100% (44/44), 4.56 KiB, done.Total 44 (delta 18), reused 8 (delta 1)To* [new tag] v1.5 -> v1.5Thursday, August 9, 12
  • 47. TaggingSharing TagsIf you have a lot of tags that you want to push up at once, you can alsouse the --tags option to thegit push command.This will transfer all ofyour tags to the remote server that are not already there.$ git push origin --tagsCounting objects: 50, done.Compressing objects: 100% (38/38), done.Writing objects: 100% (44/44), 4.56 KiB, done.Total 44 (delta 18), reused 8 (delta 1)To* [new tag] v0.1 -> v0.1* [new tag] v1.2 -> v1.2* [new tag] v1.4 -> v1.4* [new tag] v1.4-lw -> v1.4-lw* [new tag] v1.5 -> v1.5Now, when someone else clones or pulls from your repository, theywill get all your tags as well.Thursday, August 9, 12
  • 48. BranchingNearly everyVCS has some form of branchingsupport. Branching means you diverge from themain line of development and continue to dowork without messing with that main line.The way Git branches is incredibly lightweight,making branching operations nearlyinstantaneous and switching back and forthbetween branches generally just as fast.Thursday, August 9, 12
  • 49. BranchingLet’s go through a simple example of branching and merging with a workflowthat you might use in the real world.You’ll follow these steps:1.Do work on a web site.2.Create a branch for a new story you’re working on.3.Do some work in that branch.At this stage, you’ll receive a call that another issue is critical and you need ahotfix.You’ll do the following:1.Revert back to your production branch.2.Create a branch to add the hotfix.3.After it’s tested, merge the hotfix branch, and push to production.4.Switch back to your original story and continue working.Thursday, August 9, 12
  • 50. BranchingFirst, let’s say you’re working on your project and have a couple of commitsalready.You’ve decided that you’re going to work on issue #53 in whatever issue-trackingsystem your company uses, because issue #53 is a focused topic that you want towork on, you’ll create a new branch in which to work.To create a branch andswitch to it at the same time, you can run the git checkout command with the -bswitch:$ git checkout -b iss53Switched to a new branch "iss53"This is shorthand for:$ git branch iss53$ git checkout iss53Thursday, August 9, 12
  • 51. BranchingYou work on your web site and do somecommits. Doing so moves the iss53 branchforward, because you have it checked out.$ vim index.html$ git commit -a -m added a new footer [issue 53]Thursday, August 9, 12
  • 52. BranchingNow you get the call that there is an issue with the web site, and you needto fix it immediately.With Git, you don’t have to deploy your fix along withthe iss53 changes you’ve made, and you don’t have to put a lot of effort intoreverting those changes before you can work on applying your fix to what isin production.All you have to do is switch back to your master branch.However, before you do that, note that if your working directory or stagingarea has uncommitted changes that conflict with the branch you’re checkingout, Git won’t let you switch branches. It’s best to have a clean working statewhen you switch branches.There are ways to get around this (namely,stashing and commit amending) that we’ll cover later. For now, you’vecommitted all your changes, so you can switch back to your master branch:$ git checkout masterSwitched to branch "master"Thursday, August 9, 12
  • 53. BranchingNext, you have a hotfix to make. Let’s create a hotfixbranch on which to work until it’s completed$ git checkout -b hotfixSwitched to a new branch "hotfix"$ vim index.html$ git commit -a -m fixed the broken email address[hotfix]: created 3a0874c: "fixed the broken email address"1 files changed, 0 insertions(+), 1 deletions(-)Thursday, August 9, 12
  • 54. BranchingYou can run your tests, make sure the hotfix is what you want, and merge it backinto your master branch to deploy to production.You do this with the git mergecommand$ git checkout master$ git merge hotfixUpdating f42c576..3a0874cFast forwardREADME | 1 -1 files changed, 0 insertions(+), 1 deletions(-)You’ll notice the phrase "Fast forward" in that merge. Because the commit pointedto by the branch you merged in was directly upstream of the commit you’re on,Git moves the pointer forward.To phrase that another way, when you try tomerge one commit with a commit that can be reached by following the firstcommit’s history, Git simplifies things by moving the pointer forward becausethere is no divergent work to merge together — this is called a "fast forward".Thursday, August 9, 12
  • 55. BranchingAfter your super-important fix is deployed, you’re ready to switch back to thework you were doing before you were interrupted. However, first you’ll delete(optional) the hotfix branch, because you no longer need it — the masterbranch points at the same place.You can delete it with the -d option to gitbranch:$ git branch -d hotfixDeleted branch hotfix (3a0874c).Now you can switch back to your work-in-progress branch on issue #53 andcontinue working on it$ git checkout iss53Switched to branch "iss53"$ vim index.html$ git commit -a -m finished the new footer [issue 53][iss53]: created ad82d7a: "finished the new footer [issue 53]"1 files changed, 1 insertions(+), 0 deletions(-)Thursday, August 9, 12
  • 56. BranchingBasic MergingSuppose you’ve decided that your issue #53 work iscomplete and ready to be merged into yourmasterbranch. In order to do that, you’ll merge in youriss53 branch, much like you merged in your hotfixbranch earlier.All you have to do is check out thebranch you wish to merge into and then run the gitmerge command:$ git checkout master$ git merge iss53Merge made by recursive.README | 1 +1 files changed, 1 insertions(+), 0 deletions(-)Thursday, August 9, 12
  • 57. BranchingBasic MergingThis looks a bit different than the hotfix merge you did earlier. In thiscase, your development history has diverged from some older point.Because the commit on the branch you’re on isn’t a direct ancestor ofthe branch you’re merging in, Git has to do some work. In this case, Gitdoes a simple three-way merge, using the two snapshots pointed to bythe branch tips and the common ancestor of the two. Figure 3-16highlights the three snapshots that Git uses to do its merge in this case.Thursday, August 9, 12
  • 58. BranchingBasic MergingInstead of just moving the branch pointer forward, Git creates a new snapshot thatresults from this three-way merge and automatically creates a new commit thatpoints to it.This is referred to as a merge commit and is special in that it has morethan one parent.It’s worth pointing out that Git determines the best common ancestor to use for itsmerge base; this is different than CVS or Subversion (before version 1.5), where thedeveloper doing the merge has to figure out the best merge base for themselves.This makes merging a heck of a lot easier in Git than in these other systems.Thursday, August 9, 12
  • 59. BranchingBasic Merge ConflictsOccasionally, this process doesn’t go smoothly. If you changedthe same part of the same file differently in the two branchesyou’re merging together, Git won’t be able to merge themcleanly. If your fix for issue #53 modified the same part of a fileas the hotfix, you’ll get a merge conflict that looks somethinglike this:$ git merge iss53Auto-merging index.htmlCONFLICT (content): Merge conflict in index.htmlAutomatic merge failed; fix conflicts and then commit theresult.Thursday, August 9, 12
  • 60. BranchingBasic Merge ConflictsGit hasn’t automatically created a new merge commit. It has paused theprocess while you resolve the conflict. If you want to see which files areunmerged at any point after a merge conflict, you can run git status:[master*]$ git statusindex.html: needs merge# On branch master# Changed but not updated:# (use "git add <file>..." to update what will be committed)# (use "git checkout -- <file>..." to discard changes in working directory)## unmerged: index.html#Thursday, August 9, 12
  • 61. BranchingBasic Merge ConflictsAnything that has merge conflicts and hasn’t been resolved is listed as unmerged. Git addsstandard conflict-resolution markers to the files that have conflicts, so you can open themmanually and resolve those conflicts.Your file contains a section that looks something likethis:<<<<<<< HEAD:index.html<div id="footer">contact :</div>=======<div id="footer">please contact us at</div>>>>>>>> iss53:index.htmlIf you want to use a graphical tool to resolve these issues, you can run gitmergetool, which fires up an appropriate visual merge tool and walks youthrough the conflicts.$ git mergetoolThursday, August 9, 12
  • 62. BranchingBasic Merge ConflictsYou can run git status again to verify that all conflicts have been resolved:$ git status# On branch master# Changes to be committed:# (use "git reset HEAD <file>..." to unstage)## modified: index.html#If you’re happy with that, and you verify that everything that hadconflicts has been staged, you can type git commit to finalize themerge commit.Thursday, August 9, 12
  • 63. Aptana & Git• Requirements• Git• Download and install Aptana Studio 3•, August 9, 12
  • 64. Aptana & Git1. Open Aptana Studio and open the Project Explorer view.“Window -> Show view -> ProjectExplorer”2. Click on the “File -> New -> Project” menu.3. Click on “Create Project”, select “PHP Project” and click “Next”Thursday, August 9, 12
  • 65. Aptana & Git4. Type the project name and disable the “Use default location” option to specify the path of aweb application directory then click “Finish”.Thursday, August 9, 12
  • 66. Aptana & Git5. Now your project is ready to work on it.Thursday, August 9, 12
  • 67. Aptana & Git6. Select the project on the list and click on “Create” and then “Finis”.Your Git repository isready (master brach).Thursday, August 9, 12
  • 68. Aptana & Git7. You will se the [master] next to the project name.Thursday, August 9, 12
  • 69. Aptana & Git8. Create file index.html file make some chnages on it and then commit the file into therepository. Right click on the project name select “Team -> Commit” option.Thursday, August 9, 12
  • 70. Aptana & Git9. Select index.html filename from the Unstaged Changes and click on the > button, then thefile moves into Staged Changes.Type a message into Commit Message section and click on“Commit”.You will see that the * mark on your project name will disappear.Thursday, August 9, 12
  • 71. Aptana & Git9. Modify the index.html again.And see how the background color of the filename changes andalso Aptana adds the * mark again to the file and the project name.This identify that theproject has some uncommited changes.Thursday, August 9, 12
  • 72. Aptana & Git10. Commit the project again and you’ll se the changes between the commited file and the lastversion of the file.Thursday, August 9, 12
  • 73. Aptana & Git11. Create a new hotfix branch.Thursday, August 9, 12
  • 74. Aptana & Git12. Make some changes on the file and commit the file into this new branch.Thursday, August 9, 12
  • 75. Aptana & Git13. Switch into master branch. Right click on project name “Team -> Branches -> Switch to ->master”.Thursday, August 9, 12
  • 76. Aptana & Git14. Switch into master branch. Right click on project name “Team -> Branches -> Switch to ->master”.Thursday, August 9, 12
  • 77. Aptana & Git15. Merge master and hotfix branches.Thursday, August 9, 12
  • 78. Aptana & Git16. Now the two version of the index.html file are mixed into the master branch.17. To check this status right click on filename and select “Team -> Show in Resource History”.Thursday, August 9, 12
  • 79. Aptana & Git18. The History window will appear, here you could see the history of this file.Thursday, August 9, 12
  • 80. PaybookHappy Coders!Thursday, August 9, 12