Why “alias” is my last resort for aliases

nobody tell him

I came here to say the same thing. I'm also not convinced about the instant reload aspect. You can always just define your aliases in a different file and source it when updating aliases (how often does that happen anyway?), source your .zshrc, or just open a new terminal window.

Yes, and this is why I recommend against the alias-y wrappers.

Personally, I like using abbreviations ("abbr") in fish, which automatically expand as you hit space. This is especially helpful when screen sharing: No more "what does this gcob command do" questions!

This doesn't work for me in Ubuntu 22.04. Is it a recent feature of bash?

Another advantage of using alias: `which [alias]` actually tells you what that alias is mapped to, and not just the location of a script in your bin folder.

I remember years ago seeing a trick related to this to allow aliases after `sudo` (which I think by default won't recognize them due to running as a separate user) by doing `alias sudo="sudo ".

There isn't a well-defined / binary boundary to an "actual script"; I'm assuming this "note" thing is something like a 10-liner in Python. It's simply two curves of scripting in sh/bash/zsh becoming more difficult vs. Python starting with more effort but a more shallow curve — at some point the curves cross. But that crossover point is different for each person, and the other option doesn't immediately become impossible.

Here's what I use in my .zshrc with VS Code:

    alias reload="source ~/.zshrc >/dev/null"
    alias zshconfig="code --wait --new-window ~/.zshrc && reload"

the --wait flag tells zsh that it's not done executing until the window/file is closed.

I do something similar to my .bash_aliases, but with a few short additions to make sure running it multiple times doesn't have any strange side effects. For instance:

  function edit_load() {
    $EDITOR $1
    source $1
    if [ $? -eq 0 ]
    then
      echo "$1 updated."
    fi
  }
  alias aliases="edit_load ~/.bash_aliases"

  # to make sure I don't add things to $PATH on each reload
  append_path () {
    case ":$PATH:" in
      *:"$1":*)
        ;;
      \*)
        PATH="${PATH:+$PATH:}$1"
    esac
  }
  append_path '/blah/blah/bin'

Another great advantage of fish abbreviations is your history shows the actual command that was run (and in fact as soon as you've typed it, it expands, so you SEE what you're running).

This is the right way. I mentioned in another comment, but abbreviations also shine when screen sharing: Everyone can follow along quickly without having to ask the "what does this gcob command do" questions.

I like putting my "aliases" into the functions directory of my config.

I have one that uses podman if it's available when I type `docker`. If I ever specifically need Docker I can use the fully-qualified path. I have a similar trick for `nvim`/`vim`.

zsh also supports the "alias anywhere" concept (their term is "global alias") by using the `-g` flag.

   alias -g ag='2>&1 | grep'
   some-command ag 'words' # equivalent to: some-command 2>&1 | grep 'words'

This. Functions are almost always the better solution.

True, but I think that the author did not mean this as a real useful example.

At least for myself, the main benefit of aliases is not to abbreviate the command name, but to change the default command-line options.

I strongly dislike the default command-line options of most UNIX utilities, e.g. cp, mv, rm and the like, so I never invoke them directly, but only through aliases that use what I consider to be the correct default options (for instance I consider that the default for any kind of copy command must be to make an exact copy of the source, instead of losing any part of the original information).

I just create ~/rc_files.d/{functions,aliases,profiles,etc} which automatically get sourced with a `for` loop. This makes it easier to keep things organised.

Doskey is a (kind of) Windows replacement for shell aliases, and it can be configured to auto-execute macros file in new cmd.exe windows.

I know you’re not talking about Powershell, but on Windows most people would be using Powershell, and that does have good alias support.

Untested for that specific command, but in Zsh this should work:

  timeout 10 ${aliases[my_alias]}

Similar problems.

Less portable and don't give the subprocess isolation that a proper script has. That's sometimes an advantage (can modify shell state — I think that's the primary one), sometimes a disadvantage (influenced by shell state [e.g. set -e], "exit" exits the entire shell, hard to do cleanup / use signal handlers, can accidentally change shell state [like cwd].)

But I'd use a shell function over an alias if a script isn't an option.

I used to have a bunch of over-complicated aliases, but due to their limitations, I now use a mix of aliases and functions, with a few scripts in ~/bin. It’s all a matter of using the right tool. I use aliases for simple things, like default options on some commands. Things that need to happen in the current shell, but are too complex for an alias, are functions. That leaves extra-complex things that I don’t want to write a shell function for as programs in ~/bin, which can be shell, or python, or whatever.

`alias` is shell builtin.