I do. And I also write "vim vim thefile.txt" and stuff like that.

Finally I've written a small shell function that corrects "gi tpull" to "git pull", because that happens at least once a day.

I always typed rebnoot, so I patched Netbsd to allow rebnoot. Then I patched it still so it would say, "Rebnooting". Fun times.

Relatable. For years, I aliased mroe to more. Now I alias mroe and more to less.

My wife drafts a lot of legal documents, and has a problem with "doe snot". Which unfortunately the spelling checker is perfectly happy with.

There's defintitely room for an advanced spell checker that can say "This is valid, but probably wrong".

I just ran across Language Tool[0] recently. Free, open-source proofreading lib, can be run totally locally. Uses Google Ngrams to check for often confused words. Didn't correct "doe snot" in my synthetic test just now, but that seems like a plausibly minor extension of existing functionality.

[0] https://www.languagetool.org/

There’s at least one product trying to address the issue with “valid, but probably wrong” typos. It’s called Grammarly and for some unfathomable reason it gets advertised to me a lot on YouTube whenever Google detects I’m in South Korea; I believe they are seriously mistargeting their marketing efforts.

(That said, if it were me, I’m not sure if I would give up typing doe snot every once in a while.)

Defiantly.

The spell checker in Chrome can already do that to some extent. For example, "The men walked over their to grab they're food." gets corrected: https://i.imgur.com/NR4zyVA.png

command-not-found [1] could implement that, if it isn't implemented already. I remember a Linux distribution with an application which would let a train pass in a few seconds after typing typical commands wrong. Trust me, you'll learn to type correct when that happens because it is very annoying.

EDIT: as mentioned below, it is called 'sl'

[1] https://wiki.ubuntu.com/CommandNotFoundMagic

The spelling checker in Word has some grammar rules, try to configure those if she uses Word.

defintitely

My standard .bashrc aliases cd.. and cd- to the same thing with a space. Eliminating minor annoyances and focus-disruptors is great.

Our org has a bunch of related miscellaneous projects called "pantry". Basically, if it doesn't fit standalone, you put it in the pantry. It works out better than you think, except when someone is doing a webex and misses an r.

"Rebnooting" sounds like it should be a real word; probably a military term.

Can't tell if serious...

Knowing software developers, probably entirely serious.

The seasoned sysadmins are a little more careful before smacking the enter key...

Depends on the importance of the system. If it's a fairly unimportant home system that's excessively backed up, it's fairly easy to live life on the edge.

rm -i and rm -f (as well as mv and cp) allow to specify certainty not merely for everyone above UID 0.

Keyword: Backups.

It’s probably just a shell script or an alias

An alias would work but it wouldn't say rebnooting. That was my initial fix. But I was learning things at the time and I learned how to recompile parts of the distribution. I also learned how programs in Unix could invoke different effects based on name. Coming from DOS, it was a real surprise that reboot was a link to shutdown.

So I am assuming you ended up patching the `shutdown` binary to print `Rebnooting` if exec'd with the `rebnoot` name?

This is similar to how busybox binary implements a bunch of the tools from coreutils etc.

Try The Fuck: https://github.com/nvbn/thefuck/blob/master/README.md

I have The Fuck because I think the premise is hilarious, though I don't use it as much as I'd like since it's kind of slow for me...

It's apparently grown an "instant mode" which goes much faster: https://github.com/nvbn/thefuck/blob/master/README.md#experi...

For the latter, https://github.com/nvbn/thefuck is great and pretty satisfying to use.

(me earlier this month: https://twitter.com/sailoremo/status/908390247548911617)

If debian ever starts shipping with a util called "gi", I'm screwed!

Depending on how the scritp is written, you're screwed only if it comes with a tpull command.

`alias gi="rm -rf /"`

--no-preserve-root

sudo

Suicide git

sudocide

Yes! I do all of those things too. git git, vim vim, and 'gi tpull' and 'gi tpush' and everything.

I think any command where you might start to type something out, but then need to refer to another window or session to figure out what else you want to type, is vulnerable to this kind of mistake.

Got a weird idea reading this. How about checking for all 127 error codes returned by $? (this is the return code that the shell gets, following a failed command, due to command not found).

This process should happen behind the scenes. And then train a RNN for translating it to the following command, which returns a success code. Perhaps, we need to add a few checks that successful command has the same intent as the one which returned 127 error code to the shell.

I just alias 'pull' to git pull, it's much nicer. Also 'push' and a few of the other most common ones.

Or alias to gp, gl, gd, ga, gmv, grm, gsh, glg, gcm, gcam, gpuo, gdwd, gpuom, ...

You're joking but...

    alias g='git status -sb'
    alias ga='git add'
    alias gac='git commit --amend'
    alias gb='git branch'
    alias gbb='git checkout -b'
    alias gbm='git branch --merged'
    alias gbn='git branch --no-merged'
    alias gc='git commit -m'
    alias gcp='git cherry-pick'
    alias gco='git checkout'
    alias gd='git diff'
    alias gdc='git diff --cached'
    alias gg='git status'
    alias gl='git log --graph --pretty=format:"%Cred%h%Creset -%C(auto)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset" --abbrev-commit'
    alias gla='git log --all --graph --pretty=format:"%Cred%h%Creset -%C(auto)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset" --abbrev-commit'
    alias ggpublish='git push && git push --tags && npm publish'
    alias gp='git pull --rebase && git push'
    alias gpp='git push && git push --tags'
    alias gpl='git pull --rebase --prune'
    alias gpt='git pull --rebase && git push --tags'
    alias grb='git rebase'
    alias grc='git rebase --continue'
    alias gsp='git stash ; gp ; git stash pop'
    alias unfuckgitremote='git branch --set-upstream-to=origin/`git rev-parse --abbrev-ref HEAD` `git rev-parse --abbrev-ref HEAD`'

I have to admit I use `unfuckgitremote` more often than you'd hope.

Instead of `unfuckgitremote`, why not just use `git push -u`?

origin head

The oh-my-zsh git plugin does that -

https://github.com/robbyrussell/oh-my-zsh/blob/master/plugin...

glwt

If only there was a git shell...

There is, but it's just a restricted login shell. I see what you mean though

I put my most common git commands on keyboard macros mostly for this reason.

alias p='git pull'

why type 8 characters 100 times a day, when you can type 1?

Personally, I don't want my typos corrected when I enter commands. I prefer the negative reinforcement to encourage fewer errors. I also don't mind an occasional error.

Not hatin. Just wondering if I'm alone.

You probably aren't alone, since commands that punish you when you mistype exist. Check out sl[0] or gti[1].

[0] https://github.com/mtoyoda/sl [1] http://r-wos.org/hacks/gti

Ha -- both are amusing.

I'm the same, though I create tiny aliases for commonly typed commands. gp = "git pull", and so on.

It's not only commands. My spelling skills took a dive, as google got better and better in guessing what I actually want to search for.

Can you disable that feature somewhere ? The suggestion is good, but automatically doing the corrected query is not!

I often type "git clone ", then switch to a browser to copy/paste the URL, which is usually fine, but there are still many times where I've happened to include "git clone" in the copied string. (So I end up with "git clone git clone $URL").

<Insert obligatory "don't ever paste into a CLI because $SECURITY and then admit that I've done the same thing.>

I think that advice got warped/lost in translation: Wasn't the original advice "dont't paste stuff copied from web pages into the CLI"? - Because a bad page could covertly change what is actually copied via JS.

That danger doesn't apply when things are copied from the browser chrome (address bar) or other locations. So why would pasting then still be dangerous?

I think blindly passing on advices "because $SECURITY" can actually detrimental to security because you may end up with half a dozen esoteric practices without actually knowing what they defend against. (I know the parent was half-joking, I think that's a more general problem)

You don't even need JS. In French and in style:

    <p>un paragraphe <span style="font-size: 0;">pas si </span>innocent</p>

So disabling JS won't protect you from those.

Most shells now support a bracketed paste mode. zsh: https://github.com/zsh-users/zsh/commit/98687fa1dec803f041cb..., bash: https://www.gnu.org/software/bash/manual/html_node/Readline-... (enable-bracketed-paste)

iTerm gives you a warning if it thinks you just pasted in something malicious

I think it gives warning when you paste something ends with a `\n`.

I think my zsh does something to detect copy paste (and not execute the command till I press enter), or it could be iTerm, no idea.

Happens to me too!

The one I do is `git clone ` then paste in the repository URL from bitbucket, and end up with `git clone git clone https://....`

I don't think that can be solved here though.

I do that all the time, often with package managers (npm install npm install foo)

CTRL-u CTRL-v

Nice! Never knew about CTRL+u. Thanks.

It's so far from my left hand I prefer to press ctrl+w twice. (yes, I use the mouse a bit too much)

Hah! Bitbucket drives me nuts in many ways but this one truly is the worst!

Certainly. The user is either used to typing "git clone" or is using a GUI where you input the repo URL. How bitbucket does it would only be fine if you only use bitbucket or if everybody did it that way.

Not this, but I do fairly often think assume I'm in vim when I'm not.

`alias :q="echo NOT IN VIM!!!"`

My favorite one of these is typing ctrl-w (cut in emacs) in a browser tab as I am editing a bunch of text in a text box.

I use vimperator, so the only program I use a lot which still doesn't recognize ctrl+w is Hexchat.

My friends have gotten used to see me part the channel and rejoin shortly after, cursing my fingers.

Hexchat closing on C-w is such a pain! It can't be scripted away either because it's hardcoded in the source. I haven't looked into this for some time but there does seem to have been some updates.

https://github.com/hexchat/hexchat/issues/397

That sounds like the kind of thing that would be really easy to maintain your own fork for...

HexChat parting on Ctrl+w is probably one of the main reasons that drove me to use a TUI IRC client like weechat.

You can try Lazarus form recovery[1] to mitigate your pain. It locally saves the content of forms and allows you to pull it back.

[1] https://addons.mozilla.org/en-US/firefox/addon/lazarus-form-...

Heh, for me ctrl-w means "extend selection to enclosing expression", which leads to the same issue in browsers.

One of the things I appreciate about macOS is that it implements some of the emacs behavior (C-a, C-e, C-k). Unfortunately not C-y, and non of the M- ones work since that's for special characters. I understand they originally come from the readline library.

Now try C-k and then C-y

Then regular old Cmd + v.

You're welcome.

Well, cutting is called killing in Emacs...

So why is emodendroket referring to ctrl-w then?

In other words ctrl-w is "kill," which is what most people would think of as "cut," and ctrl-y is "yank," which is what most people would think of as "paste."

And Vimmers would think of yank as copy or kill save

That's funny. Never thought about that. I guess Emacs people think of it as yanking from the clipboard to the document, and Vim people think of it as yanking from the document into the clipboard.

I actually aliased :q to clear:

https://github.com/jez/dotfiles/blob/master/util/aliases.sh#...

I also have clera, lcear, and lcera -> clear, and :tabe -> vim.

Are you aware Ctrl-l also clears? I can't recall the last time I typed clear.

I have to admit, I wince when I see someone type clear.

Not just `alias :q exit`?

Not really, if they mean `:q` to exit vim and go back to the terminal `alias :q=exit` wouldn't produce the desired result.

could really mess with it:

> alias :q=vim -c ':q'

best one

I really do that a lot so I aliased 'q' to exit in shell.

> Does anyone else actually do this besides OP.

Guilty as charged. I'll commonly start typing git, think about something else, switch to my editor, browser or an other terminal tab, then come back and type "git <command>" in full.

Unsurprisingly…

    > rg 'git =' ~/.gitconfig 
    7:	git = ! git

Something I have noted as part of my venturing into mechanical keyboards lead me to the revelation that many of my "mistakes" were really the keyboard failing me (ie, not properly register my keystrokes). All my life I assume was me the idiot that not know how use it. Only after I pay attention to how I use the keyboard (looking at my hands for a while) I start to see this.

So, I need to more firmly hit the keys in my actual driver (MS Ergo Keyboard) and now building my own mech...

P.D: ie: Maybe one of the different mech switches are more suited to the way YOU type:

http://www.wasdkeyboards.com/mechanical-keyboard-guide

---

P.D 2: This is a reply to all the ones that state that type wrong some commands.

Also, and maybe more common, is just bad typing. I was far worse before the use of the MS Ergo Keyboard (it DEMAND to use both hands.) So, if the performance change by keyboards (happend to me) maybe is a indication that are the tools at fault here..

This happens to me all the time on the new Macbook keyboard, especially with the arrow keys. I can watch myself press the key and see nothing happen. I really need to switch to a good external Mac keyboard.

I totally do this. I also occasionally will have something breaking and soon realize I typed 'git' randomly in the middle of a file instead of in my terminal...

I do stuff like because I alt-tab a lot and have so many similar-looking windows open. It's not just me either, I have seen stuff like "git pull" posted in chat rooms followed by "oops wrong window".

All the time, at least twice already today. Another common command that I'll start typing only to switch context from is vim.

Think about all the keystrokes you'd save if you just typed "vi" instead.

That's a habit I may never break. There's been enough times that vi was actually vi.

What kind of evil system ships with both vi and vim?

OpenBSD comes standard with vi. Vim is a package.

It ships nvi, as do the other BSDs. I think it's reasonable, BSDs have a stronger divide between the base system and third party packages, I'm not sure it would make a lot of sense to maintain vim as part of the former.

Besides on my FreeBSD system /usr/bin/vi is around 400kB while on my Debian machine /usr/bin/vim.basic is 2.4MB. It's not much these days but on embedded platform it could still make a significant difference.

Yep, and "nex/nvi are intended as bug-for-bug compatible replacements for the original Fourth Berkeley Software Distribution (4BSD) ex and vi programs."

Debian is the same way. But as soon as you open a file with vi on a fresh install, you know it isn't vim, so you close the editor, install vim, and then the vi command opens vim.

It's usually more "type git in a terminal then open a new tab to look something up and ALT-TAB back to the terminal" rather than a physical going away.

I type `ls ls something` a lot because of this.

As a related issue, it bothers me a lot when I type some command that I want to read the output, and then I proceed to run `ls` right in the sequence and move the output out of the screen.

... and then you clear the scrollback (Ctrl-L) but you can't just re-run the previous command because the system is now in a different state.

FWIW, I'm also baffled that this is a problem to solve.

Surprised how many are affirming this. Kind of a DAE moment. My fingers are a bit more tame from having spell check disabled & not falling back on these typo-aliases, as shown by the author's other aliases. Especially their t-prefix aliases which imply zsh aliasing gi to git

I sometimes do, though not specifically with git. Can be emacs, can be ls, can be anything where I interrupt my thought process.

So... I really fail to see why this article is of any relevance at all, really. Or at least a more global solution would have been better, but I think it's not really an annoyance. For me, it's the same as wanting to fix a UI so that I wouldn't re-double-click a software that I've already started (well, some prevent it, and generally when they do, it means there are sessions, and it annoys me).

I do the same with man instead (even though I only used that program like 50 times the last year) … it even happens in any other program where you can input text …

Yup. With lots of commands, not just git.

Leave the computer? No, never.

The author seems to have a lot of issues with spelling.

Everyone is different. I know an electrical engineer who grew up with dyslexia. So everyone finds their own solutions.

Personally I very rarely spell things wrong in cli.

It happens to me when cloning a repo. Sometimes I just write git clone ..., go to browser and the command already contains git clone, then i end up having sth like git clone git clone ...

I do. Everyone has their own tics; one of mine is that.

I do it all the time, but never thought it was the problem. Most often its to look up a reference number for a commit,

Then I get distracted on HN ...

No. I have aliases for most things git:

gs = git status

ga = git add

gc = git commit

gp = git push

gl = git pull

gt = git tag

I never started with those two-letter aliases because they're bound to become problematic:

- gs is ghostscript

- gc is a component of graphviz

...and all of a sudden your text editor can't generate PDFs anymore when started from the shell.

Instead, I use four-letter aliases which work fine:

- gits = git status

- gitd = git diff

- gitc = git commit

..etc

I aliased 'g' to 'git'. Combined with git aliases ('st' for 'status' etc) this is almost as short but doesn't steal all the short names from your shell. So instead of 'gs' you have 'g st'. Upside is you save two letters even on uncommon git commands :)

I do not. I thought the only reason that this was on the front page was because it was funny.

+1, what are you all looking at when typing git over and over again?

I just type git (or more commonly ls/cd) once on auto pilot because I'm at a terminal then without thinking about it hard I'll type it in consciously because that's why I'm at a terminal. It doesn't even involve looking away

Yep. And I did the exact same thing the OP did about it.

Yes, I do this all the time with all sorts of commands.

Sometimes, while copy pasting.

Often, yes.

I do it fairly often.

Yup, I do.