I understand the reasoning behind this, but in practice I can't imagine working like that. I love watching Gary Bernhardt (https://www.destroyallsoftware.com/screencasts), who is an incredibly fast typist and knows Unix very well. But I just can't get over the sheer volume of typing he does, because he hasn't wrapped his most common commands into short aliases and abbreviations[0]. I would find it exhausting to do that much typing relative to the amount of output.
Here's a customization I would recommend everyone who spends a lot of time on the shell do: Be able to fuzzy find from the shell. The specifics aren't important, but here's how my bindings work (I use and recommend `fzf`[1] for this):
All of these work logically like this: If the binding is triggered at the start of a prompt, do what I mean (`cd` to directories, or edit a file), but if I've already typed something, insert it as a parameter, so for example I can hit `ls<space>⌥z` to fuzzy insert a recent directory (or just `⌥z` at a raw prompt to fuzzy select a recent directory to jump to).
I'd argue fuzzy finding is the major enhancement to computer productivity of the last twenty years. I recommend using it on the shell (assuming you use the shell often enough to justify it).
> But I just can't get over the sheer volume of typing he does, because he hasn't wrapped his most common commands into short aliases and abbreviations[0].
Interestingly I go the other way: I type fast, so I don't need to abbreviate. Instead I make my aliases and abbreviations memorable. EG for git instead of aliasing `checkout -b` to `cb` or something I alias it to `newbranch`. More typing than the two-character alias, but also more memorable than the default.
I find if a command isn't memorable I'll forget to use it, so I never build the habit needed to make it useful. Single-letter commands are especially bad for this. I've had z for years, and remembered to use it when I needed it maybe once.
> Interestingly I go the other way: I type fast, so I don't need to abbreviate.
That's definitely an interesting perspective I hadn't considered, thanks for sharing!
I'll add one more note about automation and customization (this is only tangentially related to your post, it just made me think of it): Most people talk about automation and customization about doing things faster, that is definitely not how I think about it, the goal is to reduce effort. The goal of customization, automation, and software expertise in general, is to make hard things easy.
Here's an example: Lets say you have ten different `git` repos that all have the same dependency you're updating that has an API change. If you're using entry-level tooling, this is a big hassle, e.g., if you're lucky you can do a find and replace, but you still are probably going to do it manually in each repository separately, and then you've also got a bunch of manual git commands to enter. So what do you do? Most likely you just put off the problem. But if you do this with automation, e.g., personally, I would use a combination of `vim` macros, fired on some CLI `rg`[0] matches, and some `tmux` synchronization to do the `git` steps all at once in all repos, making it essentially the same amount of work to do one repo as it would be to do all the repos. Which makes it pretty easy to do, so I just do it now to get it over with. This is my goal with automation, as an extension of software expertise, is to make what I consider to be "easy" be as much output as possible.
Here's a customization I would recommend everyone who spends a lot of time on the shell do: Be able to fuzzy find from the shell. The specifics aren't important, but here's how my bindings work (I use and recommend `fzf`[1] for this):
- `⌥z`: Fuzzy find recent directory (using `fasd`[2])
- `⌥c`: Fuzzy find recursive subdirectory
- `⌥e`: Fuzzy find recursive file
All of these work logically like this: If the binding is triggered at the start of a prompt, do what I mean (`cd` to directories, or edit a file), but if I've already typed something, insert it as a parameter, so for example I can hit `ls<space>⌥z` to fuzzy insert a recent directory (or just `⌥z` at a raw prompt to fuzzy select a recent directory to jump to).
I'd argue fuzzy finding is the major enhancement to computer productivity of the last twenty years. I recommend using it on the shell (assuming you use the shell often enough to justify it).
[0]: https://fishshell.com/docs/current/cmds/abbr.html
[1]: https://github.com/junegunn/fzf
[2]: https://github.com/clvv/fasd