
I've recently been replacing more and more of the standard UNIX commands that ship with most linux distros and macOS with more modern alternatives.

Some of these comands, like `du` and `df`, have been around for decades and are showing their age. They can be very useful, but often are not very user-friendly.

In this post, I'll explain what I mean by "replacing" these commands and show you how I do it.

:::note
In this post, you'll learn about:
- How to alias a command to another.
- How to preserve the original command using a backup alias.
- How to use the commands `alias`, `type`, `which`, and `shift`, as well as the parameters `$?` and `$*`.
:::


# Replacing a command with another one

One typical example is replacing `cat` with [`bat`](https://github.com/sharkdp/bat).

If you're like me, you've developed a habit of using `cat` to display the contents of a file. At this point I have muscle memory for `cat` and I type it without thinking, so I don't really want to retrain myself to use a different command.


So, it's obvious, right? Just alias `cat` to `bat` in your shell configuration file and you're done:

```bash
# `alias` is a shell built-in that creates an alias for another command.
alias cat=bat
```

Done!

Okay, wait a minute. What if `bat` isn't installed on your system? If you run the new `cat`, you'll see an error:

```bash
zsh: command not found: bat
```
Oops. Let's handle this.

## Handling cases where the replacement is not installed (yet)

To cover scenarios where the replacement command isn't installed yet, we can use the `type` command to check for its existence.

:::note
`type` displays information about a command and **exits with a status of `1` if the command is not found**. We will redirect both its output and errors to `/dev/null` to keep the terminal output clean.
:::

Here's how this looks:

```bash
if type bat >/dev/null 2>&1; then
  alias cat=bat
fi
```

Assuming there is no `bat` installed on the system, let's check where `cat` points to:

```bash
$ which cat  # `which` locates a command and returns its path.
/bin/cat
```

So `cat` still refers to the original command. Let's install `bat` and try again:

```bash
$ which cat
cat: aliased to bat
```

Great! Now `cat` is correctly aliased to `bat`.


To get a better understanding of `type`, try the following commands:
```bash
$ type cat
cat is /bin/cat

$ echo $?  # $? stores the exit code of the last executed command.
0

$ type i_dont_exist
i_dont_exist not found

$ echo $?
1
```

So if the command is not installed, `type` will return an exit code of `1`, which is what we use in our conditional.


## Keeping the original command

Okay, let's say that for some reason you have the corner case where you want to use the original command instead of the replacement. For instance, [`gping`](https://github.com/orf/gping) is nice, but sometimes good ol' `ping` is simpler and just enough.

You could always call the original command by using its full path (like `/bin/cat`), but that's tedious. Let's create a backup alias:

```bash
if type bat >/dev/null 2>&1; then
  alias cat_="$(which cat)"
  alias cat="bat"
fi
```

With this setup:
1. We check if `bat` is installed.
2. If it is, we create an alias `cat_` that points to the original `cat`.
3. We alias `cat` to `bat`.

Great!

However, there is still one (albeit small) issue. What if we source this file twice? Let's say you change some other part of the configuration and source it again. The second time `which cat` will return the aliased `cat` (i.e., `bat`) and not the original one. You'll end up overwriting `cat_` to point to the replacement instead of the original command.

To prevent this, we add an extra check:

```bash
# Check that `bat` exists.
if type bat >/dev/null 2>&1; then
  # If the backup alias `cat_` isn't already set,
  # create it pointing to the original command.
  if ! type cat_ &>/dev/null; then
    alias cat_="$(which cat)"
  fi

  # Alias `cat` to `bat`.
  alias cat="bat"
fi
```

Now, `cat_` won't be redefined every time you source the configuration file. It's defined only once, guaranteeing that it always points to the original `cat` command.

Aaand that's it! You can reuse this setup for any command you want to replace.

# Extra Credit: Aliasing multiple commands

So what if you want to alias multiple commands? You can just repeat the same code for each command, but if you're like me, copy-pasting these lines will bug the hell out of you.

Let's go further and create a function that will do this for us:

```bash
set_alias_with_backup() {
  # `$1` and `$2` are the first and second parameters passed to the function.
  local alias_name="$1"
  local new_cmd="$2"

  # Check that both parameters are provided.
  if [ -z "$alias_name" ] || [ -z "$new_cmd" ]; then
    echo "Usage: set_alias_with_backup <alias_name> <new_command> [extra_params]"
    return 1
  fi

  # In the next 2 lines, we add suport for extra parameters
  # to be passed to the new command.

  # `shift` removes the first N parameters. In this case removing `$1` and `$2`.
  shift 2

  # `$*` contains all positional parameters passed to the function.
  # It's equivalent to `$1 $2 $3 ... $N`.
  # After we shifted the first two parameters away, we're left with
  # extra parameters to be passed to the new command.
  local extra_params="$*"


  # Check that the new command exists.
  if type "$new_cmd" >/dev/null 2>&1; then
    # Define a backup alias by appending an underscore
    # (e.g., "cat_" for "cat")
    local backup_alias="${alias_name}_"

    # If the backup alias isn't already set, create it pointing
    # to the original command.
    if ! type "$backup_alias" >/dev/null 2>&1; then
      alias "$backup_alias"="$(which "$alias_name")"
    fi

    # Create the alias: e.g., alias "cat" to "bat" and pass any extra params.
    alias "$alias_name"="$new_cmd $extra_params"
  fi
}
```

And now, finally, we can happily do:
```bash
set_alias_with_backup cat bat
set_alias_with_backup df duf
set_alias_with_backup ping gping
```

You can also pass extra parameters to the new command. For example, if you always want to pass `--style plain` to `bat`, you can do:
```bash
set_alias_with_backup cat bat --style plain
```

Done! This time for real 😁. As usual, thanks for reading! If you found this post useful, please click the heart below to let me know.


Replacing standard UNIX commands


You can often hear two vastly different opinions on macOS that are opposites on the same spectrum - the OS is either great because _"it just works"_, or terrible because it is _"very limited and can't be customized"_.

I think both are wrong.

I like macOS for a couple of reasons:
1. It is Unix-like, and you can use a lot of the tools and software from the Unix world;
1. People write some great software for it;
1. It can be customized just enough (at least for now) to make it much more usable than it is by default;
1. It looks good without the need to spend hours working on it; [^1]
1. It integrates well with other Apple devices.

Having said that, I believe that in the state it comes out of the box, macOS is barely usable[^2] for more complex workflows.

There are a couple of major problematic areas:
1. window management is nonexistent;
1. finder is stuck in its ways and lacks some basic functionality;
1. the Menu bar (for Windows people - this is the alternative to the System tray) gets flooded by random icons.

All of these pain points can be alleviated to some degree using third-party software.

## Contents


# Window Management
 By default, you are given a very minimal amount of options - you can minimize, hide windows, and make windows fullscreen. You can also create multiple spaces for windows. That's about it.
 It is embarrassing how much macOS has fallen behind Windows in that regard. [^3]

There are a couple of very notable omissions:
- no window snapping/tiling whatsoever (either using the mouse or via keyboard shortcuts);
- no easy way to move windows between different monitors.

:::note
I think people underestimate how much good window management can improve their productivity, especially on small laptop displays.

Moving windows around with the mouse without snapping is a huge hassle. Full-screening apps to new virtual desktops tends to get disorienting. I often see people fumble around trying to find their windows.
:::

## Option 1: Rectangle (free)
Download from: https://rectangleapp.com.

Rectangle is a free [^4], open-source app that gives you a lot of options for resizing windows to a bunch of areas, moving windows around, etc.

Besides the keyboard shortcuts, you can also use the mouse to resize windows to predefined snap areas - e.g. move a window to the left half of the screen to snap it to the left 50%.

![rectangle options](https://rectangleapp.com/assets/images/shortcutScreenshot.jpg)
:source[source: https://rectangleapp.com.]

## Option 2: Raycast (free, paid AI features)
Download from: https://www.raycast.com/.

Raycast is an awesome tool. It is a Spotlight replacement and does much more than just window management. **I cannot recommend it enough.**

Raycast allows you to quickly open apps, execute various commands with aliases, and most importantly - has a huge ecosystem of free, open-source extensions.
I recommend setting up Raycast to start on login and to be opened with :kbd[⌘]+:kbd[space] (replacing Spotlight's shortcut).

You can browse Raycast's [extension store](https://www.raycast.com/store) to see what it integrates with. Some of the extensions I use are:
- [Bitwarden Vault](https://www.raycast.com/jomifepe/bitwarden)
- [Encoding Tools](https://www.raycast.com/eth-p/encoding-tools)
- [Home Assistant](https://www.raycast.com/tonka3000/homeassistant)
- [Kill Process](https://www.raycast.com/rolandleth/kill-process)
- [Port Manager](https://www.raycast.com/lucaschultz/port-manager)
- [Search Can I Use](https://www.raycast.com/thomaslombart/can-i-use)
- [Spotify Controls](https://www.raycast.com/thomas/spotify-controls)
- [UUID Generator](https://www.raycast.com/jmaeso/uuid-generator)
- and of course, Window management (built-in)

You can set up keyboard shortcuts and command aliases for all commands (including all the window management options).
In my setup, this enables me to hit :kbd[⌘]+:kbd[space] and type `lf` (or other short aliases) for quick window tiling of the active window.

![raycast](/images/making-macos-more-usable/raycast.webp)

This is the option I use. While it may take a bit more time to set up and get used to, this is a must-have for me.

Here are some example workflows from my system that I cannot live without.

### Moving windows around via keyboard shortcuts and aliased commands
![resizing windows with raycast](/images/making-macos-more-usable/resizing-with-raycast.gif)
Used shortcuts (this is my configuration):
- :kbd[⌃]+:kbd[⌘]+:kbd[up] to resize the window to full screen
- :kbd[⌃]+:kbd[⌘]+:kbd[left/right] to tile to the left/right and cycle between various widths
- :kbd[⌘]+:kbd[space] to launch raycast, then `lf` for "Last Fourth" to tile the window at the last 25% of the screen
- :kbd[⌘]+:kbd[space] to launch Raycast, then `trs` for "Top Right Sixth", etc

### Obtaining a 2FA token for my Discord account from Authy
![using raycast with authy](/images/making-macos-more-usable/authy-raycast.gif)
Keystrokes:
1. :kbd[⌘]+:kbd[space] to launch Raycast
1. type :kbd[at] and press space (or enter) to search authy tokens
1. type :kbd[dis] to search for Discord
1. enter

### Quickly switching between open applications
![app switching with raycast](/images/making-macos-more-usable/app-switching-raycast.gif)


# Menu bar clutter
A lot of software written for macOS wants to put its icon in the Menu bar. Some give you the option to hide the icons, but not all of them do.

Even when I disable whatever I can, things tend to get cluttered. And if you are working on a MacBook that has a notch, icons can even get hidden behind the notch.

![menu-bar](https://matthewpalmer.net/vanilla/images/notch-guide-1.jpeg)
:source[source: https://matthewpalmer.net/vanilla/vanilla-macbook-notch.html]

The main missing functionalities are:
- easily hide icons
- have the option to show the hidden icons when you need them
- be able to easily rearrange icons

There are a lot of tools in this space. There's a website dedicated to them - check out [Menu Bar Managers](https://macmenubar.com/menu-bar-managers/).

## Option 1: Bartender (paid, $16)
Download from: https://www.macbartender.com/.

![bartender](https://www.macbartender.com/Bartender5/img/quickreveal.gif)
:source[source: https://www.macbartender.com/]

This is the one I've been using - it is paid, but not on a subscription basis. They typically charge upgrade fees for major release versions once every few years.

It allows you to hide items and has a bunch of customization on top of that. It also allows you to customize the appearance of the Menu bar, including reducing the distance between icons.

In my experience, this is the best option for managing Menu bar icons.

## Option 2: Vanilla (free)
Download from: https://matthewpalmer.net/vanilla/.

Vanilla allows you to hide Menu bar icons in an expandable tray.

It is free but has a paid version with extra features. The only drawback of the free version is that it seems like they prohibit you from running Vanilla on login, which is a bit of a bummer.

## Option 3: Dozer (free, open-source)
Download from: https://github.com/Mortennn/Dozer.

Kinda the same thing as Vanilla. Free and open-source, but unfortunately development seems to have stopped.


# Finder & File browsing
I mean... if you've used it, you probably felt frustration at some point. Even though I think Finder has been improving with recent versions of macOS, it still has a way to go.

Here's a non-exhaustive list of missing things:
- no option to see folders on top,
- no split view,
- limited options to work with remote file systems.

## Option 1: Forklift (paid, $20)
Download from: https://binarynights.com.

![forklift](https://binarynights.com/images/main.png)
:source[source: https://binarynights.com.]

Forklift is a great Finder replacement. It is very customizable, has great support for working with remotes, has split screen support, and has remappable shortcuts. It has an improved UI for copying and moving things around, especially in-progress jobs.

Its license says 1 year, but it is not a subscription. You get lifetime access and 1 year of updates.

## Option 2: customize Finder as best as you can (free)

If you go to Finder's preferences, you will find options to change the default folder and to use tabs instead of opening new windows. You can also customize the sidebar to show only what you need. In "Advanced", you can choose to keep folders on top when sorted by name.

## Option 3: might as well use the terminal (free)
... If you're into it 😁

Some tools that are worth looking into:
- [fzf](https://github.com/junegunn/fzf) - fuzzy search in the terminal. Integrates well with zsh, git, and others.
- [eza](https://github.com/eza-community/eza) - `ls` replacement. Shows useful information and is easy to customize.


# Bonus round: remapping keyboard keys

Sometimes the default keyboard layout is just hard to get used to.
For example, I have a very hard time getting used to my MacBook's European keyboard layout:

![keyboard with EU layout](/images/making-macos-more-usable/eu-keyboard.webp)
:source[Keyboard with EU layout]

Notice the :kbd[~] is next to the left shift key instead of its usual location below :kbd[esc].

macOS supports some key remaps out of the box. You can go to System Preferences -> Keyboard -> Keyboard Shortcuts -> Modifier Keys and remap some keys.

I always swap the globe (:kbd[fn]) and left control keys and set :kbd[caps] to :kbd[esc]:
![remapping keys in macOS](/images/making-macos-more-usable/key-remap.webp)

For my case of the :kbd[~] key, though, nothing built-in can help. I use [Karabiner Elements](https://karabiner-elements.pqrs.org/) for that. It is a bit more complex to set up, but it is very powerful - it allows you
to remap any key to any other key.


# Misc apps a.k.a honourable mentions
- [Sound Source](https://rogueamoeba.com/soundsource/) (paid, $47) - Incredible audio management tool. Lets you control audio volume per app & device, equalize audio, easily connect to audio accessories, and much more. Unfortunately, it is pricey and also requires quite a lot of control over your system.
- [Monitor Control](https://github.com/MonitorControl/MonitorControl) (free) - Handy tool that improves support for external monitors. If you're having issues with blurriness, this might help. Also allows you to control the brightness and volume of external monitors.
- [Dato](https://apps.apple.com/us/app/dato/id1470584107?mt=12) ($10) - Nifty calendar in the Menu bar. Has great notifications for upcoming events.
- [DatWeatherDoe](https://github.com/inderdhir/DatWeatherDoe) (free) - Menu Bar weather.
- [Stats](https://github.com/exelban/stats) (free) - Show detailed system usage (disk, network, CPU, memory, battery, etc.) in the Menu bar.
- [Alfred](https://www.alfredapp.com/) (free) - Raycast's older brother. Alfred has been a thing for a long time. It is a bit harder to configure and extend, though. Currently, I don't see a reason to go for Alfred instead of Raycast.
- [The Unarchiver](https://theunarchiver.com/) (free) - Lets you extract various archive file types easily. Adds support for a lot of archive types that are not supported by default.
- [rcmd](https://lowtechguys.com/rcmd/) ($13) - Even faster keyboard-based app switching. Allows you to assign a single character key to every app and open/focus the app by hitting right command + that key.  If you use Raycast, this may be a bit of an overkill. Still, really cool and a great idea.


# Conclusion
If you were to try only one of the apps I mentioned here, I suggest going with Raycast. It is a great tool that can improve your workflow in numerous ways.

I hope I was able to show that macOS can be customized and optimized for your workflow if you spend a bit of time tinkering and are willing to use some third-party tools.


[^1]: Though I admit browsing through [r/unixporn](https://www.reddit.com/r/unixporn/) once in a while and some of the stuff there looks excellent.
[^2]: Ok, maybe I'm being a bit overly dramatic here. I recently used a "vanilla" macOS machine and was very frustrated by how hard navigating around is
[^3]: I'm not even gonna mention the Linux world, because there we've always had a sea of options, and most DEs come with very adequate window management out of the box.
[^4]: Rectangle has a paid Pro version, but you don't necessarily *need* it.


Background options

software

Replacing standard UNIX commands

Making macOS more usable