2 A tour of git: the basics
6 This document is a modified version of a document originally titled
7 "Distributed revision control with Mercurial" and originally authored
8 by Bryan O’Sullivan. The original document was obtained from
9 <http://hgbook.red-bean.com/>.
11 Copyright © 2006, 2007 Bryan O’Sullivan.
13 This material may be distributed only subject to the terms and
14 conditions set forth in version 1.0 of the Open Publication
15 License. Please refer to Appendix D for the license text.
17 As this is a modified version, the name of Bryan O'Sullivan is used
18 only to properly credit him with the original text. The appearance of
19 his name here explicitly does not assert or imply his endorsement of
20 this modified document.
22 Portions Copyright © 2007 Carl Worth.
24 Changes made by Carl include the following:
27 * Convert from HTML to markdown source syntax
28 * Eliminate all content except Chapter 2 and Appendix D
29 * Eliminate line numbers from examples
30 * Modified to describe git instead of mercurial
32 ### 2.1 Installing git on your system
34 Prebuilt binary packages of git are available for many popular
35 operating systems. These make it easy to start using git on your
40 Because each Linux distribution has its own packaging tools, policies,
41 and rate of development, it’s difficult to give a comprehensive set of
42 instructions on how to install git binaries. The version of
43 git that you will end up with can vary depending on how active
44 the person is who maintains the package for your distribution.
46 To keep things simple, I will focus on installing git from the
47 command line under the most popular Linux distributions. Most of these
48 distributions provide graphical package managers that will let you
49 install git with a single click. The package name to look for is
50 often git, but is sometimes git-core, (due to an unfortunate name
51 with git, meaning GNU Interactive Tools).
55 apt-get install git-core
75 A git-core package is available through
76 [macports](http://macports.org). Once macports is enabled, the command
83 Git has long been available as part of cygwin, and works reasonably
84 well in that environment. Some people find cygwin a particularly
85 inelegant approach to running git and would prefer a "native"
86 solution. To this end, the [msysgit
87 project](http://code.google.com/p/msysgit/) is rapidly putting
88 together a solution including various packages with full
89 installers. These include GitMe, a package to install the entire
90 development environment necessary to work on improving the msysgit
91 port of git, and WinGit, a package for installing just git itself
92 without the development environment, (still in Alpha as of September
95 ### 2.2 Getting started
97 To begin, we’ll use the “git version” command to find out whether git
98 is actually installed properly. Versions 1.5 and newer of git are much
99 more friendly to new users than versions 1.4 and older. If you aren't
100 yet running version 1.5 or newer, it's highly recommended that you
106 #### 2.2.1 Built-in help
108 Git provides a built-in help system. This is invaluable for those
109 times when you find yourself stuck trying to remember how to run a
110 command. If you are completely stuck, simply run “git help”; it will
111 print a brief list of commonly-used commands, along with a description
112 of what each does. If you ask for help on a specific command (such as
113 "git help init"), it prints more detailed information. [XXX: Does "git
114 help <foo>" work universally as a built-in or does it expect man to be
115 present and just call out to "man git-<foo>"?]
117 [XXX: The original hgbook includes the complete output of "hg
118 help init" at this point. I'm not including the corresponding
119 "git help init" output as it would be excessively long. The
120 description alone is quite reasonable, (other than a
121 not-too-helpful aside about the obsolete git-init-db command),
122 but it only comes after a full screen's worth of options
123 details. Might it make sense to have a more summarized help
124 output for "git help <foo>" than all of the documentation
125 available for git-<foo>? And perhaps alos provide a "git -v
126 help" similar to "hg -v help" for more?]
128 ### 2.3 Working with a repository
130 In git, everything happens inside a repository. The repository
131 for a project contains all of the files that “belong to” that project,
132 along with a historical record of the project’s files.
134 There’s nothing particularly magical about a repository; it is simply
135 a directory tree in your filesystem that git treats as
136 special. You can rename or delete a repository any time you like,
137 using either the command line or your file browser.
139 #### 2.3.1 Making a local copy of a repository
141 Copying a repository is just a little bit special. While you could use
142 a normal file copying command to make a copy of a repository, it’s
143 best to use a built-in command that git provides. This command
144 is called “git clone”, because it creates an identical copy of an
147 $ git clone git://cworth.org/git/hello
148 Initialized empty Git repository in /tmp/hello/.git/
149 remote: Generating pack...
150 remote: Done counting 15 objects.
151 remote: Deltifying 15 objects...
152 remote: 100% (15/15) done
153 remote: Total 15 (delta 2), reused 15 (delta remote: 2)
154 Indexing 15 objects...
156 Resolving 2 deltas...
159 If for some reason you are prevented from talking on the git: port,
160 then there is also the capability to clone a repository (less
161 efficiently) over http:
163 $ git clone http://cworth.org/git/hello
164 Initialized empty Git repository in /tmp/hello/.git/
165 Getting alternates list for http://cworth.org/git/hello
166 Getting pack list for http://cworth.org/git/hello
167 Getting index for pack 04ecb061314ecbd60fa0610ecf55a1cbf85ea294
168 Getting pack 04ecb061314ecbd60fa0610ecf55a1cbf85ea294
169 which contains a1a0e8b392b17caf50325498df54802fe3c03710
170 walk a1a0e8b392b17caf50325498df54802fe3c03710
171 walk 72d4f10e4a27dbb09ace1503c20dbac1912ee451
172 walk 13ed136b983a9c439eddeea8a1c2076cffbb685f
173 walk 0a633bf58b45fcf1a8299d3c82cd1fd26d3f48f2
174 walk db7117a9dd9a6e57e8632ea5848e1101eee0fbde
176 If our clone succeeded, we should now have a local directory called
177 hello. This directory will contain some files.
181 drwxr-xr-x 3 cworth cworth 4096 2007-09-27 16:40 hello
185 These files have the same contents and history in our repository as
186 they do in the repository we cloned.
188 Every git repository is complete, self-contained, and
189 independent. It contains its own private copy of a project’s files and
190 history. A cloned repository remembers the location of the repository
191 it was cloned from, but it does not communicate with that repository,
192 or any other, unless you tell it to.
194 What this means for now is that we’re free to experiment with our
195 repository, safe in the knowledge that it’s a private “sandbox” that
196 won’t affect anyone else.
198 #### 2.3.2 What’s in a repository?
200 When we take a more detailed look inside a repository, we can see that
201 it contains a directory named .git. This is where git keeps all
202 of its metadata for the repository.
206 . .. .git hello.c Makefile
208 The contents of the .git directory and its subdirectories are private
209 to git. Every other file and directory in the repository is
210 yours to do with as you please.
212 To introduce a little terminology, the .git directory is the “real”
213 repository, and all of the files and directories that coexist with it
214 are said to live in the working directory. An easy way to remember the
215 distinction is that the repository contains the history of your
216 project, while the working directory contains a snapshot of your
217 project at a particular point in history.
219 ### 2.4 A tour through history
221 One of the first things we might want to do with a new, unfamiliar
222 repository is understand its history. The “git log” command gives us a
226 commit a1a0e8b392b17caf50325498df54802fe3c03710
227 Author: Bryan O'Sullivan <bos@serpentine.com>
228 Date: Tue Sep 6 15:43:07 2005 -0700
232 commit 72d4f10e4a27dbb09ace1503c20dbac1912ee451
233 Author: Bryan O'Sullivan <bos@serpentine.com>
234 Date: Tue Sep 6 13:15:58 2005 -0700
236 Get make to generate the final binary from a .o file.
238 commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
239 Author: Bryan O'Sullivan <bos@serpentine.com>
240 Date: Tue Sep 6 13:15:43 2005 -0700
242 Introduce a typo into hello.c.
244 commit 0a633bf58b45fcf1a8299d3c82cd1fd26d3f48f2
245 Author: Bryan O'Sullivan <mpm@selenic.com>
246 Date: Fri Aug 26 01:21:28 2005 -0700
250 commit db7117a9dd9a6e57e8632ea5848e1101eee0fbde
251 Author: Bryan O'Sullivan <mpm@selenic.com>
252 Date: Fri Aug 26 01:20:50 2005 -0700
254 Create a standard "hello, world" program
256 By default, this command prints a brief paragraph of output for each
257 change to the project that was recorded. In git terminology, we
258 call each of these recorded events a commit.
260 The fields in a record of output from “git log” are as follows.
262 * commit This field consists of a string of 40 hexadecimal characters.
263 This is a unique identifier for referring to particular commits.
264 * Author The identity of the person who authored the commit. This
265 field consist of two sub-fields for the user's name and email
266 address, (or at least an email-like idenitifer). Note that git
267 stores a separate "Committer" field for the person who commited
268 the change, (since often an author will email a change to a
269 maintainer that commits it). The "git log" command doesn't display
270 the Committer, but other git tools do.
271 * Date The date and time on which the commit was authored, (again
272 stored separately from the date the change was committed).
273 timezone in which it was created. (The date and time are displayed
274 in the timezone of the person who created the commit.)
275 * commit message The text message that the creator of the commit
276 entered to describe the commit, (generally a one-line summary
277 followed by more supporting text).
279 The default output printed by “git log” is purely a summary; it is
280 missing a lot of detail.
282 #### 2.4.1 Commits, revisions, and talking to other people
284 As English is a notoriously sloppy language, and computer science has
285 a hallowed history of terminological confusion (why use one term when
286 four will do?), revision control has a variety of words and phrases
287 that mean the same thing. If you are talking about git history
288 with other people, you will find that what we have called a “commit”
289 is often called a "revision". In other systems, a similar notion
290 is referred to as a "changeset". You might even see abbreviations of
291 these terms such as "rev", "change", or even "cset".
293 While it may not matter much what word you use to refer to the concept
294 of “a commit”, it's important to know how to name “a specific
295 commit”. We have already seen one means of referring to a particular
296 commit, the 40-character hexadecimal string shown by "git log". These
297 commit identifiers are powerful because they are permanent, unique
298 identifiers that always identify the same commit in any copy of a
299 repository. If two users are examining a working directory associated
300 with the same commit identifier, then those two users have precisely
301 the same contents in all files, and exactly the same history leading
304 So there are places where it is often important to archive the
305 complete commit identifier, (perhaps in bug-tracking systems to
306 indicate a specific commit that fixes a bug, for example). But often,
307 in more casual settings, it's more convenient to use abbreviated
308 commit identifiers. Git accept any unique prefix of a commit
309 identifier, (and for reasonably-sized project the first 8 or 10
310 characters are almost always unique).
312 And unlike the permanent commit identifiers, git also provides
313 transient means of identifying commits. In fact, in day-to-day use of
314 git, you will probably use these names more than commit
315 identifiers. One example is branch names, (such as the default
316 "master" branch in any git repository), or any project-specific branch
317 names such as "stable", "experimental", or "crazy-insane-changes". Git
318 also provides a special name "HEAD" which always refers to the current
321 #### 2.4.2 Naming related commits
323 Git offers simple ways to name revisions that are related to
324 particular revisions in the history. One syntax is the ~ suffix which
325 refers to the parent of a commit, or if followed by a number, to the
326 Nth parent. For example, since "HEAD" refers to the most recent commit
327 in the current branch, "HEAD~", refers to the previous commit, and
328 "HEAD~2" refers to two commits back in the history.
330 Another useful syntax is .. which can be used to specify a range of
331 commits. So "origin..master" specifies everything that has been
332 committed to master since it derived from origin.
334 #### 2.4.3 Viewing specific revisions
336 You can use "git log" to explore the range syntax just introduced. For
337 example, to see a list of the most recent 3 revisions you can use
338 "HEAD~3..", (the destination of the range is implicitly HEAD in this
342 commit a1a0e8b392b17caf50325498df54802fe3c03710
343 Author: Bryan O'Sullivan <bos@serpentine.com>
344 Date: Tue Sep 6 15:43:07 2005 -0700
348 commit 72d4f10e4a27dbb09ace1503c20dbac1912ee451
349 Author: Bryan O'Sullivan <bos@serpentine.com>
350 Date: Tue Sep 6 13:15:58 2005 -0700
352 Get make to generate the final binary from a .o file.
354 commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
355 Author: Bryan O'Sullivan <bos@serpentine.com>
356 Date: Tue Sep 6 13:15:43 2005 -0700
358 Introduce a typo into hello.c.
360 #### 2.4.4 Other log filters
362 Besides filtering by commit identifiers, git allows you to easily
363 filter the log output according to which files (or directories) are
364 modified by listing them after "--" wihch is necessary to distinguish
365 commit names from file names:
367 $ git log -- Makefile
368 commit 72d4f10e4a27dbb09ace1503c20dbac1912ee451
369 Author: Bryan O'Sullivan <bos@serpentine.com>
370 Date: Tue Sep 6 13:15:58 2005 -0700
372 Get make to generate the final binary from a .o file.
374 commit 0a633bf58b45fcf1a8299d3c82cd1fd26d3f48f2
375 Author: Bryan O'Sullivan <mpm@selenic.com>
376 Date: Fri Aug 26 01:21:28 2005 -0700
380 And "git log" can also filter based on the dates at which commits were
383 $ git log --since="2 weeks ago" --until="yesterday"
385 Another useful option is -n or --max-count which, unsurprisingly,
386 limits the maximum number of commits to be displayed.
388 #### 2.4.3 More detailed information
390 While the default information printed by “git log” is useful if you
391 already know what you’re looking for, you may need to see more details
392 of the change, such as the "diffstat" information with --stat:
394 $ git log --stat --max-count=3
395 commit a1a0e8b392b17caf50325498df54802fe3c03710
396 Author: Bryan O'Sullivan <bos@serpentine.com>
397 Date: Tue Sep 6 15:43:07 2005 -0700
402 1 files changed, 2 insertions(+), 6 deletions(-)
404 commit 72d4f10e4a27dbb09ace1503c20dbac1912ee451
405 Author: Bryan O'Sullivan <bos@serpentine.com>
406 Date: Tue Sep 6 13:15:58 2005 -0700
408 Get make to generate the final binary from a .o file.
411 1 files changed, 2 insertions(+), 0 deletions(-)
413 commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
414 Author: Bryan O'Sullivan <bos@serpentine.com>
415 Date: Tue Sep 6 13:15:43 2005 -0700
417 Introduce a typo into hello.c.
420 1 files changed, 1 insertions(+), 1 deletions(-)
422 Or perhaps you'd like to see the actual patch content of each change,
423 which you can get with -p. That commit with the word typo in its name
424 looks suspicous, so let's tak a closer look. Remember that we can name
425 it as master~3, HEAD~3, or any prefix of its commit identifier, (such
428 $ git log -p -n 1 13ed136b
429 commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
430 Author: Bryan O'Sullivan <bos@serpentine.com>
431 Date: Tue Sep 6 13:15:43 2005 -0700
433 Introduce a typo into hello.c.
435 diff --git a/hello.c b/hello.c
436 index ed55ec0..80b260c 100644
441 int main(int argc, char **argv)
443 - printf("hello, world!\n");
444 + printf("hello, world!\");
448 Of course, wanting to see all this information for a single commit is
449 such a common operation that it's given its own name in git, "git
450 show". So "git show 13ed136b" is a much easier way to get exactly the
454 commit 13ed136b983a9c439eddeea8a1c2076cffbb685f
455 Author: Bryan O'Sullivan <bos@serpentine.com>
456 Date: Tue Sep 6 13:15:43 2005 -0700
458 Introduce a typo into hello.c.
460 diff --git a/hello.c b/hello.c
461 index ed55ec0..80b260c 100644
466 int main(int argc, char **argv)
468 - printf("hello, world!\n");
469 + printf("hello, world!\");
473 ### 2.5 All about command options
475 Let’s take a brief break from exploring git commands to discuss
476 a pattern in the way that they work; you may find this useful to keep
477 in mind as we continue our tour.
479 Git has a consistent and straightforward approach to dealing
480 with the options that you can pass to commands. It follows the
481 conventions for options that are common to modern Linux and Unix
484 * Most options have long names. For example, as we’ve already seen,
485 the “git log" command accepts a --max-count=<number> option.
486 * Some options have short, single-character names. Often these are
487 aliases for long commands, (such as "-n <number>" instead of
488 --max-count=<number>), but sometimes the option exists in
489 short-form with no long-form equivalent, (such as -p). [XXX: It
490 wouldn't hurt to fix this by adding --patch, etc. right?]
491 * Long options start with two dashes (e.g. --max-count), while short
492 options start with one (e.g. -n).
494 * Option naming and usage is consistent across commands. For
495 example, every command that lets you specify a commit identifier
496 or range will accept the same expressions, (HEAD~3,
497 origin..master, 72d4f10e, etc), while any command that can be
498 limited by paths will accept the same expressions ("-- doc/
501 Many commands that print output of some kind can be made more quiet by
502 passing the -q or --quiet options.
504 ### 2.6 Making and reviewing changes
506 Now that we have a grasp of viewing history in git, let’s take a
507 look at making some changes and examining them.
509 The first thing we’ll do is isolate our experiment in a repository of
510 its own. We use the “git clone” command, but we don’t need to clone a
511 copy of the remote repository. Since we already have a copy of it
512 locally, we can just clone that instead. This is much faster than
513 cloning over the network, and cloning a local repository uses less
514 disk space in most cases, too.
517 $ git clone hello my-hello
518 Initialized empty Git repository in /tmp/my-hello/.git/
521 [XXX We say "empty" here, (presumably from the git-init part),
522 but shouldn't the command also report the succesful clone
523 which makes it non-empty? And what the heck does "0 blocks"
526 As an aside, it’s often good practice to keep a “pristine” copy of a
527 remote repository around, which you can then make temporary clones of
528 to create sandboxes for each task you want to work on. This lets you
529 work on multiple tasks in parallel, each isolated from the others
530 until it’s complete and you’re ready to integrate it back. Because
531 local clones are so cheap, there’s almost no overhead to cloning and
532 destroying repositories whenever you want.
534 Alternatively, you can achieve much the same effect by creating
535 multiple branches in a single repository, (but we won't go into detail
536 on how to do that in this chapter). Some people greatly appreciate
537 having multiple branches in a single repository rather than having
538 many repositories cluttering up their filesystem. Other people prefer
539 the ability to have working-tree changes, and intermediate build
540 files, etc. each isolated in a separate repository per branch. Both
541 modes are very well-supported by git, so it's really a matter of which
542 you find most appropriate at any time given your tastes and project
545 In our my-hello repository, we have a file hello.c that contains the
546 classic “hello, world” program. Let’s use the ancient and venerable
547 sed command to edit this file so that it prints a second line of
548 output. (I’m only using sed to do this because it’s easy to write a
549 scripted example this way. Since you’re not under the same constraint,
550 you probably won’t want to use sed; simply use your preferred text
551 editor to do the same thing.)
553 $ sed -i '/printf/a\\tprintf("hello again!\\n");' hello.c
555 The “git status” command will tell us what git knows about the files
562 # Changed but not updated:
563 # (use "git add <file>..." to update what will be committed)
567 no changes added to commit (use "git add" and/or "git commit -a")
569 We see that “git status” command prints a line with "modified" for
570 hello.c. The “git status” command will not print any output for files
571 that have not been modified.
573 Notice that we didn’t need to inform git that we were going to modify
574 the file before we started, or that we had modified the file after we
575 were done; it was able to figure this out itself.
577 It’s a little bit helpful to know that we’ve modified hello.c, but we
578 might prefer to know exactly what changes we’ve made to it. To do
579 this, we use the “git diff” command.
582 diff --git a/hello.c b/hello.c
583 index 9a3ff79..6d28887 100644
587 int main(int argc, char **argv)
589 printf("hello, world!\");
590 + printf("hello again!\n");
594 ### 2.7 Recording changes in a new commit
596 We can modify files, build and test our changes, and use “git status”
597 and “git diff” to review our changes, until we’re satisfied with what
598 we’ve done and arrive at a natural stopping point where we want to
599 record our work in a new commit.
601 The “git commit” command lets us create a new changeset; we’ll usually
602 refer to this as “making a commit” or “committing”.
604 #### 2.7.1 Setting up a username
606 When you try to run “git commit” for the first time, it might not do
607 exactly what you want. Git records your name and address with each
608 change that you commit, (as both author and committer unless you tell
609 it otherwise), so that you and others will later be able to tell who
610 made each change. Git tries to automatically figure out a sensible
611 name and address to attribute to both author and committer. It will
612 attempt each of the following methods, in order, (stopping for each field as soon as a value is found):
614 1. If you specify a --author option to the “git commit” command on
615 the command line, followed by a "Real Name <email@example.com>"
616 string, then this name and addresss will be used for the author
617 fields. The committer fields will still be determined as
618 below. This option is very helpful for when applying a commit
619 originally authored by someone other than yourself.
620 2. If any of the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL,
621 GIT_COMMITTER_NAME, or GIT_COMMITER_EMAIL environment variables
622 are set, then those values will be used for the corresponding
624 3. If you have a file in your home directory called .gitconfig, with
625 name or email settings in the [user] section, then these values
626 will be used to set any remaining author and committer
627 fields. For more details on the contents of this file, refer to
629 4. If you have a file in the local repository called .git/config,
630 again with name or email settings in the [user] section, then
631 these values will be used to set any remaining author and
633 5. If you have set the EMAIL environment variable, this will be used
634 to set author and committer email addresses if still unset.
635 6. git will query your system to find out your real name from
636 available GECOS field and your username, hostname, and domain to
637 construct an email address, (or at least an identifier resembling
640 If all of these mechanisms fail, "git commit" will fail, printing an
641 error message instructing you how to use "git config" to tell git your
642 name and email address.
644 You should think of the GIT_AUTHOR/COMMITER_NAME/EMAIL environment
645 variables and the --author option to the “git commit” command as ways
646 to override git’s default selection. For normal use, the simplest and
647 most robust way to set your information is by creating a .gitconfig
648 file, (either manually or with the "git config" command); see below
651 ##### Creating a git configuration file
653 To set your name and email address, just use the following commands:
655 git config --global user.name "Your Name"
656 git config --global user.email "you@example.com"
658 The --global option means that this command will set global
659 information, (affecting all repositories on this machine), in the
660 .gitconfig file in your home directory. Alternately, you could omit
661 the --global which would make the change take effect only in the local
662 repository. This is convenient if you want to have different email
663 addresses associated with different projects, for example.
665 Of course, git's configuration file is a simple-to-edit plain-text
666 file, so instead of using the above commands, you can also just edit
667 the files directly. Use your favorite editor to create a file called
668 .gitconfig in your home directory, (or if you ran the above commands
669 then it will be there already). The initial contents of your
670 .gitconfig should look like this.
672 # This is a git configuration file.
675 email = you@example.com
677 Similarly, you can make a repository-specific configuration by editing
678 .git/config in the local repository. It will already have some
679 sections present, (created by the "git clone"), just add a [user]
682 The “[user]” line begins a section of the config file, so you can read
683 the “name = ...” line as meaning “set the value of the name item in
684 the user section”. This is the same notion expressed with the
685 "user.name" syntax on the git-config command line. A section
686 continues until a new section begins, or the end of the file. Git
687 ignores empty lines and treats any text from “#” to the end of a line
690 ##### Choosing a user name
692 You can use any text you like as the value of the name and email
693 configuration items, since this information is for reading by other
694 people, not for interpreting by git. It is conventional to use a valid
695 email address, but some, (notably Linus Torvalds, the original author
696 of git), actually like the default user@hostname convention that git
697 falls back on without any additional information. There's no
698 requirement that the email address actually be valid, and perhaps it's
699 useful to be reminded which machine was used to create particular
702 #### 2.7.2 Writing a commit message
704 When we commit a change, git drops us into a text editor to
705 enter a message that will describe the modifications we’ve made in
706 this commit. This is called the commit message. It will be a record
707 for readers of what we did and why, and it will be printed by “git log”
708 after we’ve finished committing.
712 Note: The -a on the command-line instructs git to commit all changes
713 to tracked files. Without this, "git commit" will only commit changes
714 that have been previously staged for committing with "git add
715 file". The most common usage is to commit with "git commit -a" and
716 only use "git add file; git commit" when there is a need to commit
717 only some subset of changes that have been made.
719 The editor that the “git commit” command drops us into will contain an
720 empty line, followed by a number of lines starting with “#”.
723 # Please enter the commit message for your changes.
724 # (Comment lines starting with '#' will not be included)
726 # Changes to be committed:
727 # (use "git reset HEAD <file>..." to unstage)
732 git ignores the lines that start with “#”; it uses them only
733 to tell us which files it’s recording changes to. Modifying or
734 deleting these lines has no effect.
736 #### 2.7.3 Writing a good commit message
738 A good commit message will generally have a single line that
739 summarizes the commit, a blank line, and then one or more pargraphs
740 with supporting detail. Since many tools only print the first line of
741 a commit message by default, it’s important that the first line stands
744 One example of a first-line-only viewer is "git log
745 --pretty=short". Other examples include graphical history viewers such
746 as gitk and gitview, and web-based viewers such as gitweb and cgit.
748 Here’s a real example of a commit message that doesn’t follow
749 this guideline, and hence has a summary that is not readable.
751 $ git log --pretty=short
752 commit 3ef5535144da88a854f7930503845cd44506c2e2
753 Author: Censored Person <censored.person@example.org>
755 include buildmeister/commondefs. Add an exports and install
757 As far as the remainder of the contents of the commit message are
758 concerned, there are no hard-and-fast rules. git itself doesn’t
759 interpret or care about the contents of the commit message, though
760 your project may have policies that dictate a certain kind of
763 My personal preference is for short, but informative, commit messages
764 that tell me something that I can’t figure out with a quick glance at
765 the output of “git log -p".
767 #### 2.7.4 Aborting a commit
769 If you decide that you don’t want to commit while in the middle of
770 editing a commit message, simply exit from your editor without saving
771 the file that it’s editing. This will cause nothing to happen to
772 either the repository or the working directory.
774 #### 2.7.5 Admiring our new handiwork
776 Once we’ve finished the commit, we can use the “git show” command to
777 display the commit we just created. As discussed previously, this
778 command produces output that is identical to “git log -p”, but for
779 only a single revision, (and the most recent revision by default):
782 commit 018cfb742be6176443ffddac454e593e802ddf3e
783 Author: Carl Worth <cworth@cworth.org>
784 Date: Thu Sep 27 23:55:00 2007 -0700
786 Added an extra line of output.
788 If I would have been clever I would have fixed that old typo
791 diff --git a/hello.c b/hello.c
792 index 9a3ff79..6d28887 100644
796 int main(int argc, char **argv)
798 printf("hello, world!\");
799 + printf("hello again!\n");
803 Note that you will not see the same commit identifier for your commit,
804 even if the change you made is identical to mine. The commit
805 identifier incorporates not only the contents of the files, but commit
806 message, the author and committer names and emails, and the author and
807 commit dates. (OK, so now you probably know enough to be able to guess
808 the right command to produce a commit with exactly the commit
809 identifier shown above. Can you do it?)
811 #### 2.7.6 Fixing up a broken commit (before anyone else sees it)
813 So now that we've cloned a local repository, made a change to the
814 code, setup our name and email address, and made a commit with a
815 careful message, we're just about ready to share our change with the
816 world. But wait, we forgot to try to compile it didn't we?
819 cc -c -o hello.o hello.c
820 hello.c:10:9: warning: missing terminating " character
821 hello.c:10:9: warning: missing terminating " character
822 hello.c: In function ‘main’:
823 hello.c:10: error: missing terminating " character
824 hello.c:11: error: expected ‘)’ before ‘;’ token
825 hello.c:13: warning: passing argument 1 of ‘printf’ makes pointer from integer without a cast
826 hello.c:13: error: expected ‘;’ before ‘}’ token
827 make: *** [hello.o] Error 1
829 Oh look. The code's broken and doesn't compile. We don't want to share
830 code in this state. For situations where you notice one tiny detail
831 that got left out of the last commit, (a silly syntax error, a
832 misspelling in a comment or commit messsage), git provides a very
833 handy tool for just changing the last commit.
835 So fix that typo, (a missing 'n' between the '\' and the '"'), with
836 your editor or with something like this:
838 sed -i 's/\\"/\\n"/' hello.c
840 And then you can just amend the previous commit rather than creating a
841 new one with the --amend option to "git commit":
843 $ git commit -a --amend
845 Note that we use -a to include the code change here. And that helps
846 point out a situation where "git commit" is useful without the -a
847 option, "git commit --amend" is a useful command for amend just the
848 last commit message, without committing any new code changes, even if
849 some files have been modified in the working tree.
851 And here's the final result:
854 commit 839b58d021c618bd0e1d336d4d5878a0082672e6
855 Author: Carl Worth <cworth@cworth.org>
856 Date: Thu Sep 27 23:55:00 2007 -0700
858 Added an extra line of output and fixed the typo bug.
860 diff --git a/hello.c b/hello.c
861 index 9a3ff79..ca750e0 100644
866 int main(int argc, char **argv)
868 - printf("hello, world!\");
869 + printf("hello, world!\n");
870 + printf("hello again!\n");
874 I can't help but point out that this really was a poor example for
875 --amend. The end result is a single commit that does two independent
876 things, (fixes one bug and adds one new feature). It's much better to
877 create a code history where each commit makes an independent change,
878 (and as small as possible). This is important for several reasons:
880 * Small changes are easier to review
882 * Independent changes are easier to split up if only part of the
883 series gets accepted "upstream" for one reason or another.
885 * The smaller the changes are the more useful the history will be
886 when actually using the history, not just viewing it. This is
887 particularly important when doing "git bisect"---that's a powerful
888 tool for isolating the single commit that introduces a bug. And
889 it's much more powerful if the commit it isolates is as small as
892 So it's a good thing this document is available under a license that
893 allows for distribution of modified versions. Someone should clean up
894 the --amend example to not teach bad habits like I did above. [Note:
895 All this bad-habit stuff was introduced by me, and was not present in
896 Bryan's original chapter. -Carl]
898 ### 2.8 Sharing changes
900 We mentioned earlier that repositories in git are
901 self-contained. This means that the commit we just created exists
902 only in our my-hello repository. Let’s look at a few ways that we can
903 propagate this change into other repositories.
905 #### 2.8.1 Pulling changes from another repository
907 To get started, let’s clone our original hello repository, which does
908 not contain the change we just committed. We’ll call our temporary
909 repository hello-pull.
912 $ git clone hello hello-pull
913 Initialized empty Git repository in /tmp/hello-pull/.git/
916 We could use the “git pull” command to apply changes from my-hello to
917 our master branch in hello-pull. However, blindly pulling unknown
918 changes into a repository is a somewhat scary prospect. The "git pull"
919 command is coneptually the combination of two commands, "git fetch"
920 and "git merge"; we can run those separately to examine the changes
921 before applying them locally. First we do the fetch:
924 $ git fetch ../my-hello
925 remote: Generating pack...
926 Unpacking 3 objects...
928 remote: Done counting 5 objects.
929 Result has 3 objects.
930 Deltifying 3 objects...
931 100% remote: (3/3) done
932 Total 3 (delta 1), reused 0 (delta 0)
934 The fetched commits (or commit in this case) are available as the name
935 FETCH_HEAD. [XXX: Shouldn't git-fetch print that name out to the user
936 if the user didn't provide a specific branch name to fetch into.] And
937 the difference between what we had before and what exists on
938 FETCH_HEAD can easily be examined with the ..FETCH_HEAD range
941 $ git log ..FETCH_HEAD
942 commit 839b58d021c618bd0e1d336d4d5878a0082672e6
943 Author: Carl Worth <cworth@cworth.org>
944 Date: Thu Sep 27 23:55:00 2007 -0700
946 Added an extra line of output and fixed the typo bug.
948 Since these commits actually exist in the local repository now, we
949 don't need to fetch or pull them from the remote repository again---we
950 can now use "git merge" to apply the previously fetched commits. (A
951 mercurial user might notice here that git does not have the race
952 condition between "hg incoming" and "hg pull" that mercurial has since
953 the commits are fetched only once.)
955 $ git merge FETCH_HEAD
956 Updating a1a0e8b..839b58d
959 1 files changed, 2 insertions(+), 1 deletions(-)
961 Notice that "git merge" reports that our branch pointer has been
962 updated from a1a0e8b to 839b58d. Also, this is a "fast forward"
963 meaning that the new commits are a linear sequence on top of the
964 commit we already hand. In other words, there wasn't any divergence
965 between these two repositories so no actual "merge" commit was
968 This separation of fetch and merge is useful when you need to
969 carefully review some changes before applying them. But often you're
970 in a situation where you know you trust the remote repository and you
971 simply want to pull those changes as conveniently as possible, (no
972 extra commands, no typing a magic name like FETCH_HEAD). This is the
973 case when the tracking upstream development of a project with git. And
974 in that case, the above steps are as simple as just executing "git
975 pull". So let's repeat all that the simpler way:
978 $ git clone hello hello-tracking
979 Initialized empty Git repository in /tmp/hello-tracking/.git/
982 $ git pull ../my-hello
983 remote: Generating pack...
984 remote: Done counting 5 objects.
985 Result has 3 objects.
986 Deltifying 3 objects...
987 Unpacking 3 objects...
988 remote: 100% (3/3) done
989 Total 3 (delta 1), reused 0 (delta 0)
991 Updating a1a0e8b..839b58d
994 1 files changed, 2 insertions(+), 1 deletions(-)
996 It should be plain to see that the "git pull" command really did the
997 combined sequence of "git fetch" and "git merge". Also, if you want to
998 pull from the same repository you cloned from originally, (which is
999 the common case for the upstream-tracking scenario), then "git pull"
1000 with no explicit repository is suffcient, and it will default to
1001 pulling from the same repository as the original clone.
1003 [XXX: The structure of the preceding section follows that of the
1004 original hgbook. But an alternate structure that arranged to pull from
1005 the originally cloned repository (as would be common) would allow for
1006 more straightforward use of git's features. For example, instead of
1007 the silly FETCH_HEAD stuff it would allow for "git fetch" and "git log
1008 master..origin" to be a very nice replacement for "hg
1009 incoming". Similarly, below, "git log origin..master" would make a
1010 nice replacement for "hg outgoing" which is something I didn't offer
1011 at all. One could also use git's remotes with the myriad repositories
1012 as used here, but it would require doing things like "git remote add
1013 <some-name> ../hello-pull" and that seems like a bit much to introduce
1014 for a turorial of this level. If nothing else, if the above section
1015 seems a little intimidating, understand that it's because things are
1016 not presented in the most natural "git way", (and I'm a little too
1017 tired to fix it tonight).]
1019 #### 2.8.2 Checking out previous revisions
1021 If any users of mercurial are reading this, they might wonder if
1022 there's a need for the equivalent of "hg update" after doing a "git
1023 pull". And the answer is no. Unlike mercurial, "git pull" and "git
1024 merge" will automatically update the workind-directory files as
1027 But there's another function provided by "hg update" which is to
1028 update the working-directory files to a particular revision. In git,
1029 this functionality is provided by the "git checkout" command. To
1030 checkout a particular branch, tag, or an arbitrary revions, simply
1031 give the appropriate name to the "git checkout" command. For example,
1032 to examine the files as they existed before the original typo
1033 introduction, we could do:
1035 $ git checkout 0a633bf5
1036 Note: moving to "0a633bf5" which isn't a local branch
1037 If you want to create a new branch from this checkout, you may do so
1038 (now or later) by using -b with the checkout command again. Example:
1039 git checkout -b <new_branch_name>
1040 HEAD is now at 0a633bf... Create a makefile
1042 The note that git gives us is to indicate that we are checking out a
1043 non-branch revision. This is perfectly fine if we are just exploring
1044 history, but if we actually wanted to use this revision as the basis
1045 for new commits, we would first have to create a new branch name as it
1048 For now, let's return back to the tip of the master branch by just
1049 checking it out again:
1051 $ git checkout master
1052 Previous HEAD position was 0a633bf... Create a makefile
1053 Switched to branch "master"
1055 #### 2.8.3 Pushing changes to another repository
1057 Git lets us push changes to another repository, from the repository
1058 we’re currently visiting. As with previous examples, above, we’ll
1059 first create a temporary repository to push our changes into. But
1060 instead of using "git clone", this time we'll use "git init" to make a
1061 repository from an empty directory. We do this to create a "bare"
1062 repository which is simply a repository that has no working-directory
1063 files associated with it. In general, you should only push to bare
1070 Initialized empty Git repository in /tmp/hello-push/
1072 And then we'll go back to our my-hello repository to perform the
1073 push. Since this is our very first push into this repository we need
1074 to tell git which branches to push. The easiest way to do this is to
1075 use --all to indicate all branches:
1078 $ git push ../hello-push --all
1079 updating 'refs/heads/master'
1080 from 0000000000000000000000000000000000000000
1081 to 839b58d021c618bd0e1d336d4d5878a0082672e6
1083 Done counting 18 objects.
1084 Deltifying 18 objects...
1086 Writing 18 objects...
1088 Total 18 (delta 3), reused 0 (delta 0)
1089 Unpacking 18 objects...
1091 refs/heads/master: 0000000000000000000000000000000000000000 -> 839b58d021c618bd0e1d336d4d5878a0082672e6
1093 For subsequent pushes we don't need to specify --all as "git push"
1094 will push all branches that exist in both the local and remote
1097 What happens if we try to pull or push changes and the receiving
1098 repository already has those changes? Nothing too exciting.
1100 $ git push ../hello-push
1101 Everything up-to-date
1103 #### 2.8.4 Sharing changes over a network
1105 The commands we have covered in the previous few sections are not
1106 limited to working with local repositories. Each works in exactly the
1107 same fashion over a network connection; simply pass in a URL or an ssh
1108 host:/path/name specification instead of a local path.
1111 Open Publication License
1113 Version 1.0, 8 June 1999
1115 ### D.1 Requirements on both unmodified and modified versions
1117 The Open Publication works may be reproduced and distributed in whole
1118 or in part, in any medium physical or electronic, provided that the
1119 terms of this license are adhered to, and that this license or an
1120 incorporation of it by reference (with any options elected by the
1121 author(s) and/or publisher) is displayed in the reproduction.
1123 Proper form for an incorporation by reference is as follows:
1125 Copyright (c) year by author’s name or designee. This material may be
1126 distributed only subject to the terms and conditions set forth in the
1127 Open Publication License, vx.y or later (the latest version is
1128 presently available at
1129 [http://www.opencontent.org/openpub/][http://www.opencontent.org/openpub/]).
1131 The reference must be immediately followed with any options elected by
1132 the author(s) and/or publisher of the document (see section D.6).
1134 Commercial redistribution of Open Publication-licensed material is
1137 Any publication in standard (paper) book form shall require the
1138 citation of the original publisher and author. The publisher and
1139 author’s names shall appear on all outer surfaces of the book. On all
1140 outer surfaces of the book the original publisher’s name shall be as
1141 large as the title of the work and cited as possessive with respect to
1146 The copyright to each Open Publication is owned by its author(s) or
1149 ### D.3 Scope of license
1151 The following license terms apply to all Open Publication works,
1152 unless otherwise explicitly stated in the document.
1154 Mere aggregation of Open Publication works or a portion of an Open
1155 Publication work with other works or programs on the same media shall
1156 not cause this license to apply to those other works. The aggregate
1157 work shall contain a notice specifying the inclusion of the Open
1158 Publication material and appropriate copyright notice.
1160 Severability. If any part of this license is found to be unenforceable
1161 in any jurisdiction, the remaining portions of the license remain in
1164 No warranty. Open Publication works are licensed and provided “as is”
1165 without warranty of any kind, express or implied, including, but not
1166 limited to, the implied warranties of merchantability and fitness for
1167 a particular purpose or a warranty of non-infringement.
1169 ### D.4 Requirements on modified works
1171 All modified versions of documents covered by this license, including
1172 translations, anthologies, compilations and partial documents, must
1173 meet the following requirements:
1175 1. The modified version must be labeled as such.
1176 2. The person making the modifications must be identified and the
1177 modifications dated.
1178 3. Acknowledgement of the original author and publisher if
1179 applicable must be retained according to normal academic citation
1181 4. The location of the original unmodified document must be identified.
1182 5. The original author’s (or authors’) name(s) may not be used to
1183 assert or imply endorsement of the resulting document without the
1184 original author’s (or authors’) permission.
1186 ### D.5 Good-practice recommendations
1188 In addition to the requirements of this license, it is requested from
1189 and strongly recommended of redistributors that:
1191 1. If you are distributing Open Publication works on hardcopy or
1192 CD-ROM, you provide email notification to the authors of your
1193 intent to redistribute at least thirty days before your
1194 manuscript or media freeze, to give the authors time to provide
1195 updated documents. This notification should describe
1196 modifications, if any, made to the document.
1197 2. All substantive modifications (including deletions) be either
1198 clearly marked up in the document or else described in an
1199 attachment to the document.
1200 3. Finally, while it is not mandatory under this license, it is
1201 considered good form to offer a free copy of any hardcopy and
1202 CD-ROM expression of an Open Publication-licensed work to its
1205 ### D.6 License options
1207 The author(s) and/or publisher of an Open Publication-licensed
1208 document may elect certain options by appending language to the
1209 reference to or copy of the license. These options are considered part
1210 of the license instance and must be included with the license (or its
1211 incorporation by reference) in derived works.
1213 1. To prohibit distribution of substantively modified versions
1214 without the explicit permission of the author(s). “Substantive
1215 modification” is defined as a change to the semantic content of
1216 the document, and excludes mere changes in format or
1217 typographical corrections.
1219 To accomplish this, add the phrase “Distribution of substantively
1220 modified versions of this document is prohibited without the
1221 explicit permission of the copyright holder.” to the license
1224 2. To prohibit any publication of this work or derivative works in
1225 whole or in part in standard (paper) book form for commercial
1226 purposes is prohibited unless prior permission is obtained from
1227 the copyright holder.
1229 To accomplish this, add the phrase “Distribution of the work or
1230 derivative of the work in any standard (paper) book form is
1231 prohibited unless prior permission is obtained from the copyright
1232 holder.” to the license reference or copy.