Klaudjan's Webpage

Awk the Unchained

Fri, 28 Mar 2025 20:29:18 +0000

awk is a powerful text-processing language great for working with files (like CSV and logs), processing data streams (like the output of commands), and handling tasks like transforming data in a variety of ways.

I see awk as a tool that makes the difference and brings you to the next level by setting you free from the standard way of elaborating stream of data and files.

Syntax «

awk 'pattern { action }' <path_to_file>

pattern: This specifies when the action should be executed. It can be a regular expression, a condition (like matching a specific value), or simply true (to apply the action to every line). If no pattern is provided, the action is applied to every line of input.

action: This defines what awk should do when the pattern matches. The action is enclosed in curly braces {}. If no action is provided, awk will simply print the matched lines.

<path_to_file>: This is the path to the file to be processed. If the path is not provided, awk will process input from the standard input.

Basic use «

Print specific columns «

To print ids of the running containers we can print only the first column of the docker ps command.

docker ps | awk '{print $1}'

$1 represents the first column in each line of the docker ps output. In this case, it’s the container ID.

Using a pattern to match lines «

If I want to get the ID of the Postgres container

docker ps | awk ' /postgres/ {print $1}'

Perform an action on a line «

If I want to get the total amount of space occupied by the files in the current directory

ls -l | awk '{ sum += $5 } END {print sum}'

END: is a block that will be executed after all the lines have been processed.

There is also the BEGIN block that is executed before any line is processed.

this is an example of the usage

awk 'BEGIN { print "Start processing" }
     { print $1 }
     END { print "Finished processing" }' <path_to_file>

Advanced use «

Filter out rows from a CSV file «

Given a CSV file like this

id,product_id,business_id
1,23,45
9,45,89
39,356,45
...

We want to get the header and all the lines of a specific business_id

awk -F',' 'NR==1 || $3==45 { print $0 }' <path_to_file>

-F: is used to specify the column separator. By default, it is a space but with our CSV we are using a comma ‘,’
NR: holds the number of the line in which awk is operating at the moment
||: it is the boolean or

Remove duplicated lines without changing the order of the lines «

With awk, it is possible to remove all duplicate lines, regardless of their position in the file, unlike the uniq command, which only removes adjacent duplicate lines.

awk '!seen[$0]++' <path_to_file>

By using seen[$0], we track whether each line has appeared before. If a line has already been seen, it’s skipped; otherwise, it’s printed.

We are not limited to use only $0, with

awk '!seen[$1$2]++' <path_to_file>

$1$2 concatenates the values of the first and second fields. This will ensure that duplicates are only removed based on the combination of the first two fields, while ignoring the rest of the line.

Explanation:

seen[] is an associative array (similar to a map or dictionary) that awk initializes the first time we access it.
seen[$0] accesses the value stored in the map by the key $0
! negates the returned values of the map:
- In awk, any nonzero numeric value or any nonempty string value is true.
- By default, variables are initialized to the empty string, which is zero if converted to a number.
- That being said:
  - If seen[$0] = 0 or empty string then the negation is resolved to true.
  - If seen[$0] > 0 then the negation is resolved to false.
The ++ is a post-increment operator. This means that the value of seen[$0] is accessed first to evaluate the expression, and only then is it incremented.

Summing up, the whole expression evaluates to:

true if the occurrences are zero/empty string

false if the occurrences are greater than zero

If the pattern succeeds, then the associated action is executed. If we don’t provide an action, awk, by default, prints the line.

Knots: the first step to becoming the next MacGyver

Tue, 01 Oct 2024 22:41:05 +0000

It all started in the woods, in a survival training meant to forge new Rambos; it ended in the city with a cheaper version of MacGyver.

Actually, the survival training didn’t explain how useful knots might be in day-to-day life, but it was enough to spark an interest in me.

So I took The Morrow Guide to Knots (MGTK), an illustrated book that shows how to tie the most common knots and explains why they are used. Even though the book was good, it didn’t fuel my interest. I was just learning the knots as a hobby.

Then I started thinking outside my box, which didn’t have ropes at the time, and understood that ropes and knots can be very helpful in everyday life.

Whenever I had a problem, I started to think about whether a rope could help me. For example:

I used it to lock my cat’s leash to my jeans, created a handle for a garage box, attached shirts and bottles to my backpack, made a leash for my dog¹ and fixed my car bumper in the middle of the road. For this reason, I have a rope tied to my backpack in a quick-release manner , just in case I need it.

I’ve discovered that a simple knot can solve many problems; sometimes the most unexpected skills can become invaluable tools in our everyday lives, transforming challenges into manageable tasks.

Types and uses «

There are a lot of knots out there, that can be categorized in many types. The following are the categories I utilize:

I will list all the knots that I use and for each paragraph I will highlight the most significant knot with (*).

Many of these notes appear in The Ashley Book of Knots (ABOK), the bible of the knots, and will have a reference to the pages of the book.

Stopper Knots «

Stoppers are used primarily to make other knots more secure: are made in the end of a rope to prevent its slipping through an aperture when the rope is being used.

For example, it is added to the Bowline , which can shake loose, to eliminate the risk of undoing.

Double Overhand (*) «

[ABOK # 516, p 84]

The Double Overhand Knot is based on the Overhand Knot with one additional turn. It creates a larger knot that is far less likely to shake loose and looks cooler. It is also really easy to tie. Beyond two tuns, the knot must be worked into shape, and for that reason, it may be considered more decorative than practical.

The Overhand knot, in its variations (Double and Triple), provide the basis for other useful knots as the Fisherman’s Bend , Scaffold Knot , and Strangle knot.

I used this knot in my dog leash¹ as a stopper for the Scaffold knot. I had a fair excess of rope, enough to make the double overhand knot. It is more beautiful and secure than the simple overhand knot.

Ashley Stopper Knot «

[ABOK # 526, p 86]

This is a less-known knot that is bulkier and less prone to shake than the other Stopper knots. It may be better in some circumstances when you need a bulkier knot; but remember that It is easy to do it right, and unfortunately, it is also easy to get it wrong.

Heaving Line Knot «

[ABOK # 538, p 88]

The Heaving Line knots are very strong and don’t wear the fibers of the rope, and add weight to the end of a rope making it heavier.

There are different types of Heaving Line Knots, I prefer the Franciscan or Monk’s Knot [MGTK p 36] because it is very easy and quick to tie and hard to untie.

I tie it at each end of my dog’s toy rope, to make them bulkier and strong, becoming easy to hold for both of us when we are playing.

They are also used to make the end of the rope heavier before throwing it, making the throw more precise.

Hitch Knots «

Hitches are used for tying a rope directly to or around an object, and many of them capsize if removed from the supporting object.

Half Hitch (*) «

[ABOK # 50, p 14]
[MGTK p 58]

Half Hitches are temporary knots not intended to support a lot of strain. They are often used to complete and make other knots stronger and more secure, like with the Anchor Hitch and the Taut Line Hitch , and the more Half Hitches you concatenate the more secure a knot becomes

The Half Hitch is similar to the Clove Hitch because they have the same knot form, but the difference is that the first is tied around its own standing end, and the second is tied around another object.

As I said it is mainly used to make other knots more secure, but I also use it to attach little things to my backpack, like my Hat, because It is very easy and quick to tie and untie.

Anchor Hitch «

[ABOK # 1841, p 309] [MGTK p 60]

Also known as Fisherman’s Bend Hitch, this is one of the strongest and most secure hitches. Used to anchor the extremity of a rope to something.

Bull hitch «

It is a better version of the more famous Cow Hitch, it is more stable and less prone to slipping. This hitch is very easy to tie and is typically tied around a ring. I use it to tie a lanyard to my keychain or Swiss army knife.

Noose Knots «

Also known as Running Knots, this type of knot is tied in hand, and, when placed around an object, renders and constricts when the standing part is pulled. It is not a hitch because a hitch is tied directly to an object, and it doesn’t always constrict when the rope is pulled.
Any Loop Knots becomes a Noose if the running end passes through the loop.

Scaffold Knot (*) «

[ABOK # 1120, p 204]

This knot is one of my favorites.
It is easy to tie, strong, and secure.

I used it in my dog’s leash¹ and also in some circumstances when I want to tie a rope around an object that cannot be easily reached, like when I needed to tie a rope around a screw to fix my car.

Canadian Jam Knot «

[ABOK # 2069, p 336]

This noose is simple and quick to tie; however, it can loosen easily. To maintain its form, I secure it with two Half Hitches or a Taut Line Hitch tied to the same rope.

I like this knot because it is really easy to tighten the rope around the object without needing too much force.

I use this method to bundle my sets of blankets and to secure one corner of the comforter cover: this allows me to hold the comforter in place while I insert the remaining portion inside.

Loop Knots «

These knots serve the same purpose as a hitch, but they are tied in hand, which is the main distinction between the two. Its shape, a loop, is not dependent on the object that it is fast to, and it may be removed at any time and will still retain its shape.
A Loop Knot can become a Noose if the standing part is passed through the loop.

Bowline Knot (*) «

[ABOK # 1010, p 186]
[MGTK p 70]

If you have to remember only one knot, this is the one.

The Bowline Loop Knot can hold heavy weights and it is easy to tie and untie. It is so easy that it can be tied with one hand, it is useful if you are injured or cannot use the other hand for some reason.

It is pretty secure, but it can very readily work its way untied when unloaded and I would not put my life on it. So It is best to add a Stopper Knot or a more secure Bowline variant like the Scott’s Locked Bowline.

Double Dragon Loop «

The Double Dragon Loop is a less known knot, and it is a shame because it is

more secure than the standard Bowline : doesn’t need a Stopper knot

it doesn’t bind: it is easy to untie,

it is highly adjustable: while you are tieing you can easily determine the loop size that you want,

it is an inline knot: can be tied in the middle of the rope.

Even though it has all these advantages, it is not present in the ABOK, but we can find a similar one: the Angler’s Loop [ABOK # 1017 p186-187], which is tied with only one loop around the knot, making it is less secure than the Double Dragon Loop.

Bend Knots «

Bends are used for joining two ropes at the ends to form a longer rope, or to tie two ending parts of the same rope together closing the rope. Bends should only be used as a temporary measure.

Square Knot «

[ABOK # 1402, p 258]
[MGTK p 128]

Also known as Reef Knot.

This bend knot is very easy to tie and untie, for this reason, it is widely known. But it must not be used to secure things, it is slippery and it comes undone. If tied with two ends of unequal size, or if one end is stiffer or more slippery than the other, it is bound to spill.

For this reason it cannot be trusted.

It should only be used for making temporary joints in identical ropes which will not be subject to strain.

Nevertheless, the Square Knot has many uses but not where safety is critical.

For example, I use it when I tie my water bottle to my backpack: do a Purcell Prusik Loop over the bottle and close the rope with a Square knot over the handler of the backpack. I use the Square Knot and not the Fisherman’s Bend , because I want to tie and untie it often.

Tip for tiening: put always the same rope on top of the other and under the other, this will make it easy to remember.

Sheet Bend (*) «

[ABOK # 1431, p 262]
[MGTK p 122]

This Bend Knot can be used to bend two ropes of the same, or different, diameters and types. It has the interesting property that the greater the strain put on the ropes, the better the jamming action.

It is quickly made and easily untied and by doubling the knot you make the Double Sheet Bend that is more secure especially when you have two ropes that are markedly different in size.

The Slippery version of it can be used to tie pants easily.

Fisherman’s Bend «

[ABOK # 294, p 50]
[MGTK p 140]

This is one of my favorite knots. It is a very secure, easy to tie, and hard to untie, for this reason it is used by climbers to bend the ropes.

It is made with two or three Overhand Knots tied around the other standing end, obtaining two knots that hold each other ropes and when pulled they will crash with each other, welding the knots together.

It is suggested to tie more than one overhand knot because it is not secure enough. The more overhand knots are done, the more it is secure, and make sure to leave enough extra rope.

I use this knot only when I don’t want to untie it, like in my dog leash¹ or for example, it is used with the Prusik Knot .

Lashings Knots «

A lashing may wrap and bind, or else bind only with a multiplicity of turns, a parcel, box, chest or other container, either for transportation or for storage. It may secure something movable to something that is fixed, with various turns and hitches, so that it cannot shift from its position. Some of these knots act like the zip ties.

Trucker’s Hitch «

[ABOK # 2124, p 344]

This knot is used primarily for securing loads or tensioning ropes for tarpaulins, or any other cases when you need to tension the rope. It is widely used for its simplicity and the fact that it provides a mechanical advantage when tightening the rope.

Here you can find a cool variant of it.

Taut Line Hitch (*) «

The Taut Line Hitch knot creates an adjustable loop at the end of a rope, like a zip tie, that can be slid by hand either to lengthen or to shorten the rope but, left alone, it stays where it is.

There are three different knots, very similar to each other, that are called in this manner: Midshipman’s Hitch [ABOK # 1855, p 310], Rolling Hitch [ABOK # 1856, p 310], and the [ABOK # 1857, p 310]

The Midshipman’s Hitch is the strongest, the other two are easier to adjust and secure enough for most applications.

(What makes the Midshipman’s Hitch Knot the strongest and most secure is the creation of the useful intermediate Awning Hitch; this takes the strain while tying the final Half Hitch. Also, it is relatively easy to tie or untie under load and, even after being heavily loaded, it is reasonably easy to release For more information look at this video )

These knots are extremely versatile and quick to make, I often use them to tie the end rope to itself and tension it a little bit (if you want to tension your rope, you better use the Trucker’s Hitch , which have a stronger tension power), or, using the loop that is formed, to compress object, like sleeping bag, or to hold objects together like a couple of books.

Prusik Knot «

This knot is one of the best knots for friction hitch: it holds its place even under load, you have to manually pull it to move it. It is very secure.

Because the Prusik Knot is a symmetrical slide and grip knot, it is useful if a load might need to be applied in either direction

It is widely used in climbing, and I used it in my dog leash¹, in which it is the main protagonist because enables the leash to fold in itself without losing strength.

This knot is also used to create the Purcell Prusik Loop , a zip tie knot, as you will see next.

Purcell Prusik Loop «

This is a Prusik knot that is tied to the same rope, basically to itself.

To tie it you have to bend the two ends of the rope, for example with a Fisherman’s Bend Knot , if you need a secure bend, or a Square Knot if you want to untie it later on. After the bend, you create the Prusik Knot and pass the rest of the rope inside it.

This knot takes a lot of rope, the double of the end result, but I like it and it feels more secure than other zip tie knots, for this reason it is my first chooise if I need a zip tie knot that is secure. I use it to hold my water bottle because my rope is too long to use the Taut Line Hitch which doesn’t need the bend.

Decorative Knots «

Diamond knot (*) «

[ABOK # 787, p 141]
[MGTK p 200] Also known as Lanyard Knot

This knot can be categorized as a stopper knot, loop knot, lanyard knot, and decorative knot. But it is mainly used as a decorative, lanyard knot.

It ties together two ends of the rope, usually of the same rope, and it looks cool for this reason it is used for decorating any cord that is to be left in view such as a knife or lanyard.

Monk’s Knot «

I already talked of this knot in the Heaving Line Knot , and I quote it here because I use it even as a decorative knot for lanyards.

I use this knot when I have only the end of a rope to decorate: it is bulky, a bit long, and also a bit decorative.

Shoelace Knots «

Berluti Knot «

Also known as the “Parisian Knot”, this is a very secure knot. It is a popular choice for tying dress shoes and it is favored for its sleek appearance and functionality:

Appearance: The knot is low-profile and symmetrical, making it visually appealing for formal occasions.

Stability: It stays tied throughout the day, providing reliable hold without the bulk of a double knot.

Ease of Release: The knot can be easily untied by pulling both ends, allowing for quick removal.

My dog leash ↩︎

Git triks

Mon, 23 Oct 2023 16:38:27 +0000

Selective adding changes to staging area «

git add -p <filename>

Git will break down your file into what it thinks are sensible hunks (portions of the file). It will then prompt you with this question: Stage this hunk [y,n,q,a,d,/,j,J,g,s,e,?]?

Here is a description of each option:

y stage this hunk for the next commit
n do not stage this hunk for the next commit
q quit; do not stage this hunk or any of the remaining hunks
a stage this hunk and all later hunks in the file
d do not stage this hunk or any of the later hunks in the file
g select a hunk to go to
/ search for a hunk matching the given regex
j leave this hunk undecided, see next undecided hunk
J leave this hunk undecided, see next hunk
k leave this hunk undecided, see previous undecided hunk
K leave this hunk undecided, see previous hunk
s split the current hunk into smaller hunks
e manually edit the current hunk
- You can then edit the hunk manually by replacing +/- by #
? print hunk help

If the file is not in the repository yet, you can first do git add -N <filename>. Afterwards you can go on with git add -p <filename>.

You can use: git reset -p to unstage mistakenly added hunks.

Rename branch «

To change the name locally go into the branch you want to rename, and rename it

git switch <branch_name>
git branch -m <new_branch_name>

Or you can do it without changing branch

git branch -m <old_name> <new_name>

To change the name remotely you have to delete the old name and push the new branch

git push origin --delete <old_name>
git push origin -u <new_name>

Stash single files «

When you don’t want to stash all the edited files, but only a subset, you can use this command

git stash push <file1> <file2> .. <fileN>

To make the stash retrieval easier, add a message with -m <message>

Diff staged changes «

git diff --staged

Remove files that have not been added to the staging area «

git clean -df

Revert changes that have been pushed on remote «

git diff master > branch.diff
git apply --reverse branch.diff
git rm branch.diff

Check if a folder changed «

git diff --quiet HEAD <commit_to_compare> -- <dir_to_check> || echo changed

Note that git diff --quiet will exit 1 when there are changes.

For example if you want to check if your current branch has changes in the directory dir1 when compared to the previous commit:

git diff --quiet HEAD HEAD~1 -- dir1 || echo changed

You can do this even with the previous tag

git diff --quiet HEAD "$(git describe --tags --abbrev=0 HEAD)" -- dir1 || echo changed

I have used this command to help me automate my website release: How to deploy automatically a Hugo website .

Access git remote with SSH

Sat, 30 Sep 2023 06:31:03 +0000

When I started working, I found it challenging to work on my personal projects and the work projects on the same machine. At that time I saved my authentication data in the .git-cretendials file, and I didn’t know how to handle different credentials for different projects.

After some researches I found out that you can access your projects with an SSH key!

But, what does that mean?
At the beginning of my love-story with git, I learned that to work with a remote server I had to use a private password or key. For each push or pull, or more in general, for each command that had to interact with remote, I had to write the password. Or better, I could save it somewhere, ready to be used by git.

With the SSH approach, you will not use a password, or at least, you will not use a password like you are used to. You will use a pair of SSH keys, one public and one private, to authenticate with the remote server, like GitHub or GitLab. Keeping the private half on your machine and installing the public half on the remote server.
This is how the authentication works:

Before setting up an SSH connection, the SSH client needs to generate its own public-private key pair and store its public key on the remote server.
The SSH client sends a login request to the remote server.
The remote server searches for the client public key based on information such as the username in the request, encrypts a random number using the public key, and sends the encrypted random number to the client.
Upon receipt, the SSH client uses its own private key to decrypt the returned information before sending the decrypted information to the remote server.
The remote server checks whether the decrypted information sent by the SSH client is correct; if the information is correct, authentication is successful.

There was another change that I had to make, given that I don’t use the same name and email for all my projects I removed them from the global git configuration (~/.gitconfig). Instead of setting this data globally, as git suggests, I set them locally for each project: git config user.name "<Name>". For my private project I use my email, and for work-related projects I use the work email.

How to create an SSH Key «

To create the SSH keys, you can run the following command

$ ssh-keygen -t ed25519 -C "<email>"

The command will ask if you want to set a password for the key, omitting it will allow you to use the key without entering the password each time you use it.

The command will generate the keys in the current directory, so, I suggest executing it in the ~/.ssh/ directory. This directory is used to configure all the SSH-related stuff.

The command will generate two keys, one private and one public (.pub). The private key must remain private and must not be shared or used with more than one device, for security reasons. The public key must be shared with all the services that you want to interact with, in this case GitHub or GitLab.

To make use of these keys easier, we can write a configuration file, named config, in the ~/.ssh/ directory.

This is an example of my configuration file

Host git-personal # name chosen by me
    Hostname github.com
    User git
    IdentityFile ~/.ssh/git_personal # private ssh-key

Host git-work # name chosen by me
    Hostname github.com
    User git
    IdentityFile ~/.ssh/git_work # private ssh-key

To use a key, you can enter the name you choose as the Host.

For example, to clone my own dotfiles I would write

$ git clone git-personal:Klodii/dotfiles.git

Of course, I already associated my public key with my GitHub account; otherwise, I would have gotten an error.

How to deploy automatically a Hugo website

Fri, 28 Jul 2023 15:28:35 +0000

I while ago I asked myself if there is a way to deploy automatically all the updates of my website, which is written with Hugo framework .

Before describing the automated procedure that I ended up using, I will describe my workflow in order to make more clear my decisions.

Overview «

The only thing we need to know, about how Hugo works, is that the static files that will be used by Hugo to display the website, are located in the public directory. To generate these files we execute the hugo command, which will check for changes in the articles or the HTML templates, and if there are it will create/edit the files in the public directory.

This is my workflow with git: I do all my changes as many times as I wish and commit as many times as I want. Best if each commit as a single scope.
When I feel that my work is ready to be released, I made sure that there are no pending changes and execute the hugo command. With the static files generated, I commit them with a message that always begins with release:, for example:

$ git commit -m "release: added 'How to deploy automatically a Hugo website'"

Manual procedure «

To actually release the changes I have to SSH into the website server, go to the project directory and git pull all the changes, and finally restart the docker container: which will apply all the new changes.

Automatic procedure «

After some time that I have done this procedure, I started thinking if I can execute all these steps automatically.
The first part was easy, create a cron job that will execute a bash script every morning (which is shown at the end of this article).

The second part was to create the script that will check if it is time to do a new deployment and restart the container.

Obviously, the script has to pull the latest changes, so I have to add a flag to specify the project directory.
But how to check if it is time to do a new deployment? There were two solutions that came to my mind:

check the commit messages, if there has been, through all the new commits, a message that begins with “release:"
check if the public directory has changed since the last time.

The first solution didn’t convince me, even if I have this convention at the moment it could change at any time, and what if I do a typo while writing the commit message? It was not reliable.

Only one thing will remain the same over time until Hugo changes it: when I’m ready to do a release I will update the public directory. So it is clear that a good solution is to check if this directory has changed since the last time.

To check if the directory has changed I used the following git command

git diff --quiet HEAD <commit_to_compare> -- <dir_to_check>

<commit_to_compare> is the hash of the HEAD before doing git pull and <dir_to_check> is the “public” directory. This command returns 0 if there are no changes, and 1 otherwise.

This is the bash script:

#!/bin/bash
function exit_w_error {
    echo "$1"
    exit 1
} >&2 # redirect to STDERR
function is_installed {
    [ -z "$1" ] && exit_w_error "Command name missing"
    COMMAND=$1
    FOUND=false
    PATH_SPACED=${PATH//:/ } # separate each path by space instead of :
    for individual_path in ${PATH_SPACED}; do
        # true if file exist and is executable
        [ -x "$individual_path/$COMMAND" ] && FOUND=true && break
    done
}


SCRIPT_NAME=${0##*/}  # performed a string manipulation operation to get the script name
DIR_TO_MONITOR='website/public'
function help {
    # here-document used instead of echoing all lines
   cat <<-HMESSAGE
Perform a git pull and check if the '$DIR_TO_MONITOR' directory has changed.
If this directory has changed, restart the production container to
release the new updates.
This is possible because the Hugo framework uses the 'public' directory to
store the files that have to be published, and we update it only when
we are ready to publish.
So, if the directory is updated this means that we can publish the changes.

Syntax: $SCRIPT_NAME [-hvd]
Options:
    -h     Print this help and exit.
    -v     Make messages more verbose
    -d     Directory of the git project to check
HMESSAGE
}


DIR=''
DEBUG=':' # no-op, do nothing command
# Get the options
while getopts "hvd:" option; do
    case $option in
        h )
            help
            exit 0;;
        v )
            DEBUG='echo';;
        d )
            DIR=$OPTARG;;
        \?)
            echo "Error: Invalid option"
            exit 1;;
    esac
done
shift $((OPTIND -1)) # remove all options from $#

echo "$(date) - executing '$SCRIPT_NAME' script"

is_installed git
is_installed docker

[ -d "$DIR" ] && cd "$DIR" && $DEBUG "Moved to $DIR"

[ -d "$DIR_TO_MONITOR" ] || exit_w_error "'$DIR_TO_MONITOR' does not exist in the current directory"

PRE_PULL_HASH=$(git rev-parse HEAD)

$DEBUG 'Pulling from remote'
if [ $DEBUG = ':' ];then
    git pull --quiet
else
    git pull
fi

# --quiet makes the command return 0 if there are no changes, 1 otherwise
$(git diff --quiet HEAD $PRE_PULL_HASH -- "$DIR_TO_MONITOR") && { $DEBUG "The '$DIR_TO_MONITOR' directory was not updated"; echo "NOT UPDATING the website"; exit 0; }

$DEBUG "The '$DIR_TO_MONITOR' directory was updated, restarting the production container"
echo "UPDATING the website"
docker compose restart
exit 0

This is how I set the cron job

# every day at 6:00 AM, in the Rome timezone
0 3 * * * <path to script> -d <path to website> >> <path to log file>

Git worktree

Mon, 17 Apr 2023 22:40:44 +0200

Git worktree is not just a command; it’s the first step toward a new way to work. It enables you to be in different branches at the same time. Let me explain what I mean.

What it is «

git worktree allows you to have multiple working trees for a single Git repository. This means you can have multiple instances of your repository on your file system, each with its own working directory, but all sharing the same Git history. This makes it easier to work with multiple branches, as you can have a separate working directory for each branch.

Why I use it «

Git worktrees are extremely useful when you work with different branches at the same time. The main strength is the possibility to jump from one branch to another, without the need to stash or commit the pending changes. This avoids the creation of temporary¹ commits, that in most cases will remain in the commit history.

How many times have you had to resolve an urgent bug in production while you were developing something new? It can happen, in this case you stash or commit all your unstaged code, switch to your main branch, fix the bug, commit it and then return to the previous branch and retrieve all your stashed code. This procedure can be tedious and time-consuming operation.

With git worktrees you can handle this case more easily. Each time you have to abandon what you are doing and make some implementation to another branch, all you have to do is change the directory. Make all the changes you have to do and then return to the previous working directory. And you will find all your unstaged changes still there.

How I use it «

Create work tree «

To create a worktree run:

git worktree add <pat_to_directory> <branch_name>

Where <path_to_directory> will be the new location of the work tree and <branch_name> is the initial branch of the worktree.

I found it useful to put all my working directories in a directory named forest. Usually I use a custom script that creates the work tree in the forest directory and copies, from the main working directory, all the env/secrets files needed for the project, to the newly created working directory.

Hop between working directories «

To hop from one working directory to another, quicker than cd /path/to/working_directory/ into it, I wrote this useful alias

cd $FDIR/$(ls $FDIR | fzf --height "25%" --header "Choose the workingtree" --reverse --border)

Where the $FDIR contains the path to the forest directory. With the use of fzf we can list all the worktrees, and with a few characters, you can identify the directory and change location.

Remove a work tree «

Usually, before doing the removal I list all working trees/directories, git worktree list, and then I proceed with the removal, git worktree remove. This operation simply deletes the worktree directory.

Note: you could delete the worktree directory with the rm command, but by doing this you could leave something pending. In this case, you can remove all pending things by executing git worktree prune.

“There is nothing more permanent than a temporary solution” ↩︎