Git Howto Index
===============

Here is a collection of mailing list postings made by various
people describing how they use Git in their workflow.

* link:howto/keep-canonical-history-correct.html[keep-canonical-history-correct] by Junio C Hamano <gitster@pobox.com>

This how-to explains a method for keeping a
project's history correct when using git pull.


* link:howto/maintain-git.html[maintain-git] by Junio C Hamano <gitster@pobox.com>

Imagine that Git development is racing along as usual, when our friendly
neighborhood maintainer is struck down by a wayward bus. Out of the
hordes of suckers (loyal developers), you have been tricked (chosen) to
step up as the new maintainer. This howto will show you "how to" do it.


* link:howto/new-command.html[new-command] by Eric S. Raymond <esr@thyrsus.com>

This is how-to documentation for people who want to add extension
commands to Git.  It should be read alongside api-builtin.txt.


* link:howto/rebase-from-internal-branch.html[rebase-from-internal-branch] by Junio C Hamano <gitster@pobox.com>

In this article, JC talks about how he rebases the
public "pu" branch using the core Git tools when he updates
the "master" branch, and how "rebase" works.  Also discussed
is how this applies to individual developers who sends patches
upstream.


* link:howto/rebuild-from-update-hook.html[rebuild-from-update-hook] by Junio C Hamano <gitster@pobox.com>

In this how-to article, JC talks about how he
uses the post-update hook to automate Git documentation page
shown at https://www.kernel.org/pub/software/scm/git/docs/.


* link:howto/recover-corrupted-blob-object.html[recover-corrupted-blob-object] by Linus Torvalds <torvalds@linux-foundation.org>

Some tricks to reconstruct blob objects in order to fix
a corrupted repository.


* link:howto/recover-corrupted-object-harder.html[recover-corrupted-object-harder] by Jeff King <peff@peff.net>

Recovering a corrupted object when no good copy is available.


* link:howto/revert-a-faulty-merge.html[revert-a-faulty-merge] by Linus Torvalds <torvalds@linux-foundation.org>, Junio C Hamano <gitster@pobox.com>

Sometimes a branch that was already merged to the mainline
is later found to be faulty.  Linus and Junio give guidance on
recovering from such a premature merge and continuing development
after the offending branch is fixed.


* link:howto/revert-branch-rebase.html[revert-branch-rebase] by Junio C Hamano <gitster@pobox.com>

In this article, JC gives a small real-life example of using
'git revert' command, and using a temporary branch and tag for safety
and easier sanity checking.


* link:howto/separating-topic-branches.html[separating-topic-branches] by Junio C Hamano <gitster@pobox.com>

In this article, JC describes how to separate topic branches.


* link:howto/setup-git-server-over-http.html[setup-git-server-over-http] by Rutger Nijlunsing <rutger@nospam.com>



* link:howto/update-hook-example.html[update-hook-example] by Junio C Hamano <gitster@pobox.com> and Carl Baldwin <cnb@fc.hp.com>

An example hooks/update script is presented to
implement repository maintenance policies, such as who can push
into which branch and who can make a tag.


* link:howto/use-git-daemon.html[use-git-daemon] 



* link:howto/using-merge-subtree.html[using-merge-subtree] by Sean <seanlkml@sympatico.ca>

In this article, Sean demonstrates how one can use the subtree merge
strategy.


* link:howto/using-signed-tag-in-pull-request.html[using-signed-tag-in-pull-request] by Junio C Hamano <gitster@pobox.com>

Beginning v1.7.9, a contributor can push a signed tag to her
publishing repository and ask her integrator to pull it. This assures the
integrator that the pulled history is authentic and allows others to
later validate it.


