Manage (large) files "with" git but don't store the blobs in git.

An extension to git, sort of like Mercurial's largefiles except you can't convert existing repos (well, without using filter-branch or something).

Interesting thread about git replace refs and why it works the way it does.

A workflow taking advantage of git-rerere and continuous integration of lots of small feature branches.

tytso and linus on why in-repository .hgtags are a bad idea.

Mercurial users on why hgtags may make some sort of sense. (See reply from Matt Mackall further down).

Old but still largely correct. Fails to capture what "mutability" is really about.

In-depth look covering the good stuff; good if you don't know much about the internals of either.

1 and 2: Git's repo efficiently content, compressing deltas across all files in the tree.
3. Git keeps track of names carefully.

Trying to use mq to replace Git branches is a sad and painful experience.

There are a lot of questions on the Kiln Stackexchange about the confusing number of number of options for Mercurial branching. This is one which explains a bit about how to use bookmarks to do lightweight branching.

With very helpful comparisons to Git.

@glaforge Check out for some good Git resources

Great post on how to create a history-truncated repo in #git using orphan checkout and replacement refs

A clickable git cheatsheet showing how to move between different workflow areas (working tree, index, repos)

A nice collection of .gitignore templates for different types of projects.

Tutorial slides from Matthew McCullough giving a decent and quick overview of Git and its benefits.

Simple block of lighttpd config that will pass some URLs over to git-http-backend (git 1.6.6 and newer).

Junio on the git philosophy of branching.

Indeed, the title says it all.

A detailed walk through of one way to manage a development and release process using branches with git. Clean, plenty of example command, and a PDF summary diagram for printing.

Nice reference to how the various commands modify HEAD, staging area, and working directory.

"subversion’s internal model is fairly complex, but you are not expected to understand it. You just have to know the half dozen commands you’ll ever need, and you use them, and everything is fine. Git’s model is fundamentally fairly simple [...] but you are expected to understand it fully to use git effectively."

@dangerdave Try instead of #git show-branch (but yeah, maybe it ought to be fixed.) Do you log hg glog better?

How to create a local mirror of android using repo. Need to investigate its --mirror option more.

A release of gerrit that does not require Google App Engine to run. Pretty complete looking documentation included. Nice!

"Committing in git with only some changes added to the staging area still results in an "atomic" revision that may never have existed as a working copy and may not work." -- that is, git (and darcs and bzr unshelve) require that the developer is careful to really test the commits he has, before pushing. Author argues that bzr is better, but there's interesting discussion in comments too.

Tutorial on how to migrate a website into github pages---github requires your website on a special branch, so here's a pointer to some magic that takes a directory, turns it into a special branch, and then "mounts" it as a submodule.

Linus on the meaning of git-fsck output, how to fix it---if necessary---and when *not* to fix it. (Now part of the git documentation.)

@johnnieingram Isn't svn 1.5 supposed to help deal with this? Not that I use svn, preferring #git myself...

Junio on how to maintain topic branches, bug fixes, and a workflow to avoid missing related fixes when merging between branches.

Martin Krafft explains how to do a clean git-svn import, rebase a git history on top of it, and convert patches to branches; with commands you can copy-paste. Plus a short bonus lesson on merging. In a Debian packaging context but still useful elsewhere.

A very detailed walkthrough from Martin Krafft on how to maintain a Debian package in git, tracking a git upstream. Includes discussion of branch usage showing examples for topics and integration, with commands you can run. Also the use of tags. Useful even for non-Debian work! From 2007; some git commands may have changed.

Tagging bookmarks in delicious as ff:git-world and auto-feeding into friendfeed #git. (Thanks @judell)

Nice article on how to manage branches that have some changes that need to get merged back to master, and some that don't. These can be release branches or they can be branches targeted at specific customers.

A nice post on different git workflows. The best part is about branch naming: "Using ‘origin’ as the name of your remote and ‘master’ as the name of your main branch is just the default settings git gives you. Neither name is magic. So, I renamed ‘origin’ to ‘github’ in .git/config to be explicit about where the code is going. Then, I created a new branch ‘development’ to reflect the code that is under the mainline of development."

How you should format commit messages when using git, but just as good for an version control system.

Using terms like "directed acyclic graph", explains the guts of git. Good for quick overview and reference.

How to manage git commits across multiple repositories, etc.

An excellent description of basic workflow and explanation of git's index.

How to use "git rebase" with topic branches and the relative workflows used by leaf-developers versus subsystem maintainers and core integrators. The thoughts of Linus himself.

various git resources as compiled by the folks at 37 Signals

Fabulously detailed slides (and audio though I haven't listened) on how git works. Does not discuss the intricacies of pack management which still seems a bit of a black art.

Some technical notes on how deltas work and how git keeps things small.

Nice summary of git-svn workflows.

April 2006 comparison of various VCS systems (git, mercurial, monotone, darcs).