sglavoie.com – Category: Tips & Tricks

Git worktrees for a better parallel workflow

Sébastien Lavoie — Mon, 02 Jan 2023 09:52:00 -0600

Introduction

Why are Git worktrees needed in the first place? Well, there are certainly a couple of different use cases where they come in handy, but the reason they exist is to allow a developer to check out multiple branches at once without having to do any kind of cleanup when switching branches. Introduced back in 2015 in Git 2.5, it’s certainly not a new feature anymore, yet it seems like its adoption really took off more recently. I was an avid user of git stash but I often got myself cornered in some specific situations where it was not as convenient as I thought it was… and git worktree was for me a pretty good solution without much overhead.

Why is `git stash` not enough?

It can be enough, but there are edge cases where it falls short of its promise of keeping stuff neatly around without too much fuss.

Switching context

One particular use case in favor of git worktree is when you have to quickly switch context and you have a dirty branch checked out – which is basically the same use case advertised in the Git documentation. Committing changes away might be a bit risky if those aren’t ready to be pushed to the remote server and stashing files might be annoying because there could be newer files to include with git stash --include-untracked or some files already staged in the middle of the work where a git stash --keep-index is also appropriate, or maybe even a case where you have created temporary files that match ignored files where git stash --all might do. It gets even messier if you want to leave things in a clean state with only the changes you need with git stash --patch where it would be needed to select interactively all your hunks. And then, you might already have multiple stashes or you might have forgotten to give one or more stash(es) a name, which makes it harder to git stash pop or git stash apply your changes later without having to inspect the content of your stashes with something like git stash show -p.

With git worktree, this is no longer an issue! If you don’t already have a new worktree you can switch to, creating one with git worktree add is quick and easy, as shown in the docs:

bash

git worktree add -b emergency-fix ../temp master

This will create a branch named emergency-fix, creating a new worktree at ../temp checking the branch emergency-fix that will be based off the master branch. Then, you would switch to that branch which is managed with a new worktree by changing directory into it (or pushd ../temp to put the directory into a stack so you can come back later to your current branch with popd). You would add changes and commit them, likely pushing them to a remote, then you could resume your work by going back to the original directory for your master branch. Now, you could leave behind the emergency-fix branch but if that was meant as a temporary one, you could just delete the worktree with git worktree remove ../temp. Besides being removed by path, worktrees can also be removed by the name they are associated with, which is the branch name shown in square brackets when issuing the command git worktree list.

Arguably, it’s not too hard to see that dealing with temporary changes in this way is a lot more straightforward since the current changes can be left intact without having to commit or stash them.

Running tasks in the background

Whether that be running a test suite that takes a while to execute or leaving the build of a system untouched while it is happening (like building a Docker image), it can be really useful to go work on something else while leaving the original task in the background. More than this, it allows one to go on another branch and make changes to the repository while files from the other branch are being accessed. In the case of building a Docker image for instance, it could cause hard-to-find bugs if the build is stopped or failed and meanwhile files were modified in the repo on the same branch to then be copied back in the next build of the Docker image only to realize that the files being copied have changed prior to being copied.

More generally though, I find I just like to leave my terminal windows open into a specific path (branch) while having the freedom to go work elsewhere. This way, a virtual environment (for instance, in Python) can be left “activated” and ready to use when context is switched again. Often, different branches in a project might have slightly different requirements and so a distinct virtual environment must be activated. Having them entirely separated by path in separate worktrees makes this kind of workflow a lot simpler to manage.

How I operate worktrees

First, other approaches in the wild

I have seen some great programmers use them within a “bare repository”, notably ThePrimeagen in his YouTube video titled Git’s Best And Most Unknown Feature. This works by creating different directories inside the bare repository, effectively having all worktrees at the same level. There is a slight chance of colliding with a reserved directory name by Git, though, since all the metadata is stored there too.

Another interesting approach I’ve witnessed is the use of a .worktrees directory inside the directory containing the main branch of the project, which works by adding a match for .worktrees/ in a global .gitignore file (kudos to Redhwan Nacef in his Git Worktree Tutorial!). I like this approach because it can list all working trees anyways with git worktree list and there’s nothing really cluttering the directory structure. However, there might be some huge build files or environments and nesting everything that way might require creating a script to find all worktrees as it is not immediately obvious where they would be stored, if at all.

What I actually do these days

The approach I have adopted is very simple and requires almost no setup at all.

Starting with a project with existing branches

Assuming a project is already cloned and worked on with no additional worktrees, then it leads to a minor hiccup because the project will need to be renamed. So what I currently do is create a top-level directory for the project, say sglavoie.github.io for this website. Then, I will literally reuse the branch name to create some hierarchy inside that project. Let’s say that right now, I’m writing multiple articles in different branches and I keep my main branch as always, then I would first mkdir sglavoie.github.io/main and put the project’s content in there with its .git folder. Mind you, this is a one-time thing when not already using worktrees!

At this stage, the project structure is laid out nicely and ready to accommodate new worktrees. So for instance, if I want to work on a new branch to create a new article without touching the main branch, I would git worktree add ../articles/article-name-here article-name-here from the main branch and voilà, a new worktree will be ready to use. Once a couple of worktrees are created in this way, the directory structure might look as follows:

 
 
 
~/dev/sglavoie/sglavoie.github.io
├── articles
│ ├── adv-web-dev-social-network-app
│ ├── git-worktree
│ ├── react-native-app
│ └── text-based-diagrams
└── main

In this way, it’s just a matter of changing directory and opening the worktree in your editor of choice (e.g., nvim for neovim or code . with VS Code). From now on, it’s easy to switch between branches of a project right from the editor by searching for the “topic” (e.g., main or articles in this case, but that could be hotfix or feat depending on how your name your branches) or for a project name directory, which would show all the branches that have been opened previously to allow further filtering. This is what git worktree list would display in this example:

 
 
 
/some/path/sglavoie.github.io/main d67dd8d2 [main]
/some/path/sglavoie.github.io/articles/adv-web-dev-social-network-app 666a0b43 [articles/adv-web-dev-social-network-app]
/some/path/sglavoie.github.io/articles/git-worktree d67dd8d2 [git-worktree]
/some/path/sglavoie.github.io/articles/react-native-app bcfac34e [articles/react-native-app]
/some/path/sglavoie.github.io/articles/text-based-diagrams 4b25371d [articles/text-based-diagrams]

New worktrees from a project already using worktrees

If you’ve already embraced this approach, then the next time you want to create a worktree, it will just be a matter of switching to the “base” branch you want to create a worktree from and creating one at whatever location you fancy outside the current directory. For instance, for this article:

bash

git worktree add ../articles/git-worktree articles/git-worktree

This would take care of using the branch name “nesting” convention (e.g., feat/feature-name, hotfix/bug-name, etc.) and create sub-directories as needed too. Assuming a worktree has been merged in another branch and/or is no longer necessary, it can be removed with git worktree remove git-worktree in this example (where git-worktree is the name given to the worktree… a bit confusing here, you’re right).

Keeping worktrees around

Although the official Git documentation presents a useful case for a temporary fix where the worktree is almost immediately deleted upon the completion of a task, I have found myself in a situation where I’d rather have multiple longstanding worktrees. For example, I regularly need to boot a web application from a different branch, either because the currently checked out branch does not have the necessary requirements installed or because I want to leave a web application running in the background without affecting my current work. In my case, I use it to process some data when it arrives and come back to the work I was doing earlier, doing practically the same thing shown in the Git docs but keeping the worktree around for future use.

On a large project, I might have a couple of worktrees, but still I would keep branches around without them being part of worktrees when these are meant to be short-lived feature branches that share the same dependencies as other branches as long as they won’t need to be checked out at the same time. Another time I might have separate branches like this could be to avoid having to duplicate gigantic node_modules or .venv directories when not needed, because working with different worktrees is pretty much like cloning an entire repository in a separate folder and having to reinstall requirements. There is also a nice Git feature where worktrees are prefixed with a plus sign when issuing git branch, so that makes them distinctly different from regular branches:

 bash
 
 
 
$ git branch
+ articles/react-native-app # worktree
 gh-pages # other regular branch
+ git-worktree # worktree
* main # currently checked out

Conclusion

I have briefly touched upon a downside of worktrees, which is that it’s almost like cloning over and over a repository, which can take up a lot of disk space with large projects. Nevertheless, this is a tradeoff I am entirely willing to make given the advantages Git worktrees bring with them! If you’re not already using them, maybe this little post might have inspired you to give them a go!

Resources and references

External links

From this website

Ignoring Sync of Local Files to Dropbox on Linux

Sébastien Lavoie — Sat, 30 Nov 2019 13:22:00 -0600

Introduction

Dropbox is an awesome company which has been until recently the working home of none other than Guido van Rossum, the creator of the Python programming language. It works like a charm out of the box on Linux and can be installed easily enough through the package manager that comes with your chosen distribution.

Why Dropbox?

In my experience, it has been working flawlessly and syncs consistently faster than Google Drive. It’s also worth mentioning that there is still no official Google Drive Linux client to this day: some users of the GNOME desktop environment will connect to their Google account and mount Google Drive within the file manager Nautilus/Files; other users will use the paid software Insync or the free software alternative ODrive. No thanks.

On the other hand, Dropbox is easy to use with any flavor of Linux and also syncs seamlessly with mobile devices. I use Dropbox for its convenience, but other solutions exist like Syncthing that do not depend on proprietary software and third-party cloud services. I store mostly insensitive information in my Dropbox account and for the few files that happen to be a bit more sensitive (such as the password database I synchronize on both desktop and mobile with KeePassXC and Keepass2Android, respectively), they are of course encrypted (hopefully in a secure way).

Because I like to keep things simple and light on system resources, I do not let Dropbox run in the background (it only syncs once a day in the evening). Since all one needs to do in order to use it is to create and modify files inside a specific folder (such as ~/Dropbox by default), it can just synchronize at any moment and conflicts will be handled automatically if you make changes in more than one place that’s being synced.

So, what’s wrong with Dropbox?

With all that said, there’s one little feature that I find missing with Dropbox when using the official Linux client and that’s the ability to selectively sync local files. Yes, there is a selective sync feature available, but that will delete the local copy of your files and store them in the cloud only, not the other way around by keeping your local files intact and prevent uploading them to the cloud. There are some hacks you can do to avoid this, but this isn’t a particularly enticing work flow, because we can do better.

You may have heard of other alternatives like GoodSync that allow, through yet another third-party proprietary software, to ignore specific files at your request. That’s not what we are after here: instead, there’s something you can do from the terminal that works quite well, too. At the time of this writing, it is still a beta feature according to this page:

This feature is currently in beta and not available to all Dropbox users. It will be rolled out to more users in the future.

Yet, because you can work with this feature programmatically to ignore and un-ignore files from your Dropbox directory, I thought it was worth giving it a try. Here is how I’m using it to give you a few ideas.

Any simple example?

Getting started is quick and painless. To ignore a file within your Dropbox folder, you only need to use the attr (on Linux, else xattr on macOS) command to set (-s) (or -w write on macOS) the special attribute com.dropbox.ignored to give it a value of 1 (-V 1) so it ignores a file (file.txt in this example) as follow:

 bash
 
cd /path/to/file/in/Dropbox/folder

attr -s com.dropbox.ignored -V 1 file.txt # Linux
xattr -w com.dropbox.ignored 1 file.txt # macOS

Ignore all .git and node_modules folders

Things get really interesting when we can do that automatically by matching a specific pattern (it depends who you ask, anyways). How about exploring recursively the whole directory tree to exclude only hidden .git folders? Suppose you store your Git projects in ~/Dropbox/git/. You would then do something like this:

 bash
 
 
 
cd ~/Dropbox/git/

# Linux
find . -type d -name ".git" |
 xargs -I {} attr -s com.dropbox.ignored -V 1 "{}"

# macOS
find . -type d -name ".git" |
 xargs -I {} xattr -w com.dropbox.ignored 1 "{}"

In an instant, you will start getting some feedback printed to the terminal for each .git folder that is being found:

Attribute "com.dropbox.ignored" set to a 1 byte value for ./path/to/.git:
1

Dealing with node_modules folders is equally easy. Because a message will be printed to the console every time a file attribute is changed, you could want to delete the output (preferably once you are sure you are modifying only the targeted files!) by redirecting it to /dev/null, a null device that discards all data it receives. We can always split a long command onto multiple lines with a backslash character \ like so (it’s not required right after the pipe | symbol):

 bash
 
find . -type d -name "node_modules" |
 xargs -I {} attr -s com.dropbox.ignored -V 1 \
 "{}" > /dev/null

Can we make this simpler?

Yes we can! An alias might be a bit hard to manage, but we can definitely create a set of functions that will be accessible from anywhere in the terminal. It suffices to add them to your shell configuration file, which could be located in ~/.profile, ~/.bash_profile, ~/.zshrc or something else depending on your shell.

One solution that I see fit for this purpose is to have two distinct functions that have antagonistic effects so that we can revert our changes in a pinch. Basically, setting a value of 1 for the attribute com.dropbox.ignored ignores a file while setting it back to 0 tells Dropbox to sync it again. Our functions could be conveniently called dropbox-ignore and dropbox-sync.

Now, the following functions could become quite a bit more complicated to take into account various scenarios and custom behaviors, but let’s keep things simple and assume that the user knows what is going to happen. We could have our two functions as follow:

 bash
 
 
 
# Ignore specific files/directories in Dropbox
dropbox-ignore() {
 arg1=$1
 arg2=$2

 if [ -z "$arg1" ] || [ -z "$arg2" ]; then
 echo "Usage: dropbox-ignore <f|d> <name> (e.g. dropbox-ignore d .git)"
 return 1
 fi

 find ~/Dropbox -type $arg1 -name "$arg2" |
 xargs -I {} xattr -w com.dropbox.ignored 1 "{}"
}

# Sync specific files/directories in Dropbox
# that were previously ignored (or not)
dropbox-sync() {
 arg1=$1
 arg2=$2

 if [ -z "$arg1" ] || [ -z "$arg2" ]; then
 echo "Usage: dropbox-sync <f|d> <name> (e.g. dropbox-sync d .git)"
 return 1
 fi

 find ~/Dropbox -type $arg1 -name "$arg2" |
 xargs -I {} xattr -d com.dropbox.ignored "{}"
}

How do you use those functions?

Our commands will be accessible by typing dropbox-ignore and dropbox-sync the next time we open a terminal window. Both functions do exactly the same thing, but dropbox-ignore sets the attribute value to 1 to ignore files and dropbox-sync sets the attribute to 0 to allow syncing to happen.

_{Note: For simplicity and practicality, keep in mind that those commands will search recursively from the specified directory. It’s also good to know that if you set an attribute value to 1 then back to 0 again, Dropbox will need to re-sync the affected files and directories.}

We need to pass them two arguments: the first is the type of search to perform (pass f for files and d for directories) and the second is the pattern to match in the name (node_modules or .git would fit here, no need to use quotes). Concretely, that will look like this:

 bash
 
# To ignore a file matching the pattern `myfile`
dropbox-ignore f myfile

# To avoid syncing node_modules/ directory
dropbox-ignore d node_modules

# Te re-add a .git/ folder to Dropbox
dropbox-sync d .git

Conclusion

This tip may certainly not be the best approach to solving this particular issue with Dropbox on Unix, but I hope you find it useful nevertheless as it worked out very nicely on my end! One could store files and directories elsewhere, working with symbolic links or hard links as necessary to reference files or simply give up on making a backup with Dropbox in some circumstances. But I like to keep an extra copy of projects I’m working on in Dropbox and that can include potentially large files that don’t need to be backed up, so ignoring what’s not indispensable can speed up the syncing process tremendously while keeping disk usage in the cloud possibly much lower.

Dropbox only calculates the size of the files being synced in the cloud, so you can end up needing a lot more space locally if you ignore a number of big files or, conversely, selectively syncing many files will result in a cloud storage larger than what’s needed locally.

Using dmenu to Optimize Common Tasks

Sébastien Lavoie — Sun, 10 Nov 2019 09:02:00 -0600

Introduction

dmenu is one of those tools that look a little unimpressive at first but can accomplish so much! It’s a program that you can use to receive any output redirected from other programs (through pipes in the terminal, the symbol |) and treat that output so that it can pop up within a simple menu to make it available for execution. If you want to know more about other fantastic tools from suckless.org, I went over some of them before, such as the st terminal and slock, a dead simple screen locker.

Any Simple Example?

You bet! Before diving in with how to install it and some more concrete examples, you could give dmenu a go with a simple command such as the following (assuming the program is installed on your machine).

bash

ls | dmenu

This will effectively “pipe” the output of ls into dmenu and a menu like the following would appear (by default, it shows as a thin stripe at the top covering the width of the screen):

If you start typing, the displayed list will be filtered down like so:

You can also switch to the next item to be highlighted by typing Ctrl + n, to the previous item by typing Ctrl + p and exit by reaching for the Escape key. For now, if you type Enter once your desired selection is highlighted, the selection will be outputted to the terminal and that will be the end of it. Let’s convert this into a practical thing, then.

Keeping the same output as before which only contained directories, we could open a file manager (here, I’m going with pcmanfm) and do something like this (bear with me, the explanation follows!):

 bash
 
ls | dmenu -l 5 | xargs -I {} pcmanfm "{}"

This is now a fully functional example, albeit its practicality is debatable. What will happen, exactly?

First, ls will output a list of directories in the current working directory. That is, the following would be printed in the terminal without any piping:

Desktop Downloads Learning Pictures Public Templates virtualbox_vms
Documents Dropbox Music Programming SortOut Videos

When we pipe this into dmenu, we will get a menu with all that output nicely formatted vertically, which is what the -l 5 options does (here, we want only 5 lines to show). We will see a maximum of 5 items as this is the value we passed to the -l option:

We can still start typing a word that doesn’t show up in this list like Mu and we will see that this list is filtered to only include the matching directory Music even though we couldn’t see it before since we limited our results to 5 items. We could also use the same technique with Ctrl + n and Ctrl + p to cycle between the elements.

Up to this point, we are getting our selection outputted to the terminal. Next, we pipe it into xargs, which will allow us to specify a command to which we will pass our result (what is printed to the terminal) as an argument (we could make use of more arguments depending on the output we get, but let’s start simple). The -I {} option will make it possible to “quote” our result so it is read as a single argument and properly escaped. This means that without this option, if we have spaces or other special characters in the argument (such as a folder called My Music), it would try to pass each word as a new argument to pcmanfm, trying to open both My and Music directories at once.

We are representing our output as {} and when we quote it with pcmanfm "{}", spaces are interpreted without any trouble. If we wanted to use various arguments instead, we could try something like this:

 bash
 
echo "file1.txt file2.txt\nfile3.txt file4.txt" | dmenu -l 2 | xargs cat

The part before the first pipe character will print to the terminal those two lines:

file1.txt file2.txt
file3.txt file4.txt

When we pipe this into dmenu -l 2, we will get this menu:

Typing Enter on one of the highlighted items would then trigger xargs to pass the content literally to cat as arguments, which would then print to the terminal the content of both file1.txt and file2.txt (the first line containing two arguments for cat) or the content of both file3.txt and file4.txt (the second line also containing two arguments for cat) in succession.

Now that we got our feet wet with what dmenu does (displays a menu), we might want to install it.

How do You Install It?

In Manjaro Linux, it comes with i3 if you use that flavor of the distribution and can be opened by pressing the modifier key (either Super/Windows key or Alt key) along with the letter d, as in the shortcut mod + d, or by typing dmenu_run in a terminal, which will present a list of installed applications to launch. Otherwise:

Debian-based (such as Ubuntu)

bash

sudo apt install dmenu

Arch-based (such as Manjaro)

bash

pacman -Syu dmenu

You can also install it from your distribution’s package manager if available or from source.

Useful Real-World Examples

Here are a couple of ways I like to use dmenu to open a menu with a list of:

cheat sheets;
filesystem paths;
most used documents;
documents & books I read at the university;
custom scripts I want to run in the background.

Here are a few screenshots of how it currently looks like in my daily usage so you get a better idea.

Cheat sheets

University shortcuts

File manager shortcuts

So, how does that all work? As a starting point, all of those menus are launched through a specific keyboard shortcut that uses a mnemonic for each one (mod being the “modifier” key on i3, which is set to Super/Windows):

mod + Alt + c: cheat sheets;
mod + Alt + d: documents;
mod + Alt + f: file manager;
mod + Alt + s: scripts;
mod + Alt + u: university.

Let’s take the cheat sheets example, which is a bit more interesting since it launches different applications.

Setting Up a Custom Command

Configuration for i3 (bind a keyboard shortcut)

Here, I’m using i3 to set a keyboard shortcut to run a specific command, but this will be a similar experience on other window managers and desktop environments.

 bash
 
 
 
# i3config file
# The backslash at the end of the line allows us
# to split the line to increase readability

## Cheatsheets

bindsym $mod+Mod1+c exec --no-startup-id \
cat path/to/cheatsheets.conf \
| dmenu -l 30 | sed 's/.* \+//' | sh

You would usually be able to launch a custom command from your environment through a keyboard shortcut. If passing a direct command such as the above one isn’t an option, you can always store it in a Bash script and run that Bash script instead as the designated custom command. The script would then contain the following:

 bash
 
#!/bin/bash

## Cheatsheets
cat path/to/cheatsheets.conf \
| dmenu -l 30 | sed 's/.* \+//' | sh

As far as i3 is concerned, that’s all you need to do. You would need to reload the configuration file (by default: i3config) where the previous bindsym command has been set up to apply the changes (default shortcut to reload: mod + Shift + c).

Configuration for cheatsheets.conf

The content of this file is literally what will be shown when dmenu opens it. An excerpt:

 
#---------- Cheat Sheets -------------------------------------------------------
bash st -e nvim path/to/bash.sh
git zathura path/to/github.pdf
vimwiki firefox path/to/vimwiki.html

Here, we have set a maximum of 30 lines to be displayed (-l 30). What follows after an element has been selected with dmenu allows us to parse the content of the line and retrieve only the command we are interested in with sed before passing that filtered content around to sh to execute it as a shell command. With more complex commands requiring multiples arguments to be received, we could add one more pipe between sed and sh like this (or with xargs -I {} to avoid problems with spaces):

 bash
 
cat path/to/cheatsheets.conf \
| dmenu -l 30 | sed 's/.* \+//' | xargs -r | sh

If the line we want to run only includes a path to a file as in:

myshortcut path/to/file.pdf

We could instead pipe it into an external command of choice if the same program applies to all items presented in the menu, say Firefox:

 bash
 
cat path/to/file.conf \
| dmenu -l 30 | sed 's/.* \+//' | xargs -I {} firefox "{}"

What’s nice with the way pipes work in a Unix-like system is that we can chain harmless commands until the very end so they will simply be printed to the terminal. In this example, if we want to see how to filter our lines before running a command, we can do so as follow.

Pipe 1

 bash
 
cat path/to/cheatsheets.conf \
| dmenu -l 30

If you remember from the menu we saw earlier, there’s a shortcut to open a cheat sheet for Git. Let’s say we selected that one with dmenu. Because our command isn’t doing anything with the result, it will be outputted to the terminal like so (just like in the excerpt of cheatsheets.conf):

bash

git zathura path/to/github.pdf

What sed does here is to cut everything from the beginning of the line up to where the command starts (that’s where we find zathura, which is a powerful document viewer), because we need to isolate that part of the line so it looks like a shell command we could run on its own. Let’s add a new pipe to our command and see what sed does with it*.

* _{We could have used other tools to parse the string like awk, grep, cut, etc.}

Pipe 2

 bash
 
cat path/to/cheatsheets.conf \
| dmenu -l 30 | sed 's/.* \+//'

If we select the same item as before with dmenu to illustrate more clearly what this new addition does, we will get this output:

bash

zathura path/to/github.pdf

If we were to type this in the terminal (assuming the file exists and zathura is installed!), that would do the trick and it would open with the specified document viewer. Pipe 2 and subsequent pipes before we execute something is where the filtering magic happen. In short:

Everything before | dmenu is how our input will look like when we run dmenu;
Everything after | dmenu [options here] | is what we need to do to our input so that it is converted into a working shell command;
Finally, what comes after the last pipe (either xargs, sh or a combination of both) is our way to redirect our string to the shell so it can be executed.

Once we are visually satisfied with how our command is supposed to look like (it has to be something that works when typed directly in the terminal), the next step is to pipe it again so it can be executed.

Pipe 3

 bash
 
cat path/to/cheatsheets.conf \
| dmenu -l 30 | sed 's/.* \+//' | sh

There we go, the command is launched. If we keep the same simple syntax in all of our .conf files —or whatever extension we choose— where the content of our menus is stored in plain text, we can quickly and painlessly create keyboard shortcuts to run custom lists of commands that can be edited on the fly. Once our shortcuts are active, it’s only a matter of editing one of those .conf files and automatically our lists will be up-to-date when we trigger the shortcut again.

Running a Custom Script

If we want to run custom scripts, we need to indicate a command that would work in the terminal, such as python myscrypt.py or ./myscript.sh. When it comes to shell scripts, we have to make sure they are executable. We can do so through a file manager or within the terminal like this:

bash

chmod +x path/to/script.sh

This will add the necessary permissions for the user to execute the script. As we already know, we would then need to add a keyboard shortcut to launch our custom menu and store our command in a file like scripts.conf that would contain the following:

#---------- scripts.conf -------------------------------------------------------
myscript script.sh

And that’s all there is to know to get piping with dmenu! You may also find this video from Luke Smith on YouTube to be quite helpful as well, which is where the inspiration for this post came from. He also posted a complementary video about adding prompts to your commands which is a nice way to add interactivity to your scripts!

Chaining dmenu prompts

Another useful scenario is when you want to take a specific action based on the output of a previous command. For instance, let’s say you want to read a book but when you choose a pdf with dmenu, you want to be prompted for which reader to use while you want to let the system choose the default application for other types of files (e.g. epub or mobi). This could be achieved with a script similar to the following one:

 bash
 
 
 
#!/bin/bash
FILE=`find ~/Documents/calibre_library -type f -iname "*.pdf" -o \
 -iname "*.epub" -o -iname "*.mobi" | dmenu -l 30`

if [[ "$FILE" == *.pdf ]]
then
 READER=`echo -e "zathura\natril" | dmenu -i -p "Which reader?"`
 $READER "$FILE"
else
 xdg-open "$FILE"
fi

Here’s what’s happening:

We find all the files (-type f)
in the directory ~/Documents/calibre_library
that match a pattern that’s case-insensitive with -iname (here, ending in either pdf, mobi or epub)
matching one file at a time (-o can be interpreted to mean “only” and will keep searching if the previous file extension was not matched)
then presenting 30 lines (-l 30) of results at a time with dmenu
then, if the file is a PDF, prompts whether to use atril or zathura as the file reader and open with the chosen program
otherwise, open the file with the default application.

Customize the Look of dmenu

As they say, “beauty is in the eye of the beholder”. If you would rather make some changes to how dmenu look, you can. dmenu will be searching for the configuration file located at ~/.dmenurc, which could contain something as put below (with this configuration, it will look like the screenshots shown previously):

 bash
 
 
 
#
# ~/.dmenurc
#

# define the font for dmenu to be used
DMENU_FN="NotoSans-10.5"

# background colour for unselected menu-items
DMENU_NB="#161925"

# textcolour for unselected menu-items
DMENU_NF="#fdfffc"

# background colour for selected menu-items
DMENU_SB="#235789"

# textcolour for selected menu-items
DMENU_SF="#fdfffc"

# command for the terminal application to be used:
TERMINAL_CMD="st -e"

# export our variables
DMENU_OPTIONS="-fn $DMENU_FN -nb $DMENU_NB -nf $DMENU_NF -sf $DMENU_SF -sb $DMENU_SB"

Conclusion

Hopefully this introduction to what dmenu has to offer gave you some ideas. I hope you’ll find many ways to adapt the examples so you can benefit from this amazing tool. You can find more configuration details in my dotfiles on GitHub for anything related to i3, dmenu, zathura, st, slock and many more useful programs.

Have a good time automating your digital life!

Tag Navigation in Vim

Sébastien Lavoie — Fri, 19 Apr 2019 17:52:00 -0500

Navigate inside the current buffer

There is a command gd that stands for Goto local Declaration. It is quite useful when looking for a variable inside the current buffer as it allows to jump to where it is declared when the variable is under the cursor. Using that command, you can also find where a function is declared and it will find the first occurrence in the current function. If looking for the first occurrence in the buffer, gD (Goto global Declaration) will do the trick. You can jump back and forth to where you were with the commands Ctrl + O (older position) and Ctrl + I (newer position) in normal mode.

Navigate inside all buffers within the current project

To be able to jump between buffers and go back to the origin of a declaration when it is imported in the current module, generating tags comes in very handy as it allows you to use the command Ctrl + ] to jump to a tag, just like when using the help pages in Vim.

To make this work, we can conveniently use ctags. First, we need to make sure it’s installed on the system as follow:

Debian/Ubuntu

bash

sudo apt-get install ctags

bash

sudo apt-get install exuberant-ctags

OS X

bash

brew install ctags

You can put the following command in your configuration file to be able to generate the necessary tags inside Vim by typing MakeTags in command mode:

 vim
 
command! MakeTags !ctags -R .

This will make it easy to remember how to do it. After that, open an existing project in its root directory and use this newly created MakeTags command to generate the tags. This will create a file named tags in the current working directory*. Now, you will be able to open any file inside your project and jump to all the available declarations with Ctrl + ].

* _{Note: This will create tags recursively from the current working directory, not from the path matching the current buffer.}

If you go to a tag that leads you a few declarations away in one file or another, you can come back with Ctrl + T. Here is a clear explanation from Vim’s help:

The most obvious way to use this is while browsing through the call graph of
a program. Consider the following call graph:

	main ---> FuncA ---> FuncC
	 ---> FuncB

(Explanation: main calls FuncA and FuncB; FuncA calls FuncC).
You can get from main to FuncA by using CTRL-] on the call to FuncA. Then
you can CTRL-] to get to FuncC. If you now want to go back to main you can
use CTRL-T twice. Then you can CTRL-] to FuncB.

To keep those tags useful when you update your project, you can map a sequence that saves the buffer you are working on and then regenerates the tags automatically. Here is an example:

 vim
 
nnoremap <leader>W :w<CR>:MakeTags<CR>:echo 'ctags have been updated.'<CR>

And on this note, we’re ready to conquer the world.

Dispose of Spam with Disposable Emails And More!

Sébastien Lavoie — Wed, 03 Apr 2019 20:08:00 -0600

Introduction

If your privacy matters to you even just a little, read on, if you dare. There are easy solutions you can apply right now to filter those fools out of your digital life.

Why should I care?

Once your main email address is exposed to attacks because it was leaked in a data breach or your data was somehow sold to a third-party service, it is a hard and time-consuming process to try to unsubscribe to everything or apply filters to automatically delete most of the bad stuff coming in. Many websites won’t respect your privacy and will go ahead and share your email, which can eventually have a snowball effect and you end up getting more emails than there are trees available to print them. As with printing emails, you must agree this is totally irresponsible and should be punished by law .

Because attackers can often retrieve your complete name from your email address (either because you signed up for a service sharing your information from another provider or it’s easy to associate it with you on social media, for example), they can craft advanced phishing emails or create content that’s magically relevant to you thanks to social engineering and if you don’t look close enough, you can fall into their trap.

Then suddenly, because you opened an attachment or went into the dark corners of the Web unbeknownst to you, your laptop fan is spinning all the time at full speed or you get a colorful pop-up telling you that all your files have been encrypted and a ransom, along with only unrecognizable files on your system, convincingly dictates what your destiny looks like. At this point, you are doomed, unless you actually take pleasure in formatting your computer once in a while for the shear joy of it.

So what shall we do about it?

Solution #1: Use a temporary email

This one is quick and easy. You can use a variety of services, including Temp Mail Address, Temp Mail and ThrowAwayMail to name a few. Those are all free services and allow you to get access to a temporary email address and its associated inbox.

Perfect for all those cases when you want to receive a freebie or have access to a specific page that asks for an email and a real name. You simply give a fake but working email address and you’re good to go. Don’t even set it and forget it.

Solution #2: Use a more controlled approach

There is one particular service that I have been using for almost a decade now that eats your spam away on demand. That service is appropriately called Spamgourmet. Does it work? Here are my personal stats:

Your message stats: 805 forwarded, 14,191 eaten. You have 245 spamgourmet address(es).

Does it really work?

Oh yes! From the above stats, you can see that from a total of 14,996 messages being sent to me, I have not received almost 95% of it thanks to Spamgourmet working on auto-pilot all the time… And it’s important to mention that the other 5%, I actually wanted to receive it.

How does it work?

You can create as many email addresses as you require to login to most websites that you do not intend to use regularly and create a label Filtered mail in your inbox or something similar that matches anything sent to *@spamgourmet.com. You can create addresses on the fly without ever needing to log into your Spamgourmet account and set how many emails can be sent to a specific address all at once.

With very few extra steps, you can manage your email addresses on Spamgourmet, remove the ones you don’t want anymore, reset how many emails can be received (increase/decrease that number), etc. You can find out exactly how it works on the main page of Spamgourmet.

Why consider this approach instead of solution #1?

This approach has the advantage that you can know exactly where your spam is coming from and exactly when, as your email may be used quite a long time after your original registration with a service to spam you. If you have created an account on, say, clouds.com with your special email created on the fly without ever needing to go to Spamgourmet, let’s say it’s clouds.my_username@spamgourmet.com, if you receive spammy content sent to that address six months later, don’t look too hard: you know who did it.

Not only you know this, but you can keep on using this made up email for as long as you wish. Need to be in touch with a person who doesn’t fall into any of the categories ['friend', 'acquaintance', 'work', 'intimate', 'trustworthy']? No worries, instantly claim something.my_username@spamgourmet.com and that’s the email you give that person. Since it doesn’t expire and you have full control over how many more emails you can receive at that address at any time, it can simplify a few exchanges where you don’t really want to share your real email, not even to the Nigerian Prince. This way, you can even receive attachments just as normal!

You can even go as far as having trusted senders (from whom you can receive as many emails as you define) and send mail from your custom Spamgourmet emails, including with attachments! For this, you can visit Spamgourmet and generate an email of your choice that will be sending to a specific address email. You will simply send the email to this specially generated address from your email account and voilà! The person on the other end will have a hard time figuring out your real address, except if you added it in your signature.

Solution #3: Using filters

Gmail is one email service that allows you to create filters as you wish: let’s take advantage of that. What you could do is delete only messages that match exactly the groups of terms you never want to read as to not exclude important emails. To create one filter for all of them, you can use the field has words and enter something like the following in the case of GDPR policy updates:

"Privacy Policy Update" OR "GDPR" OR "General Data protection regulation" OR "Updates to our terms of use" OR "Updates to our privacy" OR "updating our privacy" OR "updated our privacy"

If you know more specifically how the words you are looking for appear, you can check for turns of phrases such as Updates to X's Privacy Policy and manage them with the keyword AROUND <number>, where <number> is how many words can be around what you are searching:

"privacy policy" AROUND 3 update

This will look anywhere in the subject or in the content of the email and find the word update as well as updates near the match privacy policy. If you are interested in looking for the word update but not updates, you can specify an exact match with the + sign right in front of it: +update.

_{Note: If you go too broad with the chosen keywords, you may not be able to reply to everything you would like to…}

A next step could be to filter potentially important emails with more keywords but instead of deleting them, you can select a few options for your filter such as Skip the Inbox (Archive it), Mark as read, Apply the label and Never mark it as important. That way, you still have access to all those emails and you can review them separately and quickly at your convenience.

For a list of available search operators, you can refer to this Gmail help page — Search operators you can use with Gmail.

Solution #4: Use the `+` symbol in your email

Gmail lets you add a + symbol in your email address. For example, you can set up your ServiceNameHere email to be username+ServiceNameHere@gmail.com. That way, you know where your spam may be coming from, but it is always more effective to just use a unique address with the above service or even forward emails from another Gmail account so you never have to give away your main email. By doing this, you can then set up filters for individual services. This doesn’t work for all websites as sometimes the + symbol isn’t allowed. In that scenario, there is another way…

Solution #5: Forward secondary emails to your main email

This is pretty straightforward and even though you initially have to do more work to set things up, this can work very well for various reasons:

You get 15GB on each Gmail account. This can be useful, as long as you don’t abuse it and get banned for life without the possibility of ever communicating through email ever again in your lifetime.
You can apply custom filters such as send to trash for each secondary account before forwarding what’s left to your main account. You can then apply a filter in your main account to visually get a hint of where the email is coming from, like a label my.second.email@gmail.com.
You can stop forwarding emails at any moment if you decide. You will have to log into your secondary account and click a few buttons there, but it’s easy, almost painless and you shouldn’t have to repeat the process so often that it gets boring.
You can even set up your main account so that you are able to send messages from your main account as if it were coming from any of your secondary accounts. No more account switching: you get something sent to my.second.email@gmail.com in your main account and you can have it set up so that when you reply to that email, it is automatically sent from that secondary email instead of the main one.

Conclusion

I hope you found something useful in this rambling about spam. I don’t like spam myself, so if you have any tips or tricks you would like to share with me to help in this quest for freedom, please reach out to me at my email shared in plain text at sebastien39571@gmail.com.

Executing Shell Commands in a Python Script

Sébastien Lavoie — Fri, 08 Mar 2019 14:34:00 -0600

Introduction

Python is awesome for producing high-quality code quickly and efficiently, but it is not necessary to reinvent the wheel in each project: this is why the third-party library on PyPI is so extensive. There are also occasions when it is convenient to execute shell commands available in the terminal, either to retrieve its output or to perform some work in the background. I have wanted to do both when building this website, so here is one way to accomplish this!

Retrieve the output

 python
 
 
 
def read_tree():
 '''Execute `tree` command and store the output in
 `tree.txt`.'''
 tree = subprocess.getoutput(f'tree .')
 print(tree)
 with open('./tree.txt', 'w') as f:
 f.write(tree)


read_tree()

In this example, the structure from the current directory is printed when executing the code and it is later stored in a file. The output could look something like the following:

 
 
 
.
├── database_example
│   ├── example.sqlite
│   ├── db_manager.py
│   ├── review
│   │   └── sql_queries.txt
│   └── settings.py
├── database_sql.py
├── dump.sql
├── example.db
├── example.db.sql
├── example_info.txt
├── example_old.db
├── example_old.db.sql
├── sample
│   ├── chinook.db
│   └── sqlite-sample-database-diagram-color.pdf
├── test.db
└── test.sql

3 directories, 15 files

Execute a command in the background

There are also instances in which is it useful to execute a program from the terminal inside a Python script. This website, for example, currently exports daily Git statistics in the output/ folder. This looks like this:

 python
 
 
 
def daily_stats():
 '''Execute `Gitstats` once a day based on the date found in
 `stats_counter.txt`. Very simple with a caveat: it won't check if
 there are new commits on the same day if stats have already been
 generated on that day.'''
 today = datetime.today().strftime('%Y%m%d')
 with open('stats_counter.txt') as f:
 content = f.readline().strip()
 if content != today:
 current_loc = current_path()
 cmd = ["gitstats", "-c", "project_name='sglavoie.com'",
 f"{current_loc}", f"{current_loc}/output/stats/"]
 subprocess.run(cmd)
 with open('stats_counter.txt', 'w') as f:
 f.write(today)

This is an automated process, which is something Python is easy to use for. However, it won’t be necessary to program everything: it all gets generated on demand!

Conclusion

I am always amazed at how easy it can be to automate simple tasks like those mentioned above. Programming can be very rewarding regardless of initial abilities. Just beyond the most basic stuff, suddenly there is a world that opens up to those that stay curious long enough.

Using Embedded Terminals Inside Neovim

Sébastien Lavoie — Wed, 16 Jan 2019 17:32:00 -0600

Terminals & Neovim

Terminal buffers are a built-in feature of Neovim. This means that terminals can be launched inside Neovim just like any other buffer, may it be a split window, a new tab or an independent buffer. Why is this so useful? Be prepared to be amazed.

(click to open)

Seamless integration with Vim commands

For a start, terminals are not just opened inside Neovim: they are truly integrated. When you type the letter i in a terminal buffer, it switches to a new mode, Terminal, where you have access to all underlying features of a regular Bash terminal, such as CTRL + r to search, tab completion of commands, CTRL + w to delete a word backwards or CTRL + u to delete the whole line backwards.

When you escape the Terminal mode, you switch back to Normal mode, where all Vim commands are available as usual, such as navigation, search, etc. Where this gets interesting is when you consider that the terminal is just like any other buffer (except it’s not modifiable) and so you can for instance copy its content or paste into it from different registers. You can split them, view the line number, get automatic scrolling when output appears in Insert mode, you can switch back to Normal mode at any time even if a command hasn’t completed… and of course all commands like gt to go to another tab work as always.

Terminals get supercharged with the power of Vim

This is getting exciting (at least for me). Now, having a terminal with more power is useful in many cases:

A whole terminal session can be saved to another file easily by copying the desired range (:%y to copy everything, for example).
Instead of having to scroll with the mouse, all Vim commands are available to search and navigate through the buffer: gg to go to the beginning of the session, G to go to the end, 12G to go to line number 12, / or ? to search forward and backward respectively. You can even set local or global marks to jump back and forth to precise lines consistently!
It’s even possible to send commands directly to a specific terminal or set up a REPL to execute any code, either a selection, a line or a range of lines. I don’t personally use that feature yet, but I see how useful that can be and you can too if you watch this [screencast presented by Drew Neil](https://thoughtbot.com/upcase/videos/neovim-sending-commands-to-a- terminal-buffer) on thoughtbot.com.
If the terminal is opened in Normal mode, the cursor and the current position are kept intact even though new output could appear, such as would be the case if you are running a server in the background or waiting for a system update to finish. This is especially nice for instance if you are trying to debug a web application: you can leave the cursor exactly where you would like to keep reading the output and never get lost… Plus you have the ability to easily move around, search and copy like a ninja!

The workflow is more compact and centralized

Because the terminals are running with one Neovim instance, you get everything in the same place, which is usually how you need to access your work anyway. If for some reasons you need to have multiple instances of Neovim running, this is possible too and in that situation you could simply split them into different workspaces.

Because everything is launched with Neovim, every terminal left open will also be exited when you close Neovim, shutting down any server or quitting any background interaction going on in the terminals. I have found that this behaviour is what I expect pretty much all the time because the idea of having a terminal inside a working session of Neovim is to work on something related, so it makes sense to close everything that’s to do with a single project or task when you exit the text editor. No need for CTRL + d or exit anymore!

Terminal settings to consider

I don’t use many settings or mappings related to terminals, but I guess the nicest one is to remap the Escape key because by default, this is a weird mapping that leads to twisted fingers (<C-\><C-n>). Here is what I currently have in my init.vim file (the equivalent of .vimrc for Neovim):

 vim
 
 
 
set termguicolors " Make colors look better in terminal

" Exit from terminal buffer (Neovim) more easily (remaps Esc key in
" terminal)
tnoremap <C-[> <C-\><C-n>

" Open terminal buffer (M stands for the Alt key)
nnoremap <M-t> :te<CR>

" Switch to terminal buffer automatically (when only one terminal is
" open)
nnoremap <M-0> :b term://<CR>

" Move between windows exactly the same way as usual
tnoremap <C-j><C-k> <C-\><C-N>
tnoremap <C-h> <C-\><C-N><C-w>h
tnoremap <C-j> <C-\><C-N><C-w>j
tnoremap <C-k> <C-\><C-N><C-w>k
tnoremap <C-l> <C-\><C-N><C-w>l

Conclusion

This was a quick overview of a feature that I have neglected for some time but recently realized how well it integrates with my workflow. You can find some more information by typing :h terminal. If you already use Neovim, it’s worth giving it a try! Otherwise, it’s worth giving Neovim a try.

Aliases: Also Known as Terminal User's Best Friends

Sébastien Lavoie — Sat, 08 Dec 2018 13:52:00 -0600

Some aliases that I find useful

In all the following examples, the dollar sign $ at the beginning of commands represents the prompt, it should not be typed.

General-purpose

List all aliases

bash

$ alias

Prints all of your aliases. If you have plenty of those, you might prefer to pipe this command with less to get a nice pager that allows you to easily nagivate them:

 bash
 
$ alias | less

Setting an alias in `~/.bash_aliases`

 bash
 
alias c='clear'

This would set c as a shortcut to clear. In order to use the newly created alias, you would have to close the terminal or type the following command in the terminal:

bash

$ source ~/.bash_aliases

Clear the screen

 bash
 
alias c='clear'

I like being absorbed into the emptiness of the terminal, so this one comes in handy to tidy up the work space.

Reset the terminal

 bash
 
alias re='tput reset'

If for some reasons the terminal displays badly or display funky characters, it can usually be reset this way.

Exit from the terminal

 bash
 
alias q='exit'

For exiting the terminal as if you were still in Vim!

Display all file extensions recursively from the current directory

 bash
 
alias allextensions="find . -type f -name '*.*' | sed 's|.*\.||' | sort -u"

It comes in handy to spot if a file shouldn’t be there or to check for lower or uppercase extensions.

Find text inside files, including filenames

 bash
 
alias findinfiles='ag --nobreak --nonumbers --noheading . | fzf'

In this example, the alias is set up with ag, a fast code-searching tool and fzf, a great fuzzy finder.

Reboot and shutdown the system

 bash
 
alias reboot='systemctl reboot'
alias shutdown='systemctl poweroff'

This will reboot or power off the system without needing root privileges in most working conditions.

List and sort files and directories by modification time

 bash
 
alias treeold='tree -hDF | less'

This requires the command tree to be installed. The parameters are (descriptions taken from man tree):

-h: Print the size of files in a human readable way.

-D: Print the date of the last modification time.

-F: Append a ‘/’ for directories, a ‘=’ for socket files, a ‘\*’ for executable files, a ‘>’ for doors (Solaris) and a ‘|’ for FIFO’s, as per ls -F.

Open files quickly with default applications

 bash
 
alias o='xdg-open'

This will open files and URLs specified as argument in the default application detected.

Moving around

If you are going to be working on projects for some time and require to cd into them, I have found the following to be useful:

 bash
 
 
 
$ cdnameOfProject # instead of having to do cd /path/to/project/
$ # More examples:
$ cdcodeabbey # For codeabbey.com
$ cdhackerrank # For hackerrank.com
$ cdeuler # For projecteuler.net
$ cdgit # For all Github repositories

This is not advanced by any means, but it helps quite regularly! Since you can take advantage of tab completion, you can type cd (without adding a space) and then press TAB key to autocomplete the aliases.

 bash
 
alias ...='cd ../..'

Make it easier to navigate into deep directory structures by basically doing cd .. && cd .. to go back up two directories at once.

Listing files

 bash
 
 
 
alias l='ls -CFh'
alias la='ls -Ah'
alias ll='ls -ahlF'
alias ls='ls --color=auto'

Different ways to set up the command ls to quickly see the needed files. The parameters are (descriptions taken from man ls):

-A: Do not list implied . and ...

-C: List entries by columns.

-F: Append indicator (one of \*/=>@|) to entries.

-a: Do not ignore entries starting with .

-h: With -l and/or -s, print human readable sizes (e.g., 1K 234M 2G).

-l: Use a long listing format.

 bash
 
alias aNameOfProject='source /path/to/project/bin/activate'
alias aa='source ~/Programming/anaconda3/bin/activate' # Example using Anaconda distribution

The purpose is to activate a specific virtual environment quickly. The command cd could be added to go to the related project also:

 bash
 
alias gNameOfProject='cd /path/to/project/ && ./.venv/bin/activate'

Where .venv would be the name of the virtual environment.

I like to activate environments starting aliases with a and go and activate at the same time starting aliases with g. This way, it feels like I am speaking the Vim language (cw for change word, for example).

 bash
 
alias da='deactivate'

This will deactivate a virtual environment.

 bash
 
alias p36='python3.6'
alias p='python3.7' # Simply using `p` for main version of Python

Practical way to quickly open the desired Python version.

 bash
 
alias pyclean='find . -regex ".*\(__pycache__\|\.py[co]\)" -delete'

This will delete recursively all files and directories that match one of the following patterns in their name: __pycache__, .pyc or .pyo.

Conclusion

I hope you will find at least one alias to improve your productivity. Of course, you are welcome to chime in with your own suggestions!

sglavoie.com – Category: Tips & Tricks

Git worktrees for a better parallel workflow

Introduction

Why is git stash not enough?

Switching context

Running tasks in the background

How I operate worktrees

First, other approaches in the wild

What I actually do these days

Starting with a project with existing branches

New worktrees from a project already using worktrees

Keeping worktrees around

Conclusion

Resources and references

External links

From this website

Ignoring Sync of Local Files to Dropbox on Linux

Introduction

Why Dropbox?

So, what’s wrong with Dropbox?

Any simple example?

Ignore all .git and node_modules folders

Can we make this simpler?

How do you use those functions?

Conclusion

Using dmenu to Optimize Common Tasks

Introduction

Any Simple Example?

How do You Install It?

Debian-based (such as Ubuntu)

Arch-based (such as Manjaro)

Useful Real-World Examples

Cheat sheets

University shortcuts

File manager shortcuts

Setting Up a Custom Command

Configuration for i3 (bind a keyboard shortcut)

Configuration for cheatsheets.conf

Pipe 1

Pipe 2

Pipe 3

Running a Custom Script

Chaining dmenu prompts

Customize the Look of dmenu

Conclusion

Tag Navigation in Vim

Navigate inside the current buffer

Navigate inside all buffers within the current project

Debian/Ubuntu

OS X

Dispose of Spam with Disposable Emails And More!

Introduction

Why should I care?

Solution #1: Use a temporary email

Solution #2: Use a more controlled approach

Does it really work?

How does it work?

Why consider this approach instead of solution #1?

Solution #3: Using filters

Solution #4: Use the + symbol in your email

Solution #5: Forward secondary emails to your main email

Conclusion

Executing Shell Commands in a Python Script

Introduction

Retrieve the output

Execute a command in the background

Conclusion

Using Embedded Terminals Inside Neovim

Terminals & Neovim

Seamless integration with Vim commands

Terminals get supercharged with the power of Vim

The workflow is more compact and centralized

Terminal settings to consider

Conclusion

Aliases: Also Known as Terminal User's Best Friends

Some aliases that I find useful

General-purpose

List all aliases

Setting an alias in ~/.bash_aliases

Clear the screen

Why is `git stash` not enough?

Solution #4: Use the `+` symbol in your email

Setting an alias in `~/.bash_aliases`