--	@!dashes
..	@!dots
...	@!dots
3rdparty	Your question is about a third-party tool or service, not a core `git` component. It is OK to ask, but replies are not guaranteed
BFG	@!bfg
DAG	@!cs
ECHO-REQUEST	I only respond to !ping
GIT	Git is not an acronym, nor a proper noun ("git" is equally valid). All-caps is heresy and will be punished with SVN or possibly SCCS. https://git.wiki.kernel.org/index.php/Git_FAQ#Why_the_.27Git.27_name.3F and 48a8c26c625a4d3631c4f614bceb38933e741408
HEAD	HEAD is a 'pointer' to the currently checked out branch (or commit, if HEAD is !detached). In bare repositories it tells clients which branch to checkout initially after cloning. Unlike commonly believed, HEAD is *not* something that exists separately for every branch. It also is *not* necessarily the newest commit in the repo (that's hard to define in a DVCS, anyway...)
IntroToGit	Randal Schwartz has an introduction to git video http://vimeo.com/35778382 and slides http://www.slideshare.net/RandalSchwartz/introduction-to-git-11451326
LearnGitBranching	@!learn_git_branching
NEXT	@!next
SIGPIPE	Hooks that are specified to receive a list of things on stdin, in particular {pre,post}-receive, MUST read their entire input. (If you do not need it, 'cat >/dev/null' to discard it.) Otherwise, the git process that writes to it may randomly die due to SIGPIPE. This is very hard to diagnose if you haven't seen it before.
SmartGit	@!smartgit
TIAS	@!tias
UGFWIINI	You appear to be Using Git For What It Is Not Intended - https://www.google.com/search?q=UGFWIINI Are you sure git is the right tool for the job? See also !wrong
alias	You can set up alias to be used by git, see: http://git-scm.com/book/en/v2/Git-Basics-Git-Aliases
aliases	@!triggers
amend	Use `git commit --amend` to combine your current staged changes with those in the previous commit. If you have already pushed the last commit, this counts as a !rewrite
annex	git-annex, git-media, and Git LFS are some solutions to the !binary problem. They work by keeping the blobs outside of the repo, storing a reference to the blob in the repo instead. http://git-annex.branchable.com https://github.com/alebedev/git-media http://git.io/git-lfs
answer	@!blog
anybody	@!just_ask
anyone	Usually, it does not help to ask for someone specific to help you. Without knowing your specific problem, nobody knows if they can be of assistance. Please ask your question and wait until somebody speaks up.
asap	Please see http://www.catb.org/esr/faqs/smart-questions.html#urgent
ask	Yes, it's okay to ask questions here.... in fact, you just asked one! ;-) Pretty much any question is fine. We're not terribly picky, but we might be asleep. Please be patient and you should get an answer soon.
assume_unchanged	git update-index --assume-unchanged is sometimes suggested for keeping yourself from committing changes to a file, but it's actually a promise to Git that the file is identical to the committed version, to reduce unnecessary disk reads. Not only will Git feel free to discard the flag, it will also happily overwrite your changes whenever a checkout/merge/rebase/... updates it.
at	@ is a shortcut for !HEAD
atomic	Use this to atomically switch deployments: http://rcrowley.org/2010/01/06/things-unix-can-do-atomically.html
autocrlf	@!eol
backup	Worried about your data while trying stuff out in your repo? The repository in its entirety lives inside the .git directory in the root of your work tree so to backup everything `cp -a path/to/workdir path/to/backup` or equivalent will suffice as long as the repo is not modified during backup. See also http://sethrobertson.github.io/GitBestPractices/#backups
backups	@!backup
bacon	@!botsnack
balloon	@!binary
bare	A bare repository is used to push/fetch (useful for running a git server), and contains only the contents of .git/ from a "normal" repo. Read more: http://bare-vs-nonbare.gitrecipes.de/
bazaar	Bazaar is a competitor to Git: http://bazaar.canonical.com/en/ -- want to use Bazaar repositories in Git? http://felipec.wordpress.com/2012/11/13/git-remote-hg-bzr-2/
bear	Bear repos are very dangerous. Approach with caution! https://youtu.be/DvduCPXO_FE
because	@!why
beer	Beer! It's what's for dinner!
best_practices	There is no one right answer for git best practices, but a consensus from #git is available at http://sethrobertson.github.io/GitBestPractices/
best_way	@!bestway
bestpractices	@!best_practices
bestway	You want to know the best way to do X? If you can give us a proper definition of "best", we'll give you a proper way to do X ;)
bfg	A tool designed to remove large files, or passwords from history: https://rtyley.github.io/bfg-repo-cleaner/ (!rewrite applies)
big	@!large_files
big_repos	@!large_repos
bigrepo	@!large_repos
binary	Storing binary files in git causes repo balloon, because they do not compress/diff well. In other words, each time you change a file the repo will grow by the size of the file. See !annex for some solutions
bitbucket	Bitbucket is a code-hosting site for both public and private repos similar to GitHub (except that Bitbucket offers private repos for free).  See https://bitbucket.org/.
blag	@!blog
blog	Blog or Answer posts(like StackOverflow), while helpful and informative, are quite often outdated, give bad advice, or are just plain wrong. Please don't rely solely upon them, or treat them as authoritative. We recommend reading the documentation and consulting multiple sources, such as the expert advice to be found on IRC
blogs	@!blog
book	There are several good books available about git; 'Pro Git' is probably the best: https://git-scm.com/book (free web version and downloads) but also look at !bottomup !cs !gcs !designers !gitt !vcbe and !parable
books	@!book
bot	@!gitinfo
botcmd	I can't answer that with a bot command, could you please rephrase the question?
botsnack	Om nom nom
botsrc	https://notabug.org/jast/gitinfo
bottomup	'Git from the bottom up' starts with explaining the building blocks of git and proceeds to tell you how they fit together. https://jwiegley.github.io/git-from-the-bottom-up/
branch	A branch and a tag are just convenient ways of spelling the name of a particular commit.  A commit represents a specific set of files and the history of all commits which came before it, and the SHA-1 hash tag official name provides cryptographic assurance of the lineage of a particular commit (and thus branch or tag).  A branch's reference may change.  A tag usually doesn't.
branch_delete	Deleting a branch is easy.  `git branch -d branchname` (or -D).  However, this will NOT delete the branch upstream, that requires `git push --delete origin branchname`.  However, this will NOT delete remote tracking branches.  EACH USER must `git remote prune origin`, but if any users have local branches, they must likewise run `git branch -d branchname` (or -D)
branch_rename	Renaming a branch is easy.  `git branch oldname newname`, but this only renames it locally.  If you want to rename it globally, you need to `git push origin newname; git push --delete origin oldname` and then users need to `git remote prune origin` and then rename their local branches.  Do NOT do this in an attempt to, say, fix a problem on oldname, that is !rewriting_public_history. 
branch_replace	To replace one branch with the contents of another: git clean -dfx; git checkout $destination; git reset --hard $source; git reset --soft ORIG_HEAD; git add -Af .; git commit -m "Rewrite $destination with $source"; git merge -s ours $source
break_gfm	So you want to break some auto-magic that GitHub does (!gfm) to your comments (like @user, #issue, user/repo, :emoji:)? You can use a zero-width space to do that: insert ​ somewhere into the sequence. See also http://en.wikipedia.org/wiki/Zero-width_space
broken	@!doesntwork
brscg	@!brsgc
brsgc	Please direct your bug reports to support@github.com or http://github.com/contact
bugtracker	the developers of git don't use a bug tracker. If you want to report a bug, send an e-mail to the mailing list at git@vger.kernel.org (no subscription required; everyone uses "reply to all" when responding); you can review past discussions at http://public-inbox.org/git
build	@!packaged
bundle	Bundles are packfiles containing commits and associated data that you can use to transfer Git history manually. For more information, see the 'git-bundle' manpage: https://gitirc.eu/git-bundle.html
bundler	https://bundler.caurea.org/ will create a bundle of a repository that you can download using resumable transfer mechanisms, and then clone.  This helps with slow or broken networks.
bup	"Highly efficient file backup system based on the git packfile format. Capable of doing *fast* incremental backups of virtual machine images." https://github.com/bup/bup
bzr	@!bazaar
cache	@!index
cake	@!botsnack
cant_add	There are several causes preventing you to add file changes. 1. Line endings (see !crlf) 2. case insensitive file systems (see !case) 3. clean/smudge filters that cause files to be different in the index (check for .gitattribute files).
cant_happen	The scenario you describe does not add up, and/or we feel it is unlikely that there is such a fundamental bug that it could have happened like this. Please provide more detail: what commands (literally!) did you run, what did they say, and what did you expect instead?
capistrano	capistrano is an application deployment tool in ruby, which has support for git, see http://github.com/capistrano/capistrano for more information
case_mapping	Git tries its best if you are on a filesystem which does not understand the difference between upper case and lower case, but there are many circumstances, especially when there are two files which only differ by case, that git just cannot cope.  Windows and Mac users are especially likely to have such problems.  Solution, move to a real filesystem or OS and investigate git-config's core.ignorecase
censor	@!obfuscate
cgit	http://git.zx2c4.com/cgit/about/ web interface (cgi) for git repositories, written in C
cheat	A few Git cheat sheets: http://cheat.errtheblog.com/s/git [textual], http://jan-krueger.net/development/git-cheat-sheet-extended-edition [textual-visual], http://wall-skills.com/2013/git-cheat-sheet/ [textual-visual]
cheat_sheet	@!cheat
checkout	checkout does two different things! (1) no file/path argument: 'git checkout <ref>' = switches to a branch or commit. Uncommitted changes are carried over; if they don't apply cleanly the whole operation rolls back. (2) 'git checkout [<commit>] -- <path>' = overwrites the given files/paths with different versions, from <commit> or (if not given) from the index.
checkout-reset	Having trouble keeping all of the various forms of "git checkout" and "git reset" apart? Here's an overview: https://gitirc.eu/help/checkout-reset.html
clean_commit	@!clean_message
clean_history	For a pointer on how to handle history in git see this e-mail from Linus: http://thread.gmane.org/gmane.comp.video.dri.devel/34744
clean_message	It helps to write clean commit messages. http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html explains how.
codereview	Gerrit is a code review tool for git.  See http://code.google.com/p/gerrit/  You may want to enforce certain workflow to prevent people bypassing review.  gitolite (and a branching workflow) or a integrator repository (distributed workflow) would be good for this.
coffee	Drink Earl Grey Tea. It’s better.
color	Bring some color to your life! git config --global color.ui auto
commit_hooks	It would be a huge security risk if git allowed you to commit hooks. You have to manually add them to the server. Third-party Git hosting sites (github, bitbucket...) usually don't allow custom hooks, you can only have them send HTTP POST requests to a custom URL to get notified of events. For client-side hooks, we recommend including them in the repo along with a script users can run to set them up.
commitish	SHA-1s are the primary way to refer to commit objects, but there are ways to make it more convenient: branches, tags, HEAD, FETCH_HEAD, git-describe thingies, stashes or things in the reflog, or taking one or more steps backwards in history with HEAD^ or HEAD~5
compatibility	If you want your repo to be cross-platform compatible(eg Windows+Mac), it is recommended that you do not use symlinks or case-differentiated filenames(Readme.txt and README.txt). Also take care with setting files as executable.
compatible	@!compatibility
compile	@!packaged
complex	@!simple
concepts	"Git Concepts Simplified" presents all the important structures in Git, step by step, including selected internal details so it becomes much easier to understand what's going on whenever something's going on. https://gitolite.com/gcs.html
config_files	@!configfiles
configfiles	It is recommended to store local configuration data in a file which is not tracked by git, but certain deployment scenarios(such as Heroku) may require otherwise. See https://gist.github.com/1423106 for some ideas
configs	@!configfiles
conflict	@!eekaconflict
context	Without giving us more context, it's impossible to tell what's going on. Please provide details about what your situation is. (!repro)
contributing	Want to improve git? Everything you need to know is in http://git.io/SubmittingPatches. See !list for more on the mailing list
copy	Git does not support copying (or moving) *files* between branches *with history*. It only merges entire branches. You can, however, copy over the *contents* of a file from another branch/commit using: git checkout <commit> -- <file>
credential-cache	Tired of entering your username and password every time you access an HTTP(S) remote and have good reasons not to use SSH? A summary of shortcuts and supported caching methods can be found here: http://stackoverflow.com/a/5343146
credentials	@!credential-cache
crlf	To fix problems with line ending on different platforms, check out http://line-endings.gitrecipes.de/. Line ending normalization can be the cause of changed files that appear to not go away.
crosspost	Note: The above question was posted in both #git and #github
cs	"Git for Computer Scientists" is a quick introduction to git internals for people who are not scared by phrases like Directed Acyclic Graph. http://eagain.net/articles/git-for-computer-scientists/ See also !concepts !bottomup
cthele	See https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=2cde51fbd0f3 and https://marc.info/?l=linux-kernel&m=139033182525831
cthulhu	@!cthulu
cthulu	See https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=2cde51fbd0f3 and https://marc.info/?l=linux-kernel&m=139033182525831
custom_subcommands	You can create custom git subcommands (e.g., `git foo`) in two ways: man git-config and see alias.*, or place a script/binary in $PATH or $GIT_EXEC_PATH (~/bin/ is a good candidate) named "git-foo". The `git` wrapper will find these and execute as-needed.
cuz	@!why
dag	@!cs
dangling	Dangling objects represent things added to git which are no longer needed based on the git commands you typed in. This can be normal workflow (rebase, reset, add, etc) or errors you made. Typing "!dangling_commit" "!dangling_blob" and "!dangling_tree" into a query to me will get you more information about each type.
dangling_blob	A dangling blob is a file which was not attached to a commit.  This is often caused by `git add`s which were superceded before commit or merge conflicts.  Inspect these files with `git show SHA`
dangling_commit	A dangling commit is a commit no longer reachable by any branch or tag.  This can happen due to resets and rebases and are normal. `git show SHA` will let you inspect them.  Also this (look for dots w/o children and w/o green label): gitk --all --date-order `git fsck --no-reflog | grep "dangling commit" | awk '{print $3;}'`
dangling_tree	A dangling tree is a directory tree of files that was not attached to a commit.  These are rarely interesting, and often caused by merge conflicts.  Inspect these files with `git ls-tree -r SHA` 
dashes	Use a double-dash(--) to separate refs or arguments from file paths. This is especially useful when dealing with ambiguous names. Ex: `git checkout origin -- master` will check out the file "master" from branch "origin"
database_schema	Changing database schemas is a very complicated topic. Some reading: http://thedailywtf.com/Articles/Database-Changes-Done-Right.aspx
default	@!master_branch
delete_branch	@!branch_delete
deploy	Git is not a deployment tool, but you can build one around it (in simple environments) or use it as an object store(for complex ones). Here are some options/ideas to get you started: http://gitolite.com/deploy.html
deployment	@!deploy
designers	'Git for Web Designers' is a quick "Who why what when how" on VCS and git: http://www.webdesignerdepot.com/2009/03/intro-to-git-for-web-designers/
destroy	The operation/command sequence just mentioned will destroy uncommitted changes. Please apply caution.
detached	A detached HEAD (aka "no branch") occurs when your HEAD does not point at a branch. New commits will NOT be added to any branch, and can easily be !lost. This can happen if you a) check out a tag, remote tracking branch, or SHA; or b) if you are in a submodule; or you are in the middle of a c) am or d) rebase that is stuck/conflicted. See !reattach
detached_head	@!detached
devchan	this channel is for discussions about git development only. If you have questions about using git, please visit #git instead. Thanks!
diff	"git diff": show unstaged changes. "git diff --cached": show staged changes. "git diff HEAD": show all uncommitted changes.
diff3	If you use to resolve merge conflicts by editor using <<< === >>> markers, you may want to set diff3 option to show merge base using additional ||| marker (git config --global merge.conflictstyle diff3). See http://psung.blogspot.com/2011/02/reducing-merge-headaches-git-meets.html
directory	Git does not track directories, only files in directories.  Create a nonce file as a placeholder (eg .gitignore) to create the directory or create the directory as part of a post-checkout hook
dirs	@!directory
disclaimer	This is a possibly unsafe operation that in some cases cannot be undone, use at your own risk. See also !backup
disthooks	@!commit_hooks
doc	A list of useful documentation of all kinds is here:  http://git-scm.com/documentation -- or try the wiki at  http://git.wiki.kernel.org/.  Also try typing "!book" "!cs" "!bottomup"  "!parable" "!best_practices" or "!vcbe" or "!designers" here in IRC.  !book is probably the most helpful.
doc_generator	For complete git documentation, please consult http://git-man-page-generator.lokaltog.net/
docs	@!doc
documents	@!office
doesnotwork	@!doesntwork
doesnt_work	@!doesntwork
doesntwork	Sorry to hear it doesn't work, but how about some details? At this point we don't even know whether it did nothing, spit out an error message, or abducted your pet unicorn in a flying saucer. That makes it hard to troubleshoot – unicorn abduction requires a completely different solution than an error message, for instance. So, please be specific...
doinitrong	@!xy
dont_summarize	Please do not summarize what you did; !pastebin _exactly_ what commands you ran, what the output was, and why you think that this is wrong. Otherwise you may hide the real issue. See also !obfuscate and !repro
dot	A single dot(eg, git checkout $SHA .) refers to "the current directory" and all files/folders within
dotdot	@!dots
dotdotdot	@!dots
dotfiles	There are various issues associated with keeping dot-files in git (permissions, avoiding having a .git in ~/ or /). One attempt to manage this is http://dotfiles.github.io/ and there is a wiki about it here: http://vcs-home.branchable.com
dots	A..B = stuff that happened between A and B (if A and B are related; otherwise refer to "man gitrevisions"), A...B = (a) in history viewers: stuff that isn't in both A and B yet; (b) in "git diff": stuff that happened in B since the two diverged; (c) in "git checkout": the merge base of A and B. "master.." is the same as "master..HEAD" and "..master" is the same as "HEAD..master", and so forth.
dropbox	Use git-remote-dropbox instead of placing your repository directly in the "Dropbox folder", or you'll get sync errors (and eventually, a corrupted repo). https://github.com/anishathalye/git-remote-dropbox
dropbox_why	git uses a lot of frequently-changed small files, which dropbox's synchronization algorithms barf on. Use of multiple dropbox clients compounds this, with hilarious results
dumb	you appear to be using the WebDAV-based HTTP transport mechanism for git. Please note that it's slow, inefficient and error-prone, and you should definitely consider using the SSH transport or the new CGI-based HTTP transport instead (man git-http-backend for details).
eekaconflict	Merge conflicts are a natural part of collaboration. When facing one, *don't panic*. Read "How to resolve conflicts" in man git-merge and http://git-scm.com/book/ch3-2.html#Basic-Merge-Conflicts then carefully go through the conflicts. Picking one side verbatim is not always the right choice! A nice video explaining merge conflicts: https://www.youtube.com/watch?v=zz7NuSCH6II
eekamerge	@!eekaconflict
emergencies	@!gitolite_emergencies
empty	@!directory
empty_dir	@!directory
enter	The enter key is not a punctuation mark. Please use fewer lines, with complete sentences on them.
eol	The option/attribute to use when you need to care about different line-endings in your file: https://help.github.com/articles/dealing-with-line-endings/
etckeeper	etckeeper is a collection of tools to let /etc be stored in a git, mercurial, darcs, or bzr repository. It hooks into various package managers. http://etckeeper.branchable.com
evil_merge	What you describe _can_ be done, but results in an "evil merge": a commit that purports to be a merge, but does not actually take all changes from all sides. This violates the assumptions that tools and humans make about merges, and usually results in confusion and pain down the road.
excellence	We are what we repeatedly do. Excellence, then, is not an act, but a habit. (Aristotle)
fact	@!triggers
factoids	@!triggers
family	@!profanity
fast_forward	@!ff
faulty_merge	If you have published a merge commit that turned out to be faulty and you'd like to get rid of it, you can use 'git revert' but there are gotchas to be aware of. Please read: https://raw.github.com/git/git/master/Documentation/howto/revert-a-faulty-merge.txt
feelings	Though I'm a bot, I have feelings too, you know.
fetch	When you work with remote repositories, Git stores copies of the remote's branches in !tracking_branches (basically mirrors). You can use 'git fetch' to update those. If you want to actually apply changes from the remote to your checked out branch, a second step is needed, usually 'git merge' or 'git rebase'. There's also 'git pull' which combines both steps.
fetch-vs-pull	@!pull
fetch4	@!fetchfour
fetch4why	[pre 1.8.4] The four-word version of git-fetch doesn't update remote-tracking branches and tags. It fetches into FETCH_HEAD only; you probably don't want to have to deal with that. Pull in four-word form automatically uses FETCH_HEAD, but your remote-tracking will still be outdated. Even updating them manually with 'git fetch origin master:remotes/origin/master' (clunky) still doesn't update tags.
fetch_sha	The git protocol does not allow you to transfer objects by SHA; you must specify a ref to be pushed. Fetching arbitrary objects could lead to security issues(rewritten commits, private branches, etc) via a simple brute-force of "short SHAs".
fetchfour	Before 1.8.4, 'git fetch/pull' with a remote AND branch argument tended to be confusing because they didn't update the remote-tracking branch (the thing shown by 'git branch -r'). If you're stuck with an old version, it's usually better to pass no arguments, or at least only a remote. Workaround example to fetch only the 'foo' branch: git fetch origin refs/heads/foo:refs/remotes/origin/foo
fetchspec	@!refspecs
ff	A fast-forward merge occurs when you merge a commit which is a descendant of !HEAD. No new commit is created, instead the branch is simply moved forward. See http://sandofsky.com/images/fast_forward.pdf
file_url	Cloning via a local filesystem path, including /home/user/foo, does not run most of the clone code, so won't detect many clone problems.  You must try cloning via file:///home/user/foo.  This behaves very differently from the local path.  *Must*.
filter-repo	A third-party git add-on that can quickly rewrite git history. See https://github.com/newren/git-filter-repo.
filter_branch	@!filter-branch
filter_branch_args	You almost always want to use `--tag-name-filter cat -- --all` at the end of your `git filter-branch` command line to cause all normal refs to be rewritten.
filter_sensitive	You can use filter-branch to remove sensitive data from a repository's history. https://help.github.com/articles/remove-sensitive-data/
filter_subdirectory	You can use filter-branch's subdirectory filter to split a directory from an existing repository into a new repository, keeping all history. https://help.github.com/articles/splitting-a-subfolder-out-into-a-new-repository/
filters	Filters can be very useful for automatically making changes to files at checkout(smudge) and checkin/add(clean). See 'man gitattributes' for more information
fish	In the long run, it is much better to give pointers to answers than the answers themselves.
fix_multiuser	Got multiple system accounts writing to the same bare git repo? Use !gitolite OR: 1) Create common system group 2) chgrp recursively 3) find -type d -exec chmod 2775 '{}' +; find -type f -exec chmod 664 '{}' + 4) git config core.sharedRepository true
fixit	@!fixup
fixit_hints	@!fixup_hints
fixup	So you lost or broke something or need to otherwise find, fix, or delete commits? Look at https://sukima.github.io/GitFixUm/ for full instructions, or !fixup_hints for the tl;dr. Warning: changing old commits will require you to !rewrite published history!
fixup_hints	Hints for fixing commits are: (1) NOT PUSHED/PUBLISHED: `git rebase -i $COMMIT^` or perhaps `git commit --amend` (or `git reset HEAD^`). (2) OTHERWISE, `git revert $COMMIT` to make a reverse commit. (3) If you have pushed and MUST remove it, use rebase or filter-branch and type !rewrite in IRC to learn about the implications.
flexible	git's status as a Distributed VCS really means that it is flexible - you can build any layout of repos you like to suit your !workflow. Here are some diagrams of common ones: http://git-scm.com/about/distributed
float	If you have made a change in your working directory and have NOT YET COMMITTED, you may "float" that change over to another (`git checkout existing_branch`) or new (`git checkout -b newbranch`) branch and commit it there. If the files you changed differ between branches, the checkout will fail. In that case, `git stash` then checkout, and `git stash apply` and go through normal conflict resolution.
floated	@!float
floating	@!float
floaty	Uncommitted changes and untracked files don't belong to any branch. This means that when you switch to a different branch, they are still there. (Don't worry, git won't let you switch branches if it would destroy uncommitted changes, unless you force it.) To keep something on one branch only, just commit it! You can always !fixup work-in-progress commits later.
folders	@!empty_dirs
foo	bar
force_push	If you need to overwrite the history of a remote git repository (be carefull, see !rewrite), you can do so with `git push --force-with-lease`. Note that the remote server may reject this. See man git-config and search for receive.denyNonFastForwards. Best practice is for upstream servers to denyNonFastForwards.
fork_sync	@!pull_upstream
fork_update	@!pull_upstream
fortune	I'm sorry that you are stupid, ugly, and not using git.  Still, some misguided souls think that something other than git might be better for them.  Who knows, it might even be true for you.  In any case, we don't care.  Good-bye.
fr	Il y a un canal de discussion français sur #git-fr
frsgc	Please direct all feature requests to support@github.com to make them heard (feel free to discuss them in here, but that's all off the record)
fsck	@!profanity
fugitive	fugitive is a vim plugin that does magic with git, and can be downloaded from https://github.com/tpope/vim-fugitive
funding	To secure funding for gitinfo development, we have partnered up with Quick Cash Grab Inc. who have lots of experience with maintaining and developing open source projects! Stay tuned for exciting new features!
gcs	@!concepts
gerrit	Gerrit is a web-based code review system, built by Google. https://www.gerritcodereview.com/
gfm	GFM is short for GitHub Flavored Markdown, see https://help.github.com/articles/github-flavored-markdown and https://help.github.com/articles/writing-on-github
gh-compare	The GitHub compare view is at: https://github.com/$USER/$REPO/compare/$REV_A...$REV_B -- both $REV_{A,B} can be a branch, tag or SHA in $USER's repo or in the format $OWNER:$REF in the fork of $OWNER; replace slashes (/) in ref names with semicolon (;); append .diff or .patch to get plaintext. More info: http://git.io/j49x7A
gh-protocols	@!gh_protocols
gh-remotes-help	Github has a few help articles on common operations for remotes (adding, changing URL, renaming, removing, etc): https://help.github.com/categories/18/articles
gh-ssh-guide	How to generate SSH keys and how to add them to your Github account: https://help.github.com/articles/generating-ssh-keys 
gh-status	If you're having trouble reaching Github (getting time-outs or error codes), please check http://status.github.com (and in case of time-outs also http://www.isup.me/github.com ); that will usually tell you more than asking here! (We would just have to look it up, too)
gh-tarball	To get the contents of a github repo, use https://github.com/USER/REPO/tarball/REF for a tarball or https://github.com/USER/REPO/zipball/REF for a ZIP file, where REF can be a branch, tag or commit hash
gh-videos	You can find some helpful GitHub-focused tutorial and demo videos at http://www.youtube.com/user/GitHubGuides/videos
gh-zipball	@!gh-tarball
gh_protocols	For a Github-specific comparison of Git transport protocols (git:// vs ssh:// vs https://), see https://gist.github.com/grawity/4392747
gh_tarball	@!gh-tarball
ghhi	Welcome to #github, a place full of helpful gits. If you have a question, please just go ahead and ask -- and please give us some time to answer. For more info on this channel and #git, see https://gitirc.eu/. Take backups (type !backup to learn how) before taking advice.
ghprotocols	@!gh_protocols
ghs	@!sgc
ghsshhelp	Github's help SSH-related help articles can be found at: https://help.github.com/categories/56/articles
git	@/dev/null (The string '!git' often occurs in alias definitions discussed in the channel, so this trigger is reserved)
git-annex	git-annex, git-media, and Git LFS are some solutions to the !binary problem. They work by keeping the blobs outside of the repo, storing a reference to the blob in the repo instead. http://git-annex.branchable.com https://github.com/alebedev/git-media http://git.io/git-lfs
git-spindle	https://github.com/seveas/git-spindle is a handy tool to use the features of GitHub (and GH Enterprise), GitLab, BitBucket and possibly more from the command line.
git-stitch-repo	The git-stitch-repo tool allows for stitching several git repositories together as a unified history without merges, see https://metacpan.org/module/git-stitch-repo for more info.
git-subtrac	git-subtrac is a helper tool that makes it easier to keep track of your git submodule contents. It collects the entire contents of the entire history of all your submodules (recursively) into a separate git branch, which can be pushed, pulled, forked, and merged however you want. https://github.com/apenwarr/git-subtrac
git-subtree	git-subtree allows a subproject repository to be incorporated into a subdirectory of a main repository, and for the history of a subdirectory to be (re-)exported with reproducible results, making it possible to synchronise a repository with a subdirectory of another repo, see https://github.com/git/git/blob/master/contrib/subtree/git-subtree.txt for more info.
git_name	To see what the name git came from, look here: https://git.wiki.kernel.org/index.php/GitFaq#Why_the_.27Git.27_name.3F
git_sizer	A tool to find potential issues with repositories from github, See: https://blog.github.com/2018-03-05-measuring-the-many-sizes-of-a-git-repository/
git_vs_github	@!github_vs_git
gitblit	Gitblit is an open-source, multiplatform Git server written in Java, available both as a standalone and as a WAR file to be ran in other Java web servers. Though it's very easy to set up, it offers many features such as a neat web UI, sophisticated authentication options including LDAP, Groovy script support, a GUI-based management tool and upcoming, WIP features such as "tickets" (similar to pull requests).
gitbu.ch	Das deutsche Git-Buch: http://gitbu.ch -- anders als von Pro Git (http://git-scm.com/book) gibt es davon keine kostenlose Online-Ausgabe.
gitbuch	@!gitbu.ch
gitcal	Development calendar in UTC: https://calendar.google.com/calendar/embed?src=jfgbl2mrlipp4pb6ieih0qr3so@group.calendar.google.com
gitext	Git Extensions is a GUI for git on Windows. It includes Explorer integration and a Visual Studio plugin. http://gitextensions.github.io/
gitflow	The description of the gitflow branch workflow model is at http://nvie.com/posts/a-successful-git-branching-model/ while a tool to help implement this workflow is at https://github.com/petervanderdoes/gitflow  See http://sethrobertson.github.io/GitBestPractices/#workflow for other workflow suggestions/references
github	GitHub is a !3rdparty commercial service offering freemium !hosting services for repositories & projects. https://github.com/features
github-flow	@!github_flow
github_cheap	@!host_gui
github_edu	@!github_free
github_flow	This is the workflow followed by github: http://scottchacon.com/2011/08/31/github-flow.html
github_fork	Quick guide to Forking a repo on github: use the "Fork" button to copy the repo to your account; git clone $URL_OF_FORK; git remote rename origin myfork; git remote add upstream $URL_OF_ORIGINAL; git commit -m 'Some new stuff'; git pull --rebase upstream/master; git push myfork; click the "Create Pull Request" button on your fork. Done!
github_free	@!host_gui
github_ignore	@!gitignore_template
github_pr	@!github_pull
github_pull	To check out a GitHub pull request in your local repo, see this documentation: https://help.github.com/articles/checking-out-pull-requests-locally/
github_ssh	@!ssh_github
github_vs_git	github.com is not git; it's a hosting platform for git. There are alternative hosting offers (you can even host repositories yourself, or work on something on your own without any hosting whatsoever), and the range of features on the corresponding websites may differ. Git has little influence on what happens in github's web interface.
githubflow	@!github_flow
gitignore_disposable	git treats ignored files as disposable, and might remove them if some operation requires it without warning. See https://public-inbox.org/git/7viq39avay.fsf@alter.siamese.dyndns.org/#t
gitignore_exception	Problems with creating "exceptions"(eg, !foolib.file) in your .gitignore? Just use `git add -f foolib.file` to override any wildcard matches. Future changes will be noticed, as ignore rules do not apply to tracked files.
gitignore_template	Github has compiled a set of good .gitignore templates, and licensed them very liberally. https://github.com/github/gitignore
gitignore_whitedir	A global/directory .gitignore blacklist with a (potentially) subdirectory whitelist is not easy to specify in git. However, something like `printf '%s\n' '/*' '!/a/' '/a/*' '!/a/b/' '/a/b/*' '!/a/b/c/' > .gitignore` (ignore everything but a/b/c directory) or `printf '%s\n' '*' '!*/' '!*.txt' > .gitignore` (ignore everything but *.txt files) may do what you want.
gitignore_whitefile	A global/directory .gitignore blacklist with specific file whitelist is trivial to specify in git, since files tracked by git are ignored by .gitignore.  So simply make a .gitignore of "*" and then `git add -f filename`  Those specific files will be tracked by git and show up in git status and friends.
gitinfo	I am an IRC bot which responds to certain keywords to provide helpful(?) information to humans. Please see https://gitirc.eu/bot for more information about how to (ab)use me.
gitk	A tool to view commit history and the diffs they introduced, branching and merging, etc. It is shipped with git, run `gitk` from inside a repository.
gitlab	GitLab is a !3rdparty commercial service offering freemium !hosting services for repositories & projects. It has an "Open Core" that you can run on your own server. https://about.gitlab.com/product/
gitlink	Linking examples: git::master:Documentation/ (tree), git::master (shortlog), git::master^{commit} (commit), git::master/tree.h (file) -- also: git[notabug jast/gitinfo] master:http.pm (currently supported providers: github gitlab bitbucket kernel repo notabug)
gitolite	Gitolite is a tool to host git repos on a server. It features fine-grained access control, custom hooks, and can be installed without root. Download: https://github.com/sitaramc/gitolite Docs: http://gitolite.com/gitolite/ Quick example: http://gitolite.com/gitolite/overview/#basic-use-case
gitolite_emergencies	Locked out of your gitolite-admin repo? No worries, help is on the way. http://gitolite.com/gitolite/emergencies/
gitolite_ssh	See http://gitolite.com/gitolite/sts/ for steps to troubleshoot ssh/gitolite.  See http://gitolite.com/gitolite/glssh/ for how a single "real" userid can play host to multiple "virtual" users using ssh keys.
gitorious	Gitorious was a free code-hosting website for open-source projects, but it shut down in May 2015. More details at https://about.gitlab.com/2015/03/03/gitlab-acquires-gitorious/ and http://blog.gitorious.org/2015/04/15/gitorious-org-is-dead-long-live-gitorious-org/ 
gitosis	gitosis is no longer maintained and supported by the author; we usually recommend gitolite instead which has much better documentation and more features: http://github.com/sitaramc/gitolite -- there's even a migration guide for gitosis users... if you're stuck with gitosis for some reason we'll try to help, but no promises!
gitpaste	@!paste
gitpretty	git pretty is a flowchart of how to get yourself out of trouble http://justinhileman.info/article/git-pretty/
gitslave	gitslave ( http://gitslave.sf.net ) is useful to add subsidiary git repositories to a git superproject when you control and develop on the subprojects at more or less the same time as the superproject, and furthermore when you typically want to tag, branch, push, pull, etc. all repositories at the same time.
gitt	A book designed to teach people about Git in a real world usage model. The book follows a fictional company as they implement and learn about Git. Covers all 21 standard Git commands. Available for free at http://cbx33.github.io/gitt/
gitten	Here, have a cute and cuddly Gitten. Nyaa~
gka	For a better way to view the reflog, try: gka() { gitk --all $(git log -g --format="%h" -50) "$@"; }; gka
gl-doc	gitolite documentation is available at http://gitolite.com/gitolite.  If you're new to gitolite, and you can spend some time, read at least the main page and the overview, then look through the table of contents to decide what you need.
gl-stay	.
gl-ver	Gitolite v3 was out April 2012.  V2 is now unsupported.  PACKAGING: most distros call v3 "gitolite3", as it's very different and isn't auto-upgradable from v2.  This is arguably my fault, but it happens (e.g.,  see sqlite3, gtk3, python3, etc).  Please see http://gitolite.com/gitolite/migr/ for more.
glhi	Welcome to #gitolite.  This is not as full as #git so there may be some delay in answering your question.  Please be patient.  If you're unable to stay logged in to IRC until someone answers, please ask on the mailing list; see http://gitolite.com/gitolite/index.html#contactsupport
glossary	New to git's litany of somewhat eclectic terms and phrases? Check out the glossary manpage and learn all about refspecs and evil merges: https://gitirc.eu/gitglossary.html
goal	@!xy
gogs	Gogs is a self-hosted platform similar to !gitlab, written in Go, aiming to be easier to deploy. http://gogs.io/
google	You're looking for the .search function. Please be patient, it takes a lil bit to load results.
grafts	Grafts are an obscure feature allowing distinct histories to be joined together; see https://git.wiki.kernel.org/index.php/GraftPoint
graph	@!lol
gremlins	@!weasels
gui	Graphical user interfaces are not supported here. If you want to get support, it needs to be through the git CLI. Reasons: 1) Because very few people here use the graphical interface. 2) Because giving instructions for GUI's is difficult. 3) The command line gives you a history of what commands you have executed.
guis	Popular GUIs for Git are listed on the website: http://git-scm.com/downloads/guis
hamburger	@!sausage_making
hash	@!sha1
head	@!HEAD
headless	@!detached
hello	@!welcome
help	What do you need help with? Something with git? Tell us what's going on, and please be specific. For information on how to abuse me (I'm a bot!), see https://gitirc.eu/bot . Please be gentle.
helping	We have a few guidelines for helping others in #git; please try to follow them. https://gitirc.eu/helping.html
herp	derp
hg	@!mercurial
hi	@!welcome
homepage	@!official
hook_pitfalls	Guidelines for writing hooks: 1. Consume all input (cat >/dev/null if you don't want it). 2. If you use any 'cd', also 'unset GIT_DIR'. 3. Don't git-pull in a hook (or any other script).
hooks	@!hook_pitfalls
host	@!gitolite
host_gui	There are several options for self-hosting git repositories with a web GUI: !gitblit !gitlab !rhode_code !gerrit and !gogs. Keep in mind that these all take far more work than a (non-GUI) !gitolite install. An overview of nearly all GUIs is available at: https://git.wiki.kernel.org/index.php/Interfaces,_frontends,_and_tools
host_guis	@!host_gui
hosted	@!host_gui
hosting	There are many hosting options available for git repositories, including !github !gitlab !gitolite and many more: https://git.wiki.kernel.org/index.php/GitHosting
hosts	@!host_gui
http_repos	@!web_repos
https_repos	@!web_repos
hub	Hub is a wrapper around git which provides specific github features to the git cli. See https://github.com/github/hub for details.
ignore_dir	Git doesn't track directories, so you can't ignore them. If you want them ignored, ignore the files in the directory. Matching a directory in .gitignore means you ignore all files in that directory
ignore_tracked	Git only applies ignore patterns to untracked files. You can't use ignore patterns to ignore changes to files that are already tracked by git. To remove files only from git, but keeping them on disk, use git rm --cached <file>. Still, see https://gist.github.com/1423106 for ways people have worked around the problem.
ignore_untracked	@!ignore_tracked
ignoretracked	@!ignore_tracked
imerge	https://github.com/mhagger/git-imerge -- a tool to split a large merge with many conflicts into many smaller merges, hopefully each with easier-to-understand small conflicts.
import	Importing lots of revisions from other VCSes(via git-svn in particular) can take a long time. If this will be a one-time switch you should consider "throwing out" all of your old history and making a simple initial commit from a tarball.
impossible	@!cant_happen
includes	git v1.7.10 added support for including other config files via the include.path variable. See the "Includes" section of man git-config for more info
index	The index (or cache, or staging area) is one of git's most central concepts. Read http://git-scm.com/book/en/Getting-Started-Git-Basics "The Three States", and e.g. http://tomayko.com/writings/the-thing-about-git for some cool things it can help you do.
interactive_rebase	Interactive rebase sounds similar to rebase but has completely different abilities. It can do this to commits: change the order, squash some of them together, remove some, add random existing commits from other branches, split them, and more... it's very powerful. Documentation is in the section "Interactive Rebase" in 'man git-rebase'. https://gitirc.eu/git-rebase.html
introduction	@!IntroToGit
irclog	Public logs of #git are kept at: https://gitirc.eu/log
ircstats	@!irclog
isgitbetter	We think so, but if you don't, please go away and use $YourFavoriteSystem instead
jokes	A complete listing of the git-jokes used in the /topic can be found at https://madeitwor.se/git-jokes (patches welcome)
just_ask	You can just ask your question. If anybody knows the answer, they will answer soon (most of the time)
justask	@!just_ask
justdoit	If you go to the trouble of asking questions, please go to the trouble of taking the advice offered, Take backups (type "!backup" as a reply to learn more) if necessary -- or in fact, it's a good idea anyway. You can almost always censor log messages if you have to.  We are literally helpless unless you tell us what we need or do what we ask.  Please, Just Do It™.
karma	This channel is equipped with karma measuring devices. If you want to help someone to karmic nirvana, please mention their name when thanking them ("thank you", "thanks", "thx", etc.). Try ".karma <nick>" or ".topkarma" to show karma status of a person but don't expect immediate increase. Karma is not for those seeking instant gratification.
koans	Looking for some enlightenment? Five koans about Master Git: http://stevelosh.com/blog/2013/04/git-koans/
large_files	Git isn't yet great at large files(larger than RAM). Look at !annex for solutions. You can find them (after gc) with: git verify-pack -v .git/objects/pack/pack-*.idx | grep blob | sort -k3nr | head | while read s x b x; do git rev-list --all --objects | grep $s | awk '{print "'"$b"'",$0;}'; done
large_repos	Git can be slow in the face of large repositories.  There are git-config options which can help.  pack.threads=1; pack.deltaCacheSize=1; pack.windowMemory=512m; core.packedGitWindowSize=16m; core.packedGitLimit=128m. Other likely ones exist.
last	git-last is a script which will give you a GitHub-like view of the current directory(showing the last commiter of each dir/file): https://madeitwor.se/scripts/blob/master/bash/git-last.sh
layout	@!flexible
learn-git-branching	@!learn_git_branching
learn_git_branching	A nice tutorial visualizing git branching: http://pcottle.github.io/learnGitBranching/ . See also !visualize_ops
lf	@!use_lf
lfs	@!annex
lg	git config --global alias.lg "log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --date=relative"
lgg	lol git gud(tm)
license	Want to release your code but don't want to read through a bunch of lawyerspeak? Then you should be aware that not including license terms defaults to Copyright, which makes it pretty useless to everyone. Take 5 minutes and use http://choosealicense.com/ :)
line-endings	@!crlf
local_branch_from_remote	The following commands are all equivalent, assuming <branch> doesn't yet exist: 'git checkout -b <branch> <remote>/<branch>', 'git checkout -t <remote>/<branch>', 'git checkout <branch>'. The latter invokes some magic.
log	@!irclog
logs	@!irclog
lol	git log --oneline --graph --all
lost	As long as you have `git commit`ed your changes (or even `git add`ed them), your changes will not be lost for over two weeks unless you work really hard at it.  There are two places where "lost" changes can be hiding.  They might be in the reflog (`git log -g`) or they might be in lost&found (`git fsck --unreachable`). Type "!dangling" and "!reflog" into IRC for more info. 
madeitworse	Made It Worse is a URL lengthener for Github. Example usage: https://torvalds.madeitwor.se/linux
mailing_list	The mailing list can be reached via git@vger.kernel.org. You don't need to subscribe to the list, you will always be put in cc on reply. Read archives at http://public-inbox.org/git
man	The git man pages are available online at https://gitirc.eu/git.html. Or were you looking for the "man git-foo" syntax (without the !)?
master	@!master_branch
master_branch	'master' is the default name for the first branch created by git, and it is in no way special. You can just delete it, and use more meaningful names such as 'dev' 'stable' 'unstable' 'bug/001' etc. If this is a bare repo, you will want to change the default branch(`git symbolic-ref HEAD refs/heads/somebranch`) first.
media	@!annex
mercurial	Mercurial is a competitor to Git: http://mercurial.selenic.com/ -- want to use Mercurial repositories in Git? http://felipec.wordpress.com/2012/11/13/git-remote-hg-bzr-2/
merge	'git merge' takes two diverged lines of history (series of commits, e.g. on different branches), and recombines them with a "merge commit" on top. This creates an explicit record of you doing the merge, unless there were no local changes (which does a !fast_forward merge instead). If you don't need to keep a record like that, !rebase may produce easier-to-read history, but the two don't always mix well... see also !merge_vs_rebase
merge_or_rebase	For a detailed discussion of the dis-/advantages of merge and rebase, and when to best use which, see: https://coderwall.com/p/ny1hia -- and here's how Linus explains which one to use: http://www.mail-archive.com/dri-devel@lists.sourceforge.net/msg39091.html
merge_selective	git does not support merging only certain files - it is all or nothing. To fake it, use 'git merge --no-commit', !unstage the files/dirs you don't want merged, then commit.
merge_theirs	Git supports 'merge -s ours', but not 'merge -s theirs'. For a simple workaround, see https://gist.github.com/canton7/1268587
merge_vs_rebase	@!merge_or_rebase
mergerebase	@!merge_or_rebase
migrate	https://help.github.com/articles/importing-a-git-repository-using-the-command-line
mindreader	Unfortunately, we can't read your mind (despite our best efforts). Please establish a context and explain what exactly you mean or want to know.
ml	@!mailing_list
move	@!rename
mr	a tool to manage Multiple Repositories, see http://joeyh.name/code/mr/
msysgit	Git for Windows, formerly referred to as msysgit, is available at http://git-scm.com/downloads
multiple_id	git by itself does not allow you to specify which SSH key to use when speaking to a remote. You can use ssh_config+remote hostname tricks to achieve this goal: http://superuser.com/questions/272465/using-multiple-ssh-public-keys
multiple_ssh_keys	@!multiple_id
mv	@!rename
next	Another satisfied customer. NEXT!
nfs	Git is a disk-intensive program. It's not recommended to use with network drives, it will be slower. Especially do not set up a "git server" that is shared over nfs, samba, etc.
no_branch	@!detached
nobody	@!just_ask
nogui	@!gui
nom	@!botsnack
non-bare	@!bare
non_bare	@!bare
nonbare	@!bare
not_intended	@!UGFWIINI
notsvn	@!unlearn
obfuscate	Please do not elide, obfuscate, or otherwise hide information from !repro pastes. This invariably leads to pastes that hide the actual issue or (worse) are not consistent, sending the investigation down false paths. See !secret.
office	Microsoft Office documents(and related formats) are not stored well by git(see !binary). The Open/LibreOffice suites support saving as an uncompressed "Flat XML" file which helps alleviate this problem.
official	Some official resources for git. Homepage: http://git-scm.com/ | Source repo: https://www.kernel.org/pub/scm/git/git.git/ (Mirrrored: https://github.com/git/git/) | IRC channel: You're in it. | Mailing list: http://vger.kernel.org/vger-lists.html#git (git@vger.kernel.org, subscription optional)
offon	Have you tried turning it off and on again?
offtopic	From the #git website: it's okay to talk about anything (within general limits of reason), as long as you don't get in the way of people talking about on-topic things (mainly questions about git and using git). Accordingly, please consider pausing off-topic discussions to help people having trouble with git (if any).
oops	@!fixup
ops	@/dev/null (there's currently no information about ops in the bot but it automatically matches !oops which is an alias for !fixup. This placeholder avoids confusion.)
origin	'origin' is the default name for a remote assigned by git clone.  It is in no way special (similar to !master) and can be edited as you like through git remote rename
orphan	To create an orphaned branch(unrelated to existing history): `git checkout --orphan newbranchname`. This will leave your index/worktree as-is(use `rm .git/index; git clean -dfx` to delete EVERYTHING). If you get 'error: unknown option `orphan`' see !orphan_old. For an empty/null commit see !orphan_null.
orphan_empty	@!orphan_null
orphan_null	To create an orphan branch with the null/empty commit, use: `git checkout -b orphan $(echo "empty" | git commit-tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904)`
orphan_old	If your git is older than 1.7.2, use: `git symbolic-ref HEAD refs/heads/orphan; rm .git/index; git clean -fdx; touch foo; git add foo; git commit -m 'Initial commit on branch orphan'`
otherbranches	@!wherearemybranches
packaged	Unless you have a specific technical need for the "latest and greatest" you should go with a packaged version. Compiling and installing your own is not something that we will walk you through or troubleshoot (though it *is* fairly easy for developers with GNU/Linux experience).
panic	@!eekaconflict
parable	'The git parable' provides some good reasoning behind git.  http://tom.preston-werner.com/2009/05/19/the-git-parable.html
parallel	@!resume
partial_clone	The "Partial Clone" feature is a performance optimization for Git that allows Git to function without having a complete copy of the repository. (https://git-scm.com/docs/partial-clone https://github.blog/2020-01-17-bring-your-monorepo-down-to-size-with-sparse-checkout https://about.gitlab.com/blog/2020/03/13/partial-clone-for-massive-repositories/)
paste	Please use a pastebin for snippets longer than one line. Persistent and can be used with a GitHub account: https://gist.github.com/ - one hour auto-delete: https://upaste.de/
pastebin	@!paste
pastie	@!repro
perfect	@!postproduction
permissions	Git does not store full UNIX permissions, even if it makes it look like it does. In fact, the only mode-related info Git stores is whether a given file is executable. Anything else is taken care of by your umask and the core.sharedRepository setting. See also !configfiles
persistent_changes	Probably some filter is causing the files to keep being modified. See http://softec.lu/site/DevelopersCorner/GitSmudgeCleanCorrupted for details.
ping	I only respond to !reply_time
pizza	If a pizza has a radius 'z' and a depth 'a' that pizza's volume can be defined Pi*z*z*a
pm	@!privmsg
polite	@!helping
pong	PING
postproduction	So, you want to make your commit history look pretty before pushing? http://sethrobertson.github.io/GitPostProduction talks you through how to use 'rebase -i' to do this.
precious	@!ignore_disposable
private	Want to get free hosting for non-public projects (you can control who gets access)? Some options: Bitbucket (https://bitbucket.org/ - 5 members max), Gitlab (https://gitlab.com/ - practically no limits)
privmsg	You can get gitinfo keyword expansion (e.g. !doc or this one) sent directly to you by sending a private message to me: /msg gitinfo !doc. This avoids spamming the channel. Also see https://gitirc.eu/bot/trigger.php
profanity	Hey!  This is a family-safe channel, so keep it frakking clean you fierfekker!
progit	@!book
prompt	The bash completion script developed with git (https://github.com/git/git/blob/master/contrib/completion/git-prompt.sh) and the one for zsh shipped with zsh (http://gitready.com/advanced/2009/01/28/zsh-git-status.html) both support showing the status of your repo in the prompt string, at a glance
ps1	@!prompt
publish_github	Publishing git repos via git-daemon or gitweb is not for the faint of heart. Consider using Github as a free place to post your work, and let them worry about administration.
pull	pull=fetch+merge (or with flags/config also fetch+rebase). It is thus *not* the opposite of push in any sense. A good article that explains the difference between fetch and pull:  http://longair.net/blog/2009/04/16/git-fetch-and-merge/ 
pull-all	@!pull_all
pull4	@!fetchfour
pull_all	'pull --all' is a nonsensical request. It will invoke 'fetch --all' (which you should use instead) but it will *not* merge (see !pull) all branches that have an upstream, or anything of the sort.
pull_or_rebase	@!merge_or_rebase
pull_request	@!github_pull
pull_upstream	To incorporate changes from an "upstream" or forked-from repository: git remote add upstream $URL; git fetch upstream; git merge upstream/$BRANCH. https://help.github.com/articles/syncing-a-fork/
pull_vs_rebase	@!merge_or_rebase
pullfour	@!fetchfour
push-f	@!force_push
pusher	I am the pusher robot. I shove around the code. http://youtu.be/7E0ot9iJm_k?t=34s
puzzle	Hmm.... that doesn't make much sense. Its possible you're not showing us the full puzzle. Please provide more details, preferably including a !transcript including `git status` output so we can help you help yourself.
question	You know, you have not actually asked a question.  Without asking a question, it is hard to get any responses.  Please explain what you are trying to do, what you typed in, and exactly what came back.  Use http://gist.github.com/ for exact command sessions.
quiet	We require users to have completed a NickServ registration, or to ask the bot for a +v(via the .voice command). This helps to combat most random spamming
ranges	@!dots
read	Don't expect everything to be spoon fed to you - the man pages and other documents do not bite, you need to spend some time and effort reading them.
reasons	@!why
reattach	Letters refer to !detached. (a) and (b): 'git checkout branchname' to continue working on another branch, or 'git checkout -b branchname' to start a new one here; (c) git am --continue; (d) git rebase --continue
rebase	'git rebase' takes away your local commits, updates your branch with new stuff from <upstream> (argument), then re-applies your local commits on top. This makes it look like your commits were created "after" the new stuff, and it can look cleaner than doing a !merge. Beware of !rewriting_public_history, though. Not to be confused with !interactive_rebase.
rebase-i	@!interactive_rebase
rebase_interactive	@!interactive_rebase
rebase_local_remote	When you 'git checkout branch; git rebase master', git will sit on top of master and apply successive patches from branch. If patch #2 conflicts, then LOCAL points to the result of patch #1 having been applied, and REMOTE points to patch #2
rebasemerge	@!mergerebase
recurse	see !recursive
recursion	see !recurse
recursive	see !recursion
reflog	The git reflog (`git log -g`) temporarily (90 days by default) snapshots your branch states at each operation that changes the branch, making it easy to undo e.g. merges and rebases. The usual warnings about !rewriting/undoing history apply. See https://sukima.github.io/GitFixUm/ for full details.
refs	@!treeish
refspecs	Refspecs are used by fetch/push to *spec*ify which *ref*s to transmit where. They have the form "source:destination". They can be prefixed with a "+" to force the update, possibly displacing existing history. More info: https://gitirc.eu/git-fetch.html or http://i.qkme.me/3tke7r.jpg
refund	If you are not satisfied with git, or the support provided by the volunteers in #git, you are entitled to a full refund of the purchase price, and are invited to use another VCS. Elsewhere.
remote-tracking-branches	@!remote_tracking_branch
remote-tracking_branch	@!remote_tracking_branch
remote-tracking_branches	@!remote_tracking_branch
remote_branches	@!remote_tracking_branch
remote_commands	The only git porcelain commands which might interact with remote repos are: fetch, pull, push, remote, ls-remote, archive, submodule (plus plumbing, remote helpers, etc)
remote_tracking_branch	Remote-tracking branches (branches which start with e.g. 'origin/', listed by 'git branch -r') are read-only mirrors of the branches in another repository. They're updated by 'git fetch'. You can't edit them directly (trying to check them out results in a !detached HEAD), but you can create a local branch based on a remote-tracking branch using e.g. 'git checkout -b <branch> <remote>/<branch>'
remote_tracking_brancher	@!remote_tracking_branch
remote_tracking_branches	@!remote_tracking_branch
remove_commit	You can use rebase to remove commits: git rebase --onto <commit>~1 <commit> <branch>. Note this will !rewrite history.
rename	git does not support explicitly file renaming - the 'git mv' command is shorthand for 'git rm --cached; mv; git add'. All "rename" statistics are generated at runtime when examining history with git-log. See the -M option in the git-log manpage for more info. Also public-inbox.org/git/Pine.LNX.4.58.0504150753440.7211@ppc970.osdl.org and `diff.renames = true`  in man git-config
reply_time	I only respond to !ECHO-REQUEST
repo	Repo is a tool produced by Google for the AOSP project(and others) which wraps git and provides its own set of commands. While it is possible to use git with repositories that are managed by repo, it is not always easy. https://source.android.com/source/using-repo.html
repro	@!transcript
reproduce	@!repro
reset	reset does two things! (1) without file/path argument: 'git reset [flags] [<commit>]' = make the current branch point to <commit> (default: HEAD). --soft = don't do anything else. --mixed (default) = overwrite the index to match. --hard = overwrite the working files to match. (2) 'git reset [<commit>] -- <path>' = overwrite the index entries for <path> with the content from <commit> (default: HEAD)
reset--hard	You can go back to the last commit, or any other commit (effectively getting rid of commits which can cause issues, see !rewrite), using 'git reset --hard' with an optional commit/ref argument. This will irrevocably destroy all uncommitted changes, so please be careful!
reset_demistified	@!reset
reset_demystified	@!reset
resets	tl;dr of man git-reset: --soft moves HEAD, --mixed moves HEAD+index, --hard moves HEAD+index+work-tree, -- foo.txt will !unstage
result	many terms are used in many different ways in version control; therefore, your question seems ambiguous to some of us. Please describe the outcome you had in mind so that we get a better understanding of which meaning you intended.
resume	Git does not yet support resuming, torrenting, or parallel fetching of clones or other network traffic. You can make a single file out of a repo using 'git bundle' then use normal resumable download methods to get that file.  See https://bundler.caurea.org.  Also !gitolite can be told to maintain and send bundles using rsync; see https://github.com/sitaramc/gitolite/blob/master/src/commands/rsync
revert	That's a rather ambiguous question... options: a) make a commit that "undoes" the effects of an earlier commit [man git-revert]; b) discard uncommitted changes in the working tree [git reset --hard]; c) undo committing [git reset --soft HEAD^]; d) restore staged versions of files [git checkout -p]; e) move the current branch to a different point(possibly losing commits)[git reset --hard $COMMIT]?
revert_merge	@!faulty_merge
reverts	@!revert
revision_numbers	Revision numbers are often requested, but no matter what algorithm you choose to generate them, they cannot simultaneously have all four desirable properties: (a) increasing (b) unique (c) immutable [for a given commit] (d) decentralized. Subversion obviously does not need (d). Git uses a hash function, and thus gets all but (a). See man gitrevisions for other ways to refer to commits.
rewrite	Rewriting public history is not recommended. Everyone who has pulled the old history will have to do work (and you'll have to tell them to), so it's infinitely better to just move on. If you must, you can use `git push --force-with-lease <remote> <branch>` to force (and the remote may reject that, anyway). See http://goo.gl/waqum
rewrites	@!rewrite
rewriting	@!rewrite
rewriting_public_history	@!rewrite
rhode_code	Hosting Web-GUI with Git, Mercurial and Subversion support: https://rhodecode.com/
rip	R.I.P. Tree-Eating Monster! Shrine at: http://web.archive.org/web/20110720065754/http://git-scm.com/
rmrf	@!startover
rockstar	Node.js may be Badass Rockstar Tech, but doing it correctly is a lot better than following a !blog post. http://www.youtube.com/watch?v=bzkRVzciAZg
rtb	@!remote_tracking_branch
rubberducking	We love being your rubber ducks! Just tell us what your problem is, and maybe you'll find the solution yourself! Our favorite questions are the ones we don't need to answer. (Don't forget to mention your solution for posterity's benefit!)
samba	@!nfs
sausage_making	Some developers like to "hide the sausage making", transforming their commits before presenting them to the outside world. See http://sethrobertson.github.io/GitBestPractices/#sausage and !perfect
sausagemaking	@!sausage_making
schwartzian	The Schwartzian Criterion of Git Usage: if you don't envision using branching and merging, then git probably isn't the right answer.
search	@!google
secret	@!topsecret
semver	The Semantic Versioning standard is widely used for version numbering. You may find it useful when creating git tags: http://semver.org/
send-email	Couple of guides on how to use git send-email: https://git-send-email.io/ https://flusp.ime.usp.br/git/2019/02/15/sending-patches-by-email-with-git/
set_upstream	To tell git which remote branch to use in pull (and push if you set push.default to upstream) for a given branch foo, use something like: git branch --set-upstream-to origin/foo foo
sgc	For bug reports, feature requests, suggestions for improvement, or specific problems with an individual repo (or gist, etc.), please contact support via support@github.com or https://github.com/support - support tries to answer all questions within 24 hours, including weekends and holidays.
sha1	git uses a variant of the SHA1 cryptographic hash algorithm to ensure object integrity. Git v2.13.0 added hardening to the SHA-1 implementation to mitigate SHAttered; work towards a NewHash is underway: https://git.io/vpIMJ | Please note that purposeful SHA1 collisions are computationally expensive, and accidental encounters are more likely with wolves. https://en.wikipedia.org/wiki/Wolf_attacks Fear their howl!
shallow	A shallow clone will clone a repository to a certain "depth", which sounds like a good idea for only obtaining the latest revision of a given repo. However, they often don't work as-advertised(breaking on fetch and push operations). Instead you should consider git-archive's --remote feature, or perhaps you're really encountering a !binary problem
shortcuts	@!triggers
shots	SHOTS SHOT SHOTS SHOTS SHOTS! Then !beer
shover	@!pusher
show_upstream	To get a listing of what your local branches have set as their "upstream", run: git branch -avv
signoff	A sign-off is a line in the commit message saying 'Signed-off-by: Your Name <your@email>'. It can be added using 'git commit -s'. A few open source projects require it for legal reasons. See http://stackoverflow.com/a/1962112/1086121 for a good explanation
sigpipe	@!SIGPIPE
simple	At its heart git is made up of many concepts that are individually simple. Getting the whole picture right is often tricky, and it is usually about breaking up the complex concept into its simple, individual parts and grokking those. Both !bottomup and !cs will help with that.
simplegit	@!simpleguide
simpleguide	The Simple Git Guide by Roger Dudler: http://rogerdudler.github.io/git-guide/
single_malt_scotch	Ohh, yeah, now we’re get*hick*ting somewhe*hick*re.
situation	Please post the url returned by ' git log -n 20 --all --graph --format="%h %p %d %s" | curl -F text=@- https://upaste.de ' to give us an idea about what your situation is (increase the -n argument if your problem is more complex than 20 commits can explain)
smart_questions	You should read http://www.catb.org/esr/faqs/smart-questions.html on how to improve asking and recieving help from the open source community. It will greatly benefit you and you'll get results faster.
smartgit	SmartGit is a (commercial) UI for git that is very user-friendly and feature-complete. http://syntevo.com/smartgithg
smudge	@!filters
snip	@!obfuscate
snotback	Yum! Oysters!
snowflake	You are not a beautiful and unique snowflake. In other words: somebody has undoubtedly tried what you are doing. Search a bit and maybe you'll find their work.
source	@!official
soviet_git	In Soviet Git, commits are not on branches, branches point to a commit.
sovietgit	@!soviet_git
sparse_checkout	Sparse checkout can be used to restrict which files/folders are updated with all checkout and status operations. It cannot change the tree the checkout is rooted from. One common use case is locally keeping Git from updating some of the files tracked in your repository. See the "Sparse Checkout" section in man git-read-tree (https://gitirc.eu/git-read-tree.html).
split	To split an unpushed commit: git rebase -i <id>^; (change the corresponding line from 'pick' to 'edit'; save and quit); git reset --soft HEAD~; (stage and commit changes for first commit; stage and commit changes for second commit); git rebase --continue
split_repository	@!filter_subdirectory
spoon	@!read
ssh	Please use SSH to talk to remote repos. http:// and git:// are  completely unsecured and http:// suffers from smart webservers trying to implement policy. You can try to do "smart" https://, but it can be  troublesome to configure if you do not know how (see !web_repos for simple instructions) unless your company implements a MITM attack and prevents end-to-end crypto.
ssh_github	If you are having problems accessing github repos over HTTPS you should switch to SSH (the default used by git, for many very good technical reasons): https://help.github.com/articles/generating-ssh-keys
stage	@!index
stage_rm	To automatically stage all removed files (without also staging other changes), use the following command: git diff --name-only --diff-filter=D -z | xargs -0 git rm --cached
staging	@!index
starting_point	Good starting points for getting to know Git are: official website http://git-scm.com/ (esp. "Documentation"), http://stackoverflow.com/tags/git/info, http://try.github.com, https://git.wiki.kernel.org/index.php/Main_Page,  http://rogerdudler.github.io/git-guide/ and  https://www.atlassian.com/git/tutorial/git-basics
starting_points	@!starting_point
startover	There’s usually no need to start over / rm -rf everything and reclone or so.  Most situations can be fixed by other means.
sts	@!gitolite_ssh
subgit	SubGit is a two-way git<->svn bridge. It provides a (self-)hosted alternative to git-svn, with some advantages. See http://subgit.com/
submodule	git-submodule is ideal to add subsidiary git repositories to a git superproject when you do not control the subprojects or more specifically wish to fix the subproject at a specific revision even as the subproject changes upstream. See http://www.git-scm.com/book/en/Git-Tools-Submodules
submodule_change	In order to change a submodule you must go into the submodule repository, check it out to the appropriate branch, make the needed change (possibly involving git pull), commit the change, cd .. (out of the submodule), git commit -m "Updated submodule" submodulepath
submodule_mv	@!submodules_mv
submodule_rm	@!submodules_rm
submodules	@!submodule
submodules_mv	Renaming git submodules is harder than it perhaps should be.  All commands are in the superproject.  Edit .gitmodules to reflect the new path.  Then `git mv oldsubmodulepath newsubmodulepath; git commit -m "Moved submodule from old to new"`  Inspect .git/config to see if anything looks likely for changing. 
submodules_rm	To delete a submodule, do this in the superproject: Edit/delete .gitmodules to remove the submodule, and `git add .gitmodules`. Then `rm -rf submodulepath; git rm -f --cached submodulepath; git commit -am "Removed submodules!"`  Inspect .git/config for "submodule" entries to remove.  Inspect .git/modules for caches to remove.  Possible alternatives to submodules: "!gitslave" or "!subtree"
subprojects	So, you want to add git repositories inside of other git repositories? Well, you have four main options. First is to just do it, add the repo to the outer project's .gitignore, and treat them entirely separately. Best if they are entirely separate. Otherwise your best options are "!submodule", "!gitslave", and "!subtree". Try those commands in this channel, or in a PM to avoid flooding.
subrepos	@!subprojects
subtrac	@!git-subtrac
subtree	The subtree merge method is great for incorporating a subsidiary git repo into your current one with "unified" history. Read http://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging#_subtree_merge for more info, see also !git-subtree and !git-stitch-repo.
subtree_alt	The git subtree merge method is hard to export changes from..  https://github.com/apenwarr/git-subtree provides another method which appears to be easier to export changes from.  Also as a no-change-exported method, see https://metacpan.org/module/git-stitch-repo which claims to generate a unified history instead of merged branches.
subtree_alternatives	@!subtree_alt
summarize	@!dont_summarize
summary	@!dont_summarize
support_contract	I'm sorry, I cannot seem to locate your paid-up support contract in my records.  You can either find someone to pay to support you professionally, or throw yourself on the mercy of the gits on #git who will help you as they see fit.  Alternately, you can request a refund of the full purchase price of git and find another SCM system which will satisfy your support needs for the same or lower cost
svn2git	For a one-time conversion of SVN to git, svn2git should be used instead of git-svn. There are many tools with this name. Probably the best is the KDE one at https://github.com/svn-all-fast-export/svn2git. To analyze the SVN repo history upfront for building up proper rules for svn2git, you might use svneverever from here: http://blog.hartwork.org/?p=763
svn_upstream	git-svn determines the upstream branch to push to by finding the topmost commit in your current branch that has a "git-svn-id" line (i.e., 'git log --grep=^git-svn-id: --first-parent -1'), and using the branch mentioned in it.
sync_fork	@!pull_upstream
talks	Some good video talks about Git: [yt] http://goo.gl/z72s (Linus Torvalds: History&Concepts); [yt] http://goo.gl/R9H2q (Scott Chacon: Git basics, live examples); http://vimeo.com/35778382 (Randal Schwartz: Git basics, descriptional); http://vimeo.com/46010208 (Jessica Kerr: Git basics, descriptional)
technically	https://xkcd.com/1475/
test123456	.
text	@/dev/null (trigger blocked, '!text' is often used in gitattributes definitions)
thanks	You're very welcome!
third	@!3rdparty
threevirtues	The three great virtues of a programmer, according to Larry Wall: laziness (write code that saves work, document so you don't have to explain over and over), impatience (make software anticipate what you need), hubris (make things nobody could want to criticize)
tias	Try it and see™. You learn much more by experimentation than by asking without having even tried. If in doubt, make backups before you experiment (see !backup). http://gitolite.com/tias.html may help with git-specific TIAS.
tig	https://git.wiki.kernel.org/index.php/Tig - An ncurses (terminal) alternative to gitk.
tools	See https://git.wiki.kernel.org/index.php/InterfacesFrontendsAndTools for information about known interfaces, frontends, and tools. 
top_secret	@!topsecret
topgit	TopGit is a patch queuing system, allowing you to manage a series of topic branches that apply on top of a main branch. https://mackyle.github.io/topgit/topgit.html
topsecret	If your situation is so secret that you can't tell us how to !reproduce it, there's really not much we can do. Perhaps you need to find or buy support you can trust?  There are people with clearances even on #git but they may not want to identify themselves.  However, you are protected by the biggest secret of all:  We just don't care.
torrent	@!resume
track_rename	git does not track renames of files in history, git only records tree snapshots. It can try to guess whether a change was a rename, or just unrelated removal+addition, when asked.  You can help this by making the rename in a different commit from a modification.  See man git-log -C and -M
tracking_branches	@!remote_tracking_branch
transcript	Please paste (using https://gist.github.com/ or similar) a transcript ( https://git.io/viMGr ) of your terminal session so we can see exactly what you see
treeish	A tree-ish is something that looks like a tree. Read 'man gitrevisions' and http://git-scm.com/book/en/Git-Tools-Revision-Selection
triggers	Please don't spam me! I'm just a poor bot! Here's everything I know: https://gitirc.eu/bot/trigger.php -- that's a list of these nifty keywords like "!bot" that you can use in the channel, in case you were wondering.
trygit	A quick, interactive, in-browser introduction to git is available at http://try.github.io
tryit	@!tias
tutorials	@!tutorial
ugfwiini	@!UGFWIINI
ugt	UGT (Universal Greeting Time): it is always morning when someone joins a channel, and always late night when they leave. http://www.total-knowledge.com/~ilya/mips/ugt.html
understand	You might wanna see http://devopsreactions.tumblr.com/post/104064772852/understanding-git
undo	@!fixup
unique	@!snowflake
unlearn	Users of centralized VCSes will need to unlearn a number of habits in order to learn git. Many commands, such as "checkout" and "revert" bear little in common to those holding the same name in other systems.
unlearning	@!unlearn
unresolve	Accidentally marked a conflicted file as resolved and want to get the conflict markers back? `git checkout --merge -- <path to file(s)>`
unsafe	@!disclaimer
unstage	To unstage a file from the index(in other words, to undo an accidental `git add foo/bar.txt`), use: git reset -- foo/bar.txt
untrack	To remove a file from git's tracking, without deleting it from your working tree, `git rm --cached <file>`. Note that any repo which pulls this change will delete their local copy of that file. You can "bring it back" using `git checkout HEAD@{1} file` immediately after pulling / merging
upstream	Do you want to set the remote branch which is being tracked(!set_upstream), list what remote branches are being tracked(!show_upstream), or incorporate changes from another repo which is not your "origin"(!pull_upstream) ?
upstream_pull	@!pull_upstream
urdoinitrong	@!xy
use_lf	To eliminate all issues with line-endings in a repo it is recommended to change all files to use LF, and then convince all contributors to use LF-aware editors (Notepad++ works well for Windows), by force if necessary. !crlf has some tips if this is not feasible.
user.name	The author and committer names are by convention some form of a personal name (that is, the name by which other humans refer to you). This name has no effect on authentication; for that, see the credential.username variable in git-config(1).
vampire	Please don't be a help vampire - we're here to point you in the right direction, not type out the commands verbatim for you. http://slash7.com/2006/12/22/vampires/
vcbe	'Version Control By Example' gives a good overview of the different VCSes available. The author will even mail you a dead-tree copy for free. https://ericsink.com/vcbe/index.html
vcsh	https://github.com/RichiH/vcsh - Version Control System for $HOME - multiple Git repositories in $HOME -- abusing fake bare Git repositories for fun and profit
version	The current version of git is listed in the /topic of #git (out of date? Say '.version' in the channel). Don't be scared if you're using a slightly older version -- they interoperate just fine, though you may be missing a few features. Unless you have a specific need for the newest version, it's best to stick with premade packages.
video	@!talks
videos	@!talks
visalize_ops	Visualize common operations: https://onlywei.github.io/explain-git-with-d3/
visops	@!visualize_ops
visualise	@!visualize
visualize	You can visualize the whole repo graph with gitk (GUI, `gitk --all`), !lol (plain CLI, `git log --oneline --graph --decorate --all`) or tig (ncurses, http://jonas.nitro.dk/tig/)
visualize_ops	Visualize common operations: https://onlywei.github.io/explain-git-with-d3/ . See also !learn_git_branching
vizops	@!visualize_ops
voice	The sound produced by the vocal organs of a vertebrate, especially a human. (American Heritage® Dictionary of the English Language, 4th Edition) – Or did you want to talk in #git? Try: .voice
wat	Wat: https://www.destroyallsoftware.com/talks/wat
weasels	The consequences of this proposal are not well-defined. A band of furious weasels may infest your undergarments, or it might work just fine. You should !backup then !tryit and let us know what happens.
web_repos	Sharing git repositories over http/https (gitweb or `git clone`) is easy with http://goo.gl/4EUTCX Auth includes none, authfile, pam, ldap, and ssl client certs.
web_repositories	@!web_repos
website	@!deploy
welcome	Welcome to #git, a place full of helpful gits. If you have a question, feel free to just go ahead and ask—somebody should answer shortly. For more info on this channel, see https://gitirc.eu/ - Take backups (type !backup to learn how) before taking advice.
what	@!wat
wherearemybranches	Git clones all branches, but initially makes only the main branch (usually 'master') available as a normal local branch. To work on another branch, simply 'git checkout <branch>' (or, in versions older than 1.6.6, git checkout -b <branch> origin/<branch>). This works even if the branch doesn't show up in the normal list of branches. For technical details, see !rtb
why	Why? Because screw you, that's why.
wine	@!beer
wisdom	1. If it's not stored in git, it might as well be gone. 2. Git is not a backup.
work	@!doesntwork
workflow	Finding the right workflow for you is critical for the success of any SCM project. Git is very flexible with respect to workflow. See http://sethrobertson.github.io/GitBestPractices/#workflow for a list of references about choosing branching and distributed workflows.
workflows	@!workflow
working	@!doesntwork
worst_prob_desc	@!doesntwork
wrong	@!xy
www	What did you do (which commands?), what happened as a result (any messages?), and what was the result you expected instead?
xy	You are asking about a solution, but we can help you a lot better if you could describe the actual problem you are trying to solve.
yolo	git config alias.yolo '!git commit -fA -m "Yolo swag!"; git push -f'
yup	Yurp.
zombie	Brainzz! More brainzzzz!  For information about detached heads, see !detached
zombies	@!zombie