sglavoie.com – Tag: Linux

Tip the Scales in Times of Instability With the Rock-Solid Debian

Sébastien Lavoie — Sun, 05 Apr 2020 12:14:00 -0500

Introduction

I’m familiar with Linux distribution hopping, having tried out many options over the years, starting around the time Mandrake 9.2 was popular back in 2003, then switching to a few others including Ubuntu, KNOPPIX, Fedora, Xubuntu, openSUSE, Kubuntu, Mint, Manjaro, Mandriva… And of course Debian along the way, which undoubtedly used to be relatively harder to get started with.

My heart has also been stirred by different desktop environments and window managers, from more user-friendly/feature-rich solutions such as KDE, GNOME (along with Unity when it was still a thing), Xfce and Cinnamon to an arguably more obscure selection comprising Openbox, Fluxbox, Enlightenment, Awesome WM, dwm, i3 and bspwm.

I haven’t tried everything that’s out there (XMonad being one such esoteric possibility), but I’ve come to realize that what matters most to me is a great balance of stability and usability, allowing to be more focused on any given task at end and therefore leading to increased productivity. For this reason, I recently turned back to a fantastic combo: Debian with an Xfce base and the i3 tiling window manager.

Why Debian?

Stability and Reliability

Debian has always been to me the father figure of stability in the Linux world. Countless servers have run on Debian and continue to do so for good reason: it just works once it is properly set up. I have had some bad luck with other Debian-based distributions like Ubuntu and Linux Mint which strive to be easier to use but remain easier to break, being a bit more bleeding edge and sometimes bloated too with tons of software I don’t really need. Fedora, although I like its philosophy and style very much, has always lead to hardware issues on my apparently less-than-ideal machines. Manjaro has been pleasant and easy to use, but Arch feels like the right choice if one is to build a custom system from scratch. It does take a good amount of time to get things going on such a distribution and usually a good dose of maintenance too, which brought me to seek less time-consuming options. For stability and reliability, Debian is hard to beat in my experience.

Marvelous Package Manager

I have always found the package manager on Debian (and derivatives) to be easier to use than alternatives like yum, DNF or urpmi for RPM packages. The pacman package manager available on Arch-based systems is truly excellent and powerful, but I simply find apt to be more intuitive after using it for a lot longer.

It Just Won’t Break

Sitting on the bleeding edge is fun and sometimes even rewarding when things finally work as expected, but I have seen that it doesn’t stay that way forever. Big updates, sometimes relatively frequent ones, can leave the system in an unusable state. It’s often a minor annoyance to fix, but that just doesn’t happen on Debian, where packages are vetted mainly for their legendary stability before releasing them. They are indeed quite a bit older than what can be found on other distributions. It’s the price to pay, but I came to the conclusion that it’s worth it if you’re looking to get things done in the long run.

Debian Xfce in its glorious simplicity.

Xfce Is Minimalist Enough and Hassle-Free

It’s also about the combination of Debian + Xfce: while Debian makes sure the system remains functional as a whole, Xfce is the solution for interacting with applications and windows without glitches in a “floating mode” where all windows can be grabbed and moved around easily. Debian itself keeps old packages around by choice and Xfce has a very slow release cycle yet also provides stability out of the box. This means that installing Xfce on Debian has to work because bugs have been evened out over years of effort from both teams. This is an easy yet very satisfying solution.

Xfce vs KDE

One of the main appeals of desktop environments like KDE and GNOME is that they have more features and add them more often. They do use more resources and even though they have gone through substantial optimizations over the years, they still feel less snappy on older systems compared to simpler window managers or even Xfce. Recently, KDE caught up with Xfce in terms of resources utilization, but there’s one major reason I just can’t rely on it on a production machine: in every single release I have tried (from KDE 2.x in the early 2000s to Plasma 5.x), I was confronted with numerous bugs within minutes of delving into it. I have always been faced with some minor troubles on GNOME too (versions 2 and 3), but it’s never been as severe as with KDE. KDE has plenty of cool ideas and is fully customizable, but that’s to a fault in my view.

Xfce vs GNOME

On the other hand, GNOME does consume at least twice as much RAM and CPU compared with Xfce even with no extensions enabled on GNOME and a couple of plugins activated on Xfce. I enjoy how GNOME deals with virtual desktops and think this can be a great productivity enhancement, but once I’ve configured Xfce to be mainly keyboard-driven, I prefer keeping it simpler with less transition effects and other nice visual additions. On the graphical side of things, GNOME with Wayland has never worked as well for me as with Xorg, so that’s something else to watch for.

Xfce vs i3

Well, i3 is a different beast in its own right and has taken a special place in my heart. It uses less memory and CPU than any desktop environment out there and can be used with minimalistic software, like the st terminal and the dynamic menu dmenu (read the article about suckless tools if that resonates with your style!). There are still a few things that I didn’t like very much about it, such as the way windows are managed in fullscreen mode, the default lack of a convenient master/slave tiling layout (similar to dwm and bspwm) and the way one interacts with external monitor(s), where workspaces use the same numbering across multiple screens. But i3 with Debian feels more mature and is (again) a bit older than what you might find elsewhere. There is a comprehensive section in the i3 User’s Guide that explains how to work around some issues.

I find that maximizing windows works like what you would expect in Xfce, covering everything but the menu bar. There’s also the fact that Xfce makes it very convenient to add and remove virtual desktops on the fly instead of having a bunch of those at all time. With minimal Bash scripting, windows in Xfce can be moved around from one monitor to the other, replicating a useful feature available in i3. Xfce, having only floating windows, behaves better with applications like VirtualBox and GIMP by default. And there’s also some common ground with the “pseudo tiling” available in Xfce which makes i3 much less unique, although i3 makes it a lot easier to maximize the screen estate being used.

Debian i3 using up to the last available pixel.

In the department of customization, i3 is very good, but having to edit a configuration file manually each time a little change is desired can become tiresome. Xfce has a wonderful settings manager which makes it easy to adjust many system settings as well as those related only to the window manager. i3 requires initially quite a bit more effort to work and will incur a few additional dependencies if one wants to make it look better. Xfce strikes a very good balance: it’s highly customizable; pretty much bug-free in my experience and is usable right away without any surprise. Once both are fully configured to match one’s need, I tend to rely on i3 to be more productive and keep Xfce as a functional backup if someone else is going to try to use the mouse on my system to accomplish any kind of useful action with the windows ;).

I find that installing Debian with an Xfce base leads to having enough useful software pre-installed compared to a barebone installation and installing i3 afterwards only makes the transition easier.

Xfce vs Other Window Managers

Now, there is an endless stream of other options to explore and I don’t know enough about many of those to dare to comment. But from those I tried, I can certainly say that I preferred the ease of use of Xfce over other more minimalistic approaches like Openbox, Enlightenment and Fluxbox. Xfce offers all you need out of the box, but not much more, which is what I’m looking for at this moment. On the other hand, making dwm work in one precise way can be tricky and requires many tweaks before the configuration can remain untouched for a while. I do not like the necessity of recompiling the source code every single time a tiny change is made which led me to discard it as a convenient option in the long run. I like making small visual adjustments to my system from time to time and I want this to be as frictionless as possible.

Otherwise, dwm and bspwm might be some very decent options if one is inclined to be tweaking everything from scratch (it’s not really a facultative step anyways!), but Xfce integrates everything one might need under very few different packages and has been extremely reliable for me from the beginning. On any kind of modern machine, the extra system resources used up by Xfce compared to those lighter alternatives really don’t mean much in the end because it is compensated with the presence of useful applets and tools which definitely make one’s life easier.

It’s Ideal for Developers

Resources Efficiency & Effectiveness

Debian with a light working environment is resource-efficient and comes with much less software out of the box compared to the KDE or GNOME editions: instead, more resources are available for hungry applications like heavy IDEs. Installing applications specific to those desktop environments work flawlessly too. Not only does Debian consume less resources (especially while running Xfce/i3 on top), it does so extremely well and offers great performance.

Debian Xfce mostly at rest.

Rock-Solid Stability (Again, Big Selling Point!)

Since it’s so stable, any release of Debian is currently supported for at least 3 years and up to 5 years for LTS (Long Term Support) releases, which means one doesn’t have to worry about constantly upgrading the system. For a start, upgrading packages on the stable branch of Debian very rarely leads to a broken system, unlike on more bleeding edge distros like Fedora or Manjaro where downloading a few months old release almost guarantees some unexpected challenges.

Packages Availability

With currently close to 58,000 packages offered on Debian, there’s a very good chance that anything one might need will be available. Working with up-to-date, proprietary applications like Google Chrome, Zoom or Slack is also pain-free: most companies, when they do consider Linux, opt for sharing a classic deb package, the format used on Debian and Debian-based systems. Some of those packages can also be found or added directly to the sources managed by the package manager, allowing for easy, automatic updates.

Synaptic, the legendary package manager.

Large Community with Freedom in Mind

Because no company backs Debian directly, it relies on a community effort to keep going and it has done so for a long time, having now hundreds of distributions being based on it. This means that it’s easy to find a ton of documentation and tutorials giving solutions taking into account Debian-based systems. One will be able to fix any issue cropping up thanks to the Debian User Forums and of course thanks to the immense popularity of Ubuntu, which contributes tremendously to making answers available in its forums and in the Stack Exchange network.

Resources to Get Started

Debian Documentation
Debian User Forums
Debian Wiki
Developer-oriented: resources for contributing to Debian
Cloud-oriented: tutorials for Debian on Digital Ocean
i3 tiling window manager
Xfce Desktop Environment

Conclusion

After trying many different Linux distributions and desktop environments, I keep coming back to what satisfies me best in the end: stability and usability. Debian feels a bit old, but at the same time one knows it delivers on what it promises. The same can be said for Xfce and i3. This is also what makes them such a good combo: despite not being cutting edge in the realm of features, there’s no way it could break as easily as KDE or GNOME, particularly on less stable distributions. There are still a few rough edges when it comes to customizing both Xfce and i3 in my opinion, but when looking for something that just works and will keep doing so, Debian is hard to beat.

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!

Using i3 as a Window Manager for Increased Productivity

Sébastien Lavoie — Tue, 08 Jan 2019 11:12:00 -0600

What is i3?

i3 is a tiling window manager. To get to know i3 better, it’s good to situate what desktop environments are in the first place.

What are desktop environments?

If you are familiar with Linux, you certainly know about desktop environments such as GNOME, KDE, Xfce… and actually many more are available (you can see this article on Wikipedia for an extended selection)! The classic Graphical User Interface (GUI) on Windows XP was known as Luna and is now called Modern on Windows 10. Aqua is the name of the GUI on macOS. Well, every desktop environment comes with a window manager, the main component that makes interactions with windows possible, like moving, resizing, minimizing or closing them.

Desktop environments are very useful in many ways:

They are usually very easy to set up as they come fully functional out of the box. Like opening a user session on macOS or Windows.
They are sometimes quite customizable, but you don’t have to change anything to get them to work, as they normally set default applications to open with certain file types.
They automatically integrate services such as WiFi network detection, automatic mounting of drives when you plug them in, etc.
You can enable virtual desktops to split your work across different spaces. This concept can grow to [Activities](https://docs.kde.org/trunk5/en/kde-workspace/plasma-deskto p/activities-interface.html), which is a feature implemented in KDE that allows you to use virtual spaces literally for different activities by having settings that are specific to each activity (like launching one application or keeping widgets in determined positions), plus the ability to use multiple virtual desktops inside each activity.
They integrate with applications that are specifically designed to take advantage of the desktop environment in question by adapting colors and themes perfectly to match the general look of the system and arranging settings in a common location for all applications.

Why use a window manager like i3?

Even though desktop environments are user-friendly and include many goodies, they do have several disadvantages that make window managers great alternatives.

Less bloated

Desktop environments are often bloated with many applications that you may not need but that are nevertheless occupying system resources as they have many dependencies. For example, if you use Thunderbird for managing your emails and your desktop environment is GNOME, try to remove Evolution, the default application for emails that comes with it… It’s still relatively easy to disable its processes, but you sometimes have to configure files manually to satisfy your need for removing clutter.

Lower memory and CPU consumption

Other than coming with a set of default applications (more disk space), the whole environment occupies a lot more memory to run smoothly. On my modest laptop, I was still experiencing speed issues because the system was occupying too much RAM when opening heavy applications (lots of tabs when web browsing, photo editing, loading IDEs like PyCharm for programming, etc.) and I had 4 GB of RAM installed at the time. KDE requires at least 600 MB, same is true for GNOME in most recent versions (but used to be over 1 GB not very long ago, just like for KDE). Windows, for example, requires more than 1.5 GB of RAM to operate with basic features. i3 needs less than ~15 MB with as many windows and spaces open as you would ever want. Since there are much less processes to take care of, CPU consumption is also lower, which is more noticeable on older machines.

Keyboard efficiency

There are obviously ways to go about using keyboard shortcuts for pretty much anything you want with desktop environments. However, window managers and especially i3 make this a must, as there is really no reason to use a mouse for moving windows.

First of all, windows are “stuck” in place and never overlap by default. You can’t move them around with a mouse unless they are “floating” windows, which means you can separate them to move them around freely like in most desktop environments. The whole point of using a window manager like i3 is to maximize screen space, so every window opens in full screen. Honestly, the only time I ever found the need to use a floating window with i3 is when using the operating system Windows in a virtual environment when connecting through RDP with Google Chrome on Google Cloud Platform (that is, not very often). Other than that, I find it very practical to split the screen with no overlapping windows, even with my small 15 inches screen.

Because windows are managed the way they are in i3, getting split when multiple windows are in the same workspace and never overlapping, it nurtures the good habit of dividing workspaces appropriately to maximize the space that each application occupies, which is done with keyboard shortcuts. With (customizable) shortcuts, you can split windows, move them to other workspaces, change workspaces, open applications automatically in specific workspaces, etc. Using exclusively the keyboard to manage the windows becomes a huge time saver, and even more so when considering the very small footprint required to use the window manager, making for a lightning fast experience.

Extremely fast customization

Once you get past the initial lack of visual appeal and weird way to move around, you can actually customize many aspects of i3, including fonts, mouse bindings, window border decorations, colors, automatic execution of apps when initiating a session, etc.

Why is it so fast to customize? Because the configuration is all contained in one simple text file and you can make a change and reload the window manager on the fly to see your changes being reflected. Setting the number of workspaces is as easy as adding or removing a line (well, as a bare minimum, otherwise it’s useful to also bind certain keyboard shortcuts to move to those newly created workspaces). Setting a wallpaper is one line, setting a screen lock is another one. Quick and efficient.

Easy to switch layouts and focus

I actually enjoy the default layout quite a lot, in which there exists no overlap between windows (they split as needed) and all windows are visible at the same time in each workspace. If you need to make more space for a window, you can either “focus” on the current window, which will make it full screen and cover every pixel of the screen, or you can move particular windows to other workspaces. This last option will automatically resize windows so that they occupy the maximum space available.

Besides the default layout, you can also stack and tab windows, depending on how you like to work (it is well worth having a look at the i3 user’s guide to see the many other features available). Personally, I prefer seeing everything at once and dividing my work into many workspaces. If you are curious, here is how I currently have my workspaces set up:

Programming — Exclusively for programming purposes.
Terminals — For working in the terminal, opening another instance of a terminal text editor, etc.
Web — Just for Internet. Always full screen unless I open some website that requires to open new windows (like banking), which conveniently split the windows. The web browser automatically launches in the background when opening a session in i3.
Multimedia — Editing photos or watching videos.
Music — ncmpcpp (terminal music player) automatically launches in the background when opening a session.
Experiments — I use this workspace when trying to understand some programming concepts with an interactive IPython console or for breaking the system in one way or another because I don’t know what I’m doing.
Fix — After realizing that sometimes experiments need to be cleaned up a bit, I now use this workspace exclusively to run tools in the background, such as BleachBit for cleaning files or glances (similar to the top command) for watching how the system is doing.
Words — I use that workspace for reading e-books or for writing, either in Neovim or LibreOffice depending on the task.
Tools — This workspace is reserved for anything that I might want to have access to once in a while, like a calendar or KeepassXC for accessing a password database.
sg — I mainly use that workspace to update this very website, but I also use it for setting up local web servers for making personal projects in Flask and Django or even just a temporary server with python -m http.server to share files with other devices on the local network.

Only workspaces that contain windows will appear on the screen at any given time and are automatically created when you access and use them.

What does it look like in action?

Here is a screenshot* of the workspace where this article is being written (click to open):

* _{In this particular scenario, the splits on the right side are
intentionally very small as I do not need to read the output, but need
quick access to a terminal to enter commands. Moving back and forth
between windows is a breeze, so that’s how I currently handle the
situation.}

Note: With Neovim, there is an embedded terminal, which makes things very easy to handle by avoiding splits altogether. In that case, it is also possible to divide a workflow with tabs inside Neovim instead of physically splitting windows.

Alternatively, instead of splitting windows, a more convenient solution on smaller screens might be to use stacking windows with the shortcut $mod + s in each workspace or, to provide that behavior by default, the following can be added to i3’s configuration file (defaults in ~/.config/i3/config):

 bash
 
# Set default container layout
workspace_layout stacking

Conclusion

I am not trying to convince myself anymore: I really prefer this workflow! If you are looking for a change and would like to maximize both your productivity and your system resources, i3 is a great window manager to consider. It doesn’t seem very intuitive at first, but I swear it quickly becomes easy to use and you also end up learning more about how Linux works and set things up manually (just once!) to your likings. For example, I use Rofi instead of dmenu to have a window pop-up to select applications or switch to any window on any workspace… which was only one line to modify in the configuration file.

I have found the following screencasts on YouTube to be quite useful in learning how to configure i3 (apart from the official documentation which is very comprehensive):

Bash History Cleaner

Sébastien Lavoie — Sun, 23 Dec 2018 19:35:00 -0600

Introduction

This is a Python 3.6+ script that helps to clean the file containing the Bash history commands. It will remove any line matching a specified regular expression and can also remove any line starting with an alias.

The idea behind this small utility was simple:

The Bash history file (usually located in ~/.bash_history) contains much of the work one ends up doing in the terminal.
The history can grow large over time and it becomes more cumbersome to find interesting information in all that clutter, such as a rarely used command with specific flags.
By removing all superfluous commands that are repeated often and which give no real benefit in certain contexts (such as ls, cd, cat, etc.), the history is much cleaner and easier to navigate and actually becomes much more useful in my opinion.
True, it will be harder to follow the bread crumbs for everything you did, but I haven’t come across a situation where having access to yet another empty ls or cd has proven necessary and reading .bash_history doesn’t make for a great narrative story either.

Make history in a big way

I took advantage of the fact that the history can be cleaned with the script you are about to see and set up what is known as an eternal history which, as it sounds like, can grow infinitely big! All you have to do is append the following lines to the file ~/.bashrc:

 bash
 
 
 
# Eternal bash history.
# ---------------------
# Undocumented feature which sets the size to "unlimited".
# http://stackoverflow.com/questions/9457233/unlimited-bash-history
export HISTFILESIZE=-1
export HISTSIZE=-1
export HISTTIMEFORMAT="[%F %T] "
# Change the file location because certain bash sessions truncate
# .bash_history file upon close.
# http://superuser.com/questions/575479/bash-history-truncated-to-500-lines-on-each-login
export HISTFILE=~/.bash_eternal_history
# Force prompt to write history after every command.
# http://superuser.com/questions/20900/bash-history-loss
PROMPT_COMMAND="history -a; $PROMPT_COMMAND"

Bash History Cleaner

And here is the script in question *. It comes in two files that need to be in the same directory:

One is a Python file that needs to be launched from the terminal with Python 3.
The other file, settings.json, is a JSON file used to store the settings of the script, which will be detailed below.

* _{Improvements to the original script can be found on Github. To keep this
article a bit more readable, the original version is shown.}

`bash_history_cleaner.py`

 python
 
 
 
'''
Python script that helps to clean the file containing the Bash history
commands.

Note: Requires Python 3.6+

It will remove any line matching a specified regular expression and can
also remove any line starting with an alias.

Description of available settings in `settings.json`:

 "home_directory": Absolute path to user's home directory.

 "history_file": Name of file where the history will be cleaned up.

 "aliases_file": Name of file where Bash aliases are set up.

 "ignore_patterns": List of patterns to ignore in `history_file`.
 Each line where a pattern is found will be deleted.
 → Patterns are specified as regular expressions.

 "add_aliases": Boolean. If set to `true`, aliases from `aliases_file`
 will be added to `ignore_patterns`.

 "aliases_match_greedily":
 Boolean. If set to `true`, any line in `history_file`
 starting with an alias in `aliases_file` will be
 deleted. If set to `false`, delete line if the alias is
 the content of the whole line (with optional space at
 the end): `false` matches "^alias$" or "^alias $" only.

 "backup_history": Boolean. If set to `true`, `history_file` will be backed
 up in the same directory with a name ending in .bak
 based on the current date.

 "delete_logs_without_confirming":
 Boolean. If set to `true`, script with flag `-c` will
 automatically delete all the backup files found for
 `history_file`.
'''
from datetime import datetime
from pathlib import Path
import argparse
import fileinput
import glob
import json
import os
import re


def get_current_path():
 '''Returns the current working directory relative to where this script
 is being executed.'''
 return Path(__file__).parents[0]


def user_says_yes(message=""):
 '''Check if user input is either 'y' or 'n'. Returns a boolean.'''

 while True:
 choice = input(message).lower()
 if choice == 'y':
 choice = True
 break
 elif choice == 'n':
 choice = False
 break
 else:
 print("Please enter either 'y' or 'n'.")

 return choice


def delete_logs(settings: dict, history_file: str):
 '''Delete log files in `home_directory` based on `history_file`.'''

 # Retrieve a list of all matching log files
 log_files = glob.glob(f'{history_file}_*.bak')

 if log_files == []:
 print("There is no log file to delete.")
 else:
 print(f'Log files found in {settings["home_directory"]}:')

 for log_file in log_files:
 print(log_file)

 if settings['delete_logs_without_confirming']:
 for log_file in log_files:
 os.remove(log_file)
 print('Log files deleted.')
 return

 message = ("\nDo you want to delete those log files? [y/n] ")

 if user_says_yes(message=message):
 for log_file in log_files:
 os.remove(log_file)
 print('Log files deleted.')
 return

 print('Operation aborted.')
 return


def generate_date_string() -> str:
 '''Return date formatted string to backup a file.'''
 return datetime.strftime(datetime.today(), '_%Y%m%d_%H%M%S.bak')


def load_settings(settings_file: str) -> dict:
 '''Load settings in the script. Return them as a dictionary.'''
 with open(settings_file, "r") as read_file:
 settings = json.load(read_file)
 return settings


def get_list_aliases(bash_aliases_file: str, settings: dict) -> list:
 '''Retrieve the name of all the aliases specified in `bash_aliases_file`.

 Return aliases as a list of strings formatted as regular expressions.'''

 match_whole_line = bool(settings['aliases_match_greedily'])

 with open(bash_aliases_file) as file:
 content = file.read().splitlines() # one alias per line
 aliases_list = []
 for line in content:
 try:
 # Get the actual alias in each line
 # Use negative lookbehind to remove 'alias ' at the beginning.
 # Matches anything after that is a dot, digit, underscore
 # or letter (will stop at the equal sign: alias blah='...')
 alias = re.search(r'(?<!not )alias ([\.\w]*)', line).group(1)

 # If for some reason the alias cannot be extracted, skip it
 # If search doesn't match, it's of type None and won't work
 except AttributeError:
 continue

 if match_whole_line:
 # Match the whole line if it starts with the alias.
 alias = f'^{alias}( )?$|^{alias} .*'
 else:
 # Will match only when alias is the whole content of the line,
 # followed by optional space.
 alias = f'^{alias}( )?$'

 # Escape dots in alias
 alias = alias.translate(str.maketrans({".": r"\."}))

 aliases_list.append(alias)

 return aliases_list


def clean_bash_history(settings: dict, history_file: str):
 '''Modify in place `history_file` by removing every line where
 `ignore_patterns` is found.

 Optionally, add a list of aliases to `ignore_patterns` with
 `aliases` based on the value of `add_aliases` in settings.json.'''

 if settings['backup_history']:
 backup_str = generate_date_string()
 file_input = fileinput.FileInput(history_file,
 inplace=True,
 backup=backup_str)
 else:
 file_input = fileinput.FileInput(history_file,
 inplace=True)

 with file_input as file:
 for line in file:
 has_match = False
 for pattern in settings['ignore_patterns']:
 matched = re.compile(pattern).search
 if matched(line):
 has_match = True
 break
 # If no match is found (nothing to ignore), print the line
 # back into the file. Otherwise, it will be empty.
 if not has_match:
 print(line, end='') # Line already has carriage return


def launch_cleanup(settings: dict, history_file: str, aliases_file: str):
 '''Main function that launches the cleanup process.'''

 bash_aliases = None
 if settings['add_aliases']:
 try:
 bash_aliases = get_list_aliases(aliases_file, settings)

 # add aliases to list of patterns to ignore
 settings['ignore_patterns'].extend(bash_aliases)
 except FileNotFoundError:
 print(f"File not found: {aliases_file}")
 quit()
 try:
 clean_bash_history(settings, history_file)
 except FileNotFoundError:
 print(f"File not found: {history_file}")


if __name__ == '__main__':
 SETTINGS_FILE_PATH = get_current_path() / 'settings.json'
 SETTINGS = load_settings(SETTINGS_FILE_PATH)
 ALIASES_FILE = SETTINGS['home_directory'] + '/' + SETTINGS['aliases_file']
 HISTORY_FILE = SETTINGS['home_directory'] + '/' + SETTINGS['history_file']

 # initiate the parser to check all the arguments passed to the script
 PARSER = argparse.ArgumentParser()
 PARSER.add_argument(
 '-c', '--clear', help='Delete all log files', action='store_true')

 # read arguments from the command line
 ARGUMENTS = PARSER.parse_args()

 if ARGUMENTS.clear:
 delete_logs(SETTINGS, HISTORY_FILE)
 quit()

 launch_cleanup(SETTINGS, HISTORY_FILE, ALIASES_FILE)

`settings.json`

 json
 
 
 
{
 "home_directory": "/home/sglavoie",
 "history_file": ".bash_eternal_history",
 "add_aliases": true,
 "aliases_file": ".bash_aliases",
 "aliases_match_greedily": true,
 "backup_history": true,
 "delete_logs_without_confirming": false,
 "ignore_patterns": [
 "^\\#\\d+",
 "^$",
 "^(\\.\\/)?pip$",
 "^(\\.\\/)?python.*$",
 "^\\.\\.$",
 "^alias",
 "^cd ",
 "^cd$",
 "^cd..$",
 "^fg$",
 "^df( )?",
 "^du( )?",
 "^exit$",
 "^git branch",
 "^git checkout master",
 "^git log$",
 "^git push$",
 "^git status$",
 "^git stauts$",
 "^kill \\d+.*",
 "^ls -a$",
 "^ls$",
 "^make|make install$",
 "^man ",
 "^pelican( )?$",
 "^pip install -r requirements.txt",
 "^pip.* list|pip.* show$",
 "^source ",
 "^sudo apt-get autoclean|sudo apt-get autoremove$",
 "^sudo apt-get dist-upgrade|sudo apt-get update$",
 "^which "
 ]
}

Description of available settings in `settings.json`

Name of setting	Description
`home_directory`	Absolute path to user’s home directory.
`history_file`	Name of file where the history will be cleaned up.
`aliases_file`	Name of file where Bash aliases are set up.
`ignore_patterns`	List of patterns to ignore in `history_file`. Each line where a pattern is found will be deleted. Patterns are specified as regular expressions.
`add_aliases`	Boolean. If set to `true`, aliases from `aliases_file` will be added to `ignore_patterns`. (Default: `true`)
`aliases_match_greedily`	Boolean. If set to `true`, any line in `history_file` starting with an alias in `aliases_file` will be deleted. If set to `false`, delete line if the alias is the content of the whole line (with optional space at the end): `false` matches “^alias$” or “^alias $” only.
`backup_history`	Boolean. If set to `true`, `history_file` will be backed up in the same directory with a name ending in .bak based on the current date. (Default: `true`)
`delete_logs_without_confirming`	Boolean. If set to `true`, script with flag `-c` will automatically delete all the backup files found for `history_file`. (Default: `false`)

Anecdotal evidence of satisfying performances

Performance-wise, this scans ~8,300 lines per second on my modest Intel Core i5 laptop with files of over 200,000 lines long. Not that I type so much stuff in the terminal: I just duplicated many lines.

Conclusion

This is a simple solution to an nonexistent problem, but it was in the end very instructive to me nonetheless. You may even find a use for it! Otherwise, you might use the same functions for other files such as logs! If you would like to take a closer look at the source in a more convenient way, you can find the code available on Github.

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 – Tag: Linux

Tip the Scales in Times of Instability With the Rock-Solid Debian

Introduction

Why Debian?

Stability and Reliability

Marvelous Package Manager

It Just Won’t Break

Xfce Is Minimalist Enough and Hassle-Free

Xfce vs KDE

Xfce vs GNOME

Xfce vs i3

Xfce vs Other Window Managers

It’s Ideal for Developers

Resources Efficiency & Effectiveness

Rock-Solid Stability (Again, Big Selling Point!)

Packages Availability

Large Community with Freedom in Mind

Resources to Get Started

Conclusion

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

Using i3 as a Window Manager for Increased Productivity

What is i3?

What are desktop environments?

Why use a window manager like i3?

Less bloated

Lower memory and CPU consumption

Keyboard efficiency

Extremely fast customization

Easy to switch layouts and focus

What does it look like in action?

Conclusion

Bash History Cleaner

Introduction

Make history in a big way

Bash History Cleaner

bash_history_cleaner.py

settings.json

Description of available settings in settings.json

Anecdotal evidence of satisfying performances

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

Reset the terminal

Exit from the terminal

Display all file extensions recursively from the current directory

Find text inside files, including filenames

Reboot and shutdown the system

List and sort files and directories by modification time

`bash_history_cleaner.py`

`settings.json`

Description of available settings in `settings.json`

Setting an alias in `~/.bash_aliases`