+ $ git checkout --track origin/v2
+
+The last command creates a new local branch v2, sets
+remotes/origin/v2 as its upstream remote branch and checks it out into
+the working directory.
+
+
+Branches and branches
+=====================
+
+Git terminology can be a bit misleading. Take, for example, the term
+"branch". In git it has two meanings. A branch is a directed line of
+commits (possibly with merges). And a branch is a label or a pointer
+assigned to a line of commits. It is important to differentiate when
+you talk about commits and when about their labels. Lines of commits
+are by itself unnamed and are usually only lengthening and merging.
+Labels, on the other hand, can be created, moved, renamed and deleted
+freely.
+
+
+Remote repository and remote branches
+=====================================
+
+Another example of slightly misleading terminology. Remote
+repositories are really remote, you access them via network (well, a
+remote repository can be on your local disk, but it's still remote
+because it's not the current repo).
+
+Remote branches, on the other hand, are branches (pointers to commits)
+in your local repository. They are there for you to remember what
+branches and commits have been pulled from and pushed to what remote
+repos (you can pull from and push to many remotes). Remote branches
+live under ``remotes/REMOTE`` namespaces, e.g. ``remotes/origin/v2``.
+
+To see the status of remote branches run::
+
+ $ git branch -rv
+
+To see local and remote branches (and tags) pointing to commits::
+
+ $ git log --decorate
+
+You never do your own development on remote branches. You create a
+local branch that has a remote branch as upstream and do development
+on that local branch. On push git updates remote branches, and on pull
+git updates remote branches and fast-forwards, merges or rebases local
+branches.
+
+When you do an initial clone like this::
+
+ $ git clone -b v1 http://git.python.org/python.git
+
+git clones remote repository ``http://git.python.org/python.git`` to
+directory ``python``, creates remote branches and checks out branch
+``v1`` into the working directory.
+
+Updating local and remote branches
+----------------------------------
+
+There is a major difference between
+
+::
+
+ $ git fetch REMOTE BRANCH
+
+and
+
+::
+
+ $ git fetch REMOTE BRANCH:BRANCH
+
+The first command fetches commits from the named BRANCH in the REMOTE
+repository that are not in your repository and leaves the id (the
+hash) of the head commit in file .git/FETCH_HEAD. But it doesn't
+update any branch (doesn't move any pointer).
+
+The second command fetches commits from the named BRANCH in the REMOTE
+repository that are not in your repository and updates both the local
+branch BRANCH and its upstream remote branch. But it refuses to update
+branches in case of non-fast-forward. And it refuses to update the
+current branch.
+
+The first command is used internally by ``git pull``.
+
+::
+
+ $ git pull REMOTE BRANCH
+
+is equivalent to
+
+::
+
+ $ git fetch REMOTE BRANCH
+ $ git merge FETCH_HEAD # FETCH_HEAD is a literal here
+
+Certainly, BRANCH in that case should be your current branch. If you
+want to merge a different branch into your current branch first update
+that non-current branch and then merge::
+
+ $ git fetch origin v1:v1 # Update v1
+ $ git pull --rebase origin v2 # Update the current branch v2 using
+ # rebase instead of merge
+ $ git merge v1
+
+It is possible to configure git to make it fetch/pull a few branches
+or all branches at once, so you can simply run
+
+::
+
+ $ git pull origin
+
+or even
+
+::
+
+ $ git pull
+
+Push
+''''
+
+Pushing is a bit simpler. There is only one command ``push``. When you
+run
+
+::
+
+ $ git push origin v1 v2
+
+git guesses (knowing upstream remote branches) that you really want
+
+::
+
+ $ git push origin v1:v1 v2:v2
+
+Git pushes commits to the remote repo and updates remote branches. Git
+refuses to push commits that aren't fast-forwardable. You can
+force-push anyway, but please remember - you can force-push to your
+own repositories but don't force-push to public or shared repos. If
+you find git refuses to push commits that aren't fast-forwardable,
+better fetch and merge commits from the remote repo (or rebase your
+commits on top of the fetched commits), then push. Only force-push if
+you know what you do and why you do it. See the section `Commit
+editing and caveats`_ below.
+
+It is possible to configure git to make it push a few branches or all
+branches at once, so you can simply run
+
+::
+
+ $ git push origin
+
+or even
+
+::
+
+ $ git push
+
+Git refuses to push a branch if it's the current branch in the remote
+non-bare repository: git refuses to update remote working directory.
+You really should push only to bare repositories. For non-bare
+repositories git prefers pull-based workflow.
+
+Tags
+''''
+
+Git automatically fetches tags that point to commits being fetched
+during fetch/pull. To fetch all tags (and commits they point to) run
+``git fetch --tags origin``. To fetch some specific tags fetch them
+explicitly::
+
+ $ git fetch origin tag NAME1 tag NAME2...
+
+For example::
+
+ $ git fetch origin tag 1.4.2 tag 2.1.7
+
+Git doesn't automatically pushes tags. That allows you to have private
+tags (lightweight tags are also private for a repo, they cannot be
+pushed). To push tag(s) list them explicitly::
+
+ $ git push origin tag 1.4.2
+ $ git push origin v1 v2 tag 2.1.7