I use the Fish shell’s abbr (abbreviation) feature for my typing-saving Git aliases. Because Fish replaces the abbreviation with the full command before the command is logged and run, I can more easily spot when I ran certain Git commands when I browse my shell session or search through my command history.

For example, after defining this abbreviation:

abbr --add gitst "git status"

I can type gitst in my prompt:

$ gitst

But after pressing Enter, my session looks like this:

$ git status
…
nothing to commit, working tree clean

Then, if I leave my shell and go back to it later, I can see that I just ran git status. I don’t have to remember what gitst stands for.

Along the same lines, I can see the long form of flags in my history while spending as much time typing as if I had written their short forms. My gitspu abbreviation expands to git stash push --include-untracked, which is easier to read than git stash push -u.

I just use magit.

Surprised noone has mentioned aliasing git push --force-with-lease yet (shame this wasn’t the original default implementation of --force). (Explanation)

[alias]
   pforce = "push --force-with-lease"

or pf if you really hate typing.

(But +1 for using magit and rarely needing to run git commit line commands!)

My favorite yet cursed alias:

git config alias.save "commit --no-edit --allow-empty-message"

I say commit early, commit often, and then squash / rebase when you’re going to push something publicly.

I’ve broken tools that parse git log this way, though.

I have “git ff” for “git merge --ff-only”. And “git lol” for “git log --format=oneline”.

I like these threads, I always learn a new trick. :)

Here’s mine:

[alias]
  br = branch -vv --sort=-committerdate
  co = checkout
  dc = diff --cached
  ff = pull --ff-only
  fixup = commit --amend --no-edit
  lg = log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit
  st = status --short --branch
  wd = diff --word-diff

I use three, but of those three, only one is worth mentioning:

psuh = push

Nice, I also have “g s” and “g l”.

I can also recommend the meta process: Once in a while look at the statistics of your shell history to see which commands you enter most often. Create shortcuts for those.

# most used commands
cat $HISTORYFILE | cut -d ' ' -f 2- | sort | uniq -c | sort -n | tail -n 32
# most used first words in commands
cat $HISTORYFILE | cut -d ' ' -f 2 | sort | uniq -c | sort -n | tail -n 32

The output for me currently is:

171 cd
197 g diff
205 g l
208 g st
542 ls

I do have a shortcut “l” for “ls” but somehow I don’t use it.

 373 m
 608 v
 631 apt
 747 cd
 829 ls
1464 g

Interesting, I’m running apt more often than vim these days?

I use similar ones. A few more suggestions I use regularly:

conflict = !"$EDITOR" -c '/^[<=|>]\\{7\\}' `git ls-files --unmerged | cut -c 51- | uniq`
praise = blame
branches = for-each-ref --sort=-committerdate refs/heads/ --format='%(authordate:short) %(color:red)%(objectname:short) %(color:yellow)%(refname:short)%(color:reset) (%(color:green)%(committerdate:relative)%(color:reset))'
remotebranches = for-each-ref --sort=-committerdate refs/remotes/ --format='%(authordate:short) %(color:red)%(objectname:short) %(color:yellow)%(refname:short)%(color:reset) (%(color:green)%(committerdate:relative)%(color:reset))'

I have a ton, broken broadly into shortcuts and flow.

My most used shortcuts are

amend = commit --amend --no-edit
s = status
co = checkout
cof = checkout -f
cm = commit -m
a = add
staged = diff --staged
poh = push origin HEAD
sync = "!f(){ git stash && git pull && git stash pop; }; f"

On the flow side, basically we have a dev branch which each developer creates feature branches off (with a naming convention of <initials>/<feature name>). I have these helpers:

dev = "!f(){ git co us/dev/$1; }; f"
devs = branch --list /dev/*
rmdev = "!f(){ git branch -D us/dev/$1; }; f"
rmdevs = "!f(){ git branch -D `git branch --list 'us/dev/*'`; }; f"
mkdev = "!f(){ git fetch origin dev:dev && git branch us/dev/$1 dev && git co us/dev/$1; }; f"
mgdev = "!f(){ git fetch origin dev:dev && git merge dev; }; f"

Sometimes I’m on a machine without my usual .gitconfig and I wonder if I’ve done the right thing muscle-memorizing all my own nonsense :)

I use these:

    co = checkout
    st = status
    lg = log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit
    bn = symbolic-ref --short HEAD
    extend = commit --amend --no-edit
    reword = commit --amend
    rb = branch --sort=-committerdate

I have a bunch of aliases, but nowadays I just use magit. The most useful ones I have that weren’t in the article are probably:

  lol = log --graph --decorate --pretty=oneline --abbrev-commit
  s = status --short
  dc = diff --cached --diff-algorithm=minimal -w
  dw = diff --word-diff
  cm = commit -m
  a = add
  dd = "! git status --short | awk '$1 == \"D\" { print $2}' | xargs git rm --cached"

fish to turn every git alias into a shell alias:

git config --list | perl -lne '/^alias[.]([^=]+)/ and $1 ne "alias" and print "alias $1=\"git\\ $1\""' | source

bash:

eval "$(git config --list | perl -lne '/^alias[.]([^=]+)/ and $1 ne "alias" and print "alias $1=git\\ $1"')"

My history just looks like this:

s
h
tf
cx
a
vim app/controllers/syntax_highlighting_controller_methods.rb
tx origin
c
cb kiv-enable-darkship-globally
d
,

It looks arcane but having git be so near at hand makes it very easy to move fast.

Ok, so this isn’t that practically useful. 😢 But, let me reiterate what I said earlier: it makes you feel efficient, and maybe there’s some kind of placebo effect that actually makes you more productive.

I’d say it’s more important than that. More characters is more cognitive overhead, it’s more places where you can typo and do the wrong command, and if you need to fix something, it’s more characters to erase.

Doesn’t it seem weird that there’s support for aliases in .gitconfig? I guess this is sort of the logical succession from things like the porcelain commands but it really seems like messy scope creep compared to people just making aliases themselves in their shells or whatnot.

The internals of git feel really clean, but the UI is really hard to deal with…

I try to use even shorter aliases through my shell, here are mine: https://github.com/timvisee/dotfiles/blob/master/bash/bash_aliases#L66-L81

Mine:

[alias]
	ai = add -i
	b = branch
	ca = commit --amend
	ci = commit
	co = checkout
	cob = checkout -b
	lg = log --color --graph --oneline --abbrev-commit
	pr = pull-request
	rci = commit --amend --reuse-message HEAD
	squash = rebase -i @{u}
	st = status -sb
	todo = grep -Ee '\\bTODO:?\\b'
	fixme = grep -Ee '\\bFIX(ME)?:?\\b'
	com = checkout master
	ag = grep
	rg = grep
	ver = tag --sort=version:refname
	skip = update-index --skip-worktree
	unskip = update-index --no-skip-worktree
	publish = push -u hauleth
	cleanup = "!git branch --format='%(refname:lstrip=2)' --no-contains HEAD --no-contains master --merged master | xargs -xn1 git branch -d"