What are timezones

Time zones are a way of mapping the Earth’s 24-hour rotation into practical local times so that noon corresponds roughly to when the sun is highest in the sky. The Earth is divided into longitudinal regions, each offset from Coordinated Universal Time (UTC), which serves as the global reference clock. Historically, timekeeping was local and solar-based until railways and telecommunications forced standardization in the 19th century, leading to the adoption of standardized time zones and eventually UTC as the universal baseline.

In modern computing, time zones are represented using the IANA Time Zone Database (also called the tz or Olson database), which encodes not just fixed offsets (like UTC+1) but also historical changes and daylight saving rules for each region. In Python, the modern standard library tool for working with time zones is zoneinfo (introduced in Python 3.9 via PEP 615), which replaces earlier reliance on third-party packages like pytz.

Naive vs localized timestamps

One of the most important concepts in time zone handling is the difference between naive and aware timestamps. A naive datetime object in Python has no attached time zone information, which means it does not represent an absolute point in time but only a wall clock value.

from datetime import datetime

naive_ts = datetime(2026, 3, 2, 14, 30, 00)

The problem arises when such a timestamp is interpreted differently depending on the system or context. For example, the above example could mean 14:30 in Paris, New York or Tokyo. Without explicit context, Python assumes a timestamp is in the system’s local time zone when converting it. This becomes dangerous since it can produce inconsistent results across machines:

# Assuming the machine's local time zone is Europe/Paris
naive_ts = datetime(2026, 3, 2, 14, 30, 0)
utc_ts = naive_ts.astimezone(ZoneInfo("UTC"))

>>> utc_ts
2026-03-02 13:30:00+00:00

# Assuming the machine's local time zone is America/New_York
naive_ts = datetime(2026, 3, 2, 14, 30, 0)
utc_ts = naive_ts.astimezone(ZoneInfo("UTC"))

>>> utc_ts
2026-03-02 19:30:00+00:00

The correct approach is to always make timestamps timezone-aware before conversion. When naive datetimes represent only a local interpretation of a clock reading, timezone-aware timestamps represent an absolute point in time. Once a timestamp is aware, conversions become reliable and deterministic. In our above example, assuming we meant 14:30 in Paris, making the timestamp timezone-aware will guarantee the same conversion to UTC whether the machine running the code is located in Paris or in New York:

from datetime import datetime
from zoneinfo import ZoneInfo

# Assuming the system's local time zone is America/New_York
paris_ts = datetime(2026, 3, 2, 14, 30, 0, tzinfo=ZoneInfo("Europe/Paris"))
utc_ts = paris_ts.astimezone(ZoneInfo("UTC"))

>>> utc_ts
2026-03-02 13:30:00+00:00

The DST complexity

Daylight Saving Time (DST) adds another layer of complexity to time zone handling because it introduces seasonal shifts in local time offsets. DST is the practice of moving clocks forward in Spring and backward in Autumn to extend evening daylight hours during warmer months.

Not all regions observe DST, and those that do often implement it differently. For example, in the United States, DST typically begins on the second Sunday in March and ends on the first Sunday in November, shifting time zones such as Eastern Time from UTC−5 (EST) to UTC−4 (EDT). In contrast, most European countries, begin DST on the last Sunday in March and end it on the last Sunday in October, shifting from UTC+0 (GMT) to UTC+1 (BST). This mismatch means that for several weeks each year, the time difference between America and Europe changes.

gantt
    title DST 2026 — US vs UK
    dateFormat  YYYY-MM-DD
    axisFormat  %b
    todayMarker off

    section US

    US Winter   :us_w1, 2026-01-01, 2026-03-08
    US Summer   :us_s, 2026-03-08, 2026-11-01
    US Winter   :us_w2, 2026-11-01, 2026-12-31

    section UK

    UK Winter   :uk_w1, 2026-01-01, 2026-03-29
    UK Summer   :uk_s, 2026-03-29, 2026-10-25
    UK Winter   :uk_w2, 2026-10-25, 2026-12-31

Fortunately, zoneinfo handles these transitions automatically using the IANA database, so converting timestamps across zones correctly reflects these offsets without manual adjustment. However, care must still be taken when working with local times around DST transitions, because some local times do not exist (spring forward gaps) or occur twice (fall back ambiguity).

Install Docker for Windows

If you haven’t already, download and install Docker Desktop. This will let you run containerized services on your machine. By default, Docker Desktop will run with WSL 2 (Windows Subsystem for Linux).

Once installed, check that Docker is working by opening a terminal window and typing:

docker --version

Clone Your GitHub Pages repository

By convention, the GitHub Pages site for user username is hosted in a repo named username.github.io. For instance, the blog you’re reading is hosted at https://github.com/tlouarn/tlouarn.github.io.

Clone your repo locally using:

git clone https://github.com/{username}/{username}.github.io

Add a docker-compose.yml File

At the root of your project, create a docker-compose.yml file. This file defines which containers to run.

Paste the following:

version: '2.4'

services:
  jekyll:
    image: bretfisher/jekyll-serve
    volumes:
      - .:/site
    ports:
      - '80:4000'

This sets up a Jekyll service using the bretfisher/jekyll-serve image and maps port 4000 inside the container to port 80 on your machine. When the container starts, everything in the local project directory is accessible inside the container at /site (in particular, the generated website will be served from /site/_site).

Add a Gemfile

A Gemfile is a plain-text manifest that tells Bundler (Ruby’s dependency manager) what libraries (called gems) your project requires and which versions to use. It ensures that anyone who clones the repository can install exactly the same dependencies, keeping the development and production environments in sync.

Create a Gemfile with the following content:

source "https://rubygems.org"

gem 'github-pages', group: :jekyll_plugins

This ensures your local Jekyll environment matches GitHub Pages exactly. The github-pages gem pins versions of Jekyll and all supported plugins so what you see locally is what you’ll get when GitHub builds your site.

Update your .gitignore (optional but recommended)

Since Docker will generate extra files (like _site), you may want to add them to your .gitignore file so they don’t clutter your commits. Example:

_site/

Run the site locally

From the project root, start Docker with:

docker-compose up

This will spin up a Jekyll server inside Docker, generate your site into the _site folder and serve it at http://localhost/. The best part? Live reload is enabled, so changes you make to your files will instantly update in your browser.

References:

• https://docs.docker.com/get-started/
• https://blog.nimblepros.com/blogs/github-pages-with-dev-containers/
• https://bjm.me.uk/blog/testing-github-pages-locally-docker/

This post examines design considerations for implementing a live order book GUI in Python using PySide6. PySide is the official Python port of the popular Qt framework. For the data source, we will use a free Bitcoin order book feed provided by Bitfinex.

Websockets

WebSockets is a communication protocol that operates over a single TCP connection and allows real-time data exchange between a client and a server. Unlike traditional HTTP requests, which are one-way and require constant polling for updates, WebSockets provide a persistent connection where both the client and the server can send data at any time.

In Python, the most commonly used package for WebSocket communication is websockets. This package is an asyncio-based library that supports both client and server WebSocket implementations.

The Bitfinex API v2 gives access to a live Bitcoin order book via a WebSocket connection. The documentation of the book channel can be found here. Once connected to the WebSocket API, the client receives messages in the following order: first a snapshot of the current order book, then some updates to the order book (changes in prices and quantities of bids and asks). Once every 15 seconds, the client receives a heartbeat message to confirm that the connection is still open. It is therefore the client’s responsibility to maintain an internal representation of the order book and to update it accordingly with the messages received.

Design decisions

I have broken down the program into several key components:

• BitfinexHandler: interacts with the Bitfinex WebSockets API
• OrderBookModel: maintains an up-to-date internal representation of the order book
• MainWindow: ties the handler and the model to the UI

First thing first, we don’t want our UI to freeze while we are handling market data, therefore we will use asynchronous programming with the asyncio framework as well as Qt’s own signals mechanism. We showcase the use of signals by updating the status bar of the main window whenever the connection is (asynchronously) opened or closed by the handler.

BitfinexHandler is our primary client for the Bitfinex Websockets API. We implement it as a subclass of QObject in order to be able to emit signals. When it opens or close a connection, BitfinexHandler emits a specific signal that can be captured by the main window. When listening to updates of the book channel for Bitcoin (tBTCUSD), it calls back a custom handle_message method from MainWindow.

We could choose to maintain our data model directly as it is represented (i.e. a 5x4 table), or we could maintain it in a dedicated structure and implement standard methods by which our view can represent it as a table. Since it is generally good practice to separate data from UI, we choose the second option. To do so, instead of relying on a QTableWidget component, we choose to use a custom QTableView together with a custom QAbstractTableModel. This way, instead of directly updating the table cells, we update an internal model that is then translated by the view into a 5x4 table.

The main window controls the show. It builds the interface using a button, a table and a status bar. It initiates our client using its own handle_message method as a callback, meaning this method is called everytime the client receives a message. The message can either be informative (like a heartbeat) or market-related. In the latter case, the message would either be a 50-long list (25 limits on either side of bids and asks) or a 1-long list (update of a single limit). The handle_message method passes on the messages received from the handler into our order book model and notifies the view that the model has been updated.

Finally, we use qasync in order to integrate Qt’s own event loop with asyncio’s separate event loop.

UI considerations

In terms of UI, we want the user to start and stop the connection with buttons. A button should always display an action rather than a status. We could imagine two buttons: Start and Stop. Since we do not want the user to start a system already started nor to stop a system already stopped, only one of these two buttons should be enabled at all times. In fact, we could probably use a single button which action changes depending on the state of the system. This is what we implemented using our own ToggleButton widget. One last subtlety: while the system is connecting or disconnecting, we temporarily disable the button and enable it again once the system is either fully connected or fully disconnected. This avoids clicking twice while the previous operation is still running.

Qt provides a default design for its components but we want some degree of customization linked to the type of application we are building and the type of data we are handling. Among the questions to be asked are: What font should be used? What font size is optimal? How much spacing inside the cells? Should we right-align all numbers? How many decimals should be displayed? How to remove double borders (cell borders and table borders)? Thankfully, the Qt framework is customizable via its own CSS so we have provided our custom components with their own style sheets. In order to not make main_window.py too big, we have placed the button and the table classes in their own files, still in the views folder.

The result

The result is a responsive, asynchronous and (hopefully) good-looking UI that shows a live Bitcoin order book. The user can start and stop the feed with a toggle button. Most importantly, the interface remains fully responsive in any possible state of the WebSocket connection. This allows for instance the user to resize the window while, in the background, the client is connecting to the feed or the view is updating the table.

The final project can be found on my GitHub.

What is GitHub Pages

GitHub Pages is a free service provided by GitHub that allows you to host a static website directly from one of your GitHub repositories. It is based on a static site generator named Jekyll, which serves the content located in a special repository named {username}.github.io (each GitHub user can create one such special repository). Thanks to GitHub Actions, each commit to this specific repository triggers a build of the static website. In other words, once the setup is in place, all you need to do is push a new post to the repository for your website to update.

Getting started

Create a new repository named {username}.github.io

Add 2 files:

_config.yml
main.md

Let’s now setup GitHub Actions for this repository. A GitHub Action is hosted by GitHub on a Linux instance and can be parameterized using YAML files.

Go to the repository settings. Under Code and automation, select Pages. Under Build and deployment, select Deploy from a branch and choose main. From now on, each new push to the main branch will trigger a website refresh. The generated html is stored by Github in a special _site folder that can’t be accessed from the repo.

The website is now publicly available at https://{username}.github.io, but it is also possible to configure a custom domain name. The process involves two steps:

1. securing the domain name within GitHub to prevent domain takeover (see details here)
2. configuring the apex domain at your DNS provider

Website structure

In the website repository, the folder structure looks like the below:

# The GitHub Actions
.github/workflows
    jekyll-gh-pages.yml

# A .gitignore is always welcome
.gitignore

# The _config.yml file contains all the parameters for Jekyll
_config.yml

# Posts are simple MarkDown files located in the _posts directory
_posts
    2020-01-01-example-post.md
    2020-02-01-example-post-2.md
    ...

# Images are contained within the assets/images directory
assets/images
    image1.jpeg
    image2.jpeg
    ...

# The main pages are located directly at the root (they can be either HTML or MarkDown)
404.html
archive.html
index.md

# A CNAME file can be required for domain name verification
CNAME

You can view the structure of this blog at https://github.com/tlouarn/tlouarn.github.io.

Some customization tips

How to add a table of contents:

• add markdown: kramdown to _config.yml
• on each post, add a dummy ordered/unordered list item followed by {:toc}

For instance, I use:

**Table of Contents:**
* 
{:toc}

This will generate an unordered table of contents.

How to add LaTeX equations

I use KaTeX via a simple JavaScript insert in my header:

<!-- KaTex -->
<link async rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.0/dist/katex.min.css" crossorigin="anonymous">
<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.0/dist/katex.min.js" crossorigin="anonymous"></script>
<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.0/dist/contrib/auto-render.min.js" crossorigin="anonymous" onload="renderMathInElement(document.body);"></script>

KaTeX expressions must be escaped using \\[ and \\]. Here is how to write a simple equation:

\\[ C - P= D \cdot (F - K) \\]

and how it is rendered:

\[ C - P= D \cdot (F - K) \]

How to customize CSS

GitHub Pages currently runs on minima v2.5.1. In order to overwrite or add custom css, the easiest way is to create assets/main.scss and import the minima style inside, then overwrite it.

---
# Only the main Sass file needs front matter (the dashes are enough)
---

@import "minima";

body {
    font: Helvetica,Arial,sans-serif;
    letter-spacing:  -1px;
}

A better way is to fork the minima theme into a custom repo (I chose tlouarn/minima), strip all the unnecessary files and customize it by overwriting styles in _sass/minima/custom-variables.scss and _sass/minima/custom-styles.scss. Back to the main repo, add the following line to _config.yml:

remote_theme: tlouarn/minima

This way, content and presentation are cleanly separated. Also, the actual theme is now frozen (in case GitHub chooses to update the default theme at a later stage).

How to add images

Image files need to be uploaded into assets/images and can be referenced like so:

![Image](/assets/images/image.jpg)

How to link other posts

To create a hyperlink to another post named “2020-01-01-example-post.md”, enter the below:

[link text]({% post_url 2020-01-01-example-post %})

Formulas to count the arrangements of \(k\) elements among \(n\):

Permutation with repetition

We have a set of \(n\) elements, we build an ordered list of \(k\) elements chosen among the set with repetitions allowed. At each of the \(k\) draws, we can choose among \(n\) possibilities. The resulting number of permutations is: \[ n^k \]

Permutation without repetition

We have a set of \(n\) elements, we build an ordered list of \(k\) elements chosen among the set with no repetition allowed. For the first draw, we can choose among \(n\) elements. For the second draw, we can choose among \((n - 1)\) elements, etc. The resulting number of permutations is: \[ P(n, k) = \frac{n!}{ (n-k)!} \]

Combination without repetition

This is the binomial coefficient. It’s a combination so the order does not matter. It can be expressed as a permutation altered t \[ {n \choose k} = C(n, k) = \frac{P(n, k)}{k!} = \frac{ n! }{k! \times (n-k)!} \]

Combination with repetition

This is a tricky one. \[ { n+k-1 \choose k } = \frac{(n+k-1)!}{k! \times (n-1)!} \]

Examples

References:

• https://betterexplained.com/articles/easy-permutations-and-combinations/
• https://www.intmath.com/counting-probability/3-permutations.php
• https://www.mathsisfun.com/combinatorics/combinations-permutations.html

There are tons of different Linux distributions, but most of them belong to a specific family. The three main families of distributions are:

Since I use Ubuntu on my WSL and Amazon EC2, and Ubuntu belongs to the Debian family, I will only write down useful commands and tools from the Debian family.

Table of contents:

• The file system
• The command line
• Navigating the directory
• Manipulating files and directories
• The package manager
• Editing files
• User management
• Environment variables
• Manipulating files
• Streams and pipes
• Processes
• Cron
• Networks

The file system

The file system works as a tree. Unlike Windows where there can be multiple roots like C:\ and D:\, Linux only has one root and it is accessible via /. All other files, directories and partitions are located under the root. In particular, multiple drives are mounted under /mnt.

The Filesystem Hierarchy Standard (FHS) describes the main top-level directories located just under the root:

Notes:

• The file system is case-sensitive
• Each user has a directory under /home named after him
• /proc contains virtual files that only exist in memory
• /etc contains system configuration files (only the root user can edit)
• /lib contains dynamically loaded libraries

The command line

The command line is a text-based interface where users can interact with the operating system by typing commands. The basic structure of a command is:

command [flags] [arguments]

The command is the program or action to run. The flags are optional and modify the behavior of the command if needed. The arguments are the input of the command. For example, typing df -Th / displays the amount of available disk space for the root filesystem along with their type and human-readable numbers. We can break down this instruction as follows:

Navigating the directory

Below are some basic commands to navigate the directory and manipulate files.

Some flags often used with the ls command:

• ls -a lists all contents including hidden files and directories
• ls -i includes the inode of each file
• ls -h displays files sizes in a human-readable format
• ls -l shows more information

Flags can be combined: ls -aihl does all of the above at once. ls also works with Globbing patterns, such as ls *.txt to list all files with a txt extension.

In order to get help on any command, type man [command] (which stands for “manual”). For instance, to get help on find, type man find. This proves useful when looking for specific flags. To interrupt a command, type Ctrl + C. To clear the command line, type Ctrl + L.

Manipulating files and directories

Note: most applications open the file rather than rely on extensions. Extensions are more useful for the user than for the system. Hence the file command.

The package manager

APT (Advanced Package Tool) is the default package manager on Debian. It is made of two components which are apt-get (high-level package manager used for dependency resolution) and dpkg (low-level package manager working under the hood). Most of the time we use apt-get.

Example commands:

Editing files

On the command-line, we can use Nano or Vi.

From the shell, let’s add “Hello World” to file1, then print the contents of file1 to the command line:

$ echo "Hello World" > file1
$ cat file1
Hello World

To open the file in Nano, type nano my_file.

User management

Each user has a unique id. Groups gather users with common access rights and privileges. Normal users start at 1000. All users are created with at least one group which id is equal to their uid.

The /etc/passwd file is organized as follows:

username:x:UID:GID:comment:home_directory:shell

How to search /etc/passwd for a specific user (here for user “root”):

$ grep root /etc/passwd
root:x:0:0:root:/root:/bin/bash

It is bad practice to use su to switch to root account. Instead, better use sudo on a user. This way, sudo privileges are granted to a specific user but only last for a specific command.

Every file is associated with a user and a group

Environment variables

Environment variables are specific variables used by the shell.

PS1 customize your prompt

SHELL default shell for the current user, usually bash

bash: history history of commands entered

history | tail show last 10

otherwise navigate using up/down arrow keys

Ctrl+R: search in history of past commands

Tab: autocomplete

Manipulating files

cat short for concatenate

$ cat readme.txt

main purpose is to concatenate multiple files together

Some files are very large. Opening the file in an editor may consume too much memory. Using less allows to load page by page, not saturating the memory along with head and tail.

$ tail -15 somefile.log
$ tail -f somefile.log

tail -f continuously monitors new lines in the log file and displays them in stdout

Text utilities

Streams and pipes

Standard streams are communication channels between a computer program and its environment. When we launch a Linux command, three data streams are created:

• stdin: standard input
• stdout: standard output
• stderr: standard error

When a command is executed via a shell, the streams are connected to the terminal on which the shell is running.

Streams can be directed and changed using > and <:

$ do_something < input_file
$ do_something > output_file
$ do_something 2> output_file

Programs can be chained together, where the stdout of the previous program is the stdin of the next:

$ command_1 | command_2 | command_3

When several commands are chained together, each command does not have to wait for the previous command to finish before starting.

Searching for files:

Processes

Some clarification around the terminology:

• a program is an executable sequence of instructions
• a process is the running instance of a program
• a thread is a lightweight process
• a service is process running in the background

A process can run one or several threads, and can also run other processes.

There are two main commands to monitor processes:

A process can be defined by:

• ID type
• Description
• Process ID (PID)
• Unique Process ID number
• Parent Process ID (PPID)
• PID of the parent process
• Thread ID (TID)
• Thread ID number

For single-threaded processes, TID=PID. For multi-threaded processes, each thread shares the same PID but has a unique TID. To terminate a process: kill -SIGKILL <pid>. You can only terminate your own processes (unless you are root). Processes have priorities (their nice value, the lower the higher the priority). The “niceness” of a process is its priority. You can can change the niceness of a process from the CLI via renice command.

Cron

Cron makes it possible to launch background jobs at specific times.

We can schedule tasks by editing the crontab file (for cron table). We can access the crontab file by typing `crontab -e` (“crontab edit”). There are both system-wide and user-specific crontab files.

Cron instructions follow a specific format made of 6 fields:

Example of cron schedule expression to run script.sh everyday at 1AM:

0 1 * * * /path/to/my/script.sh

Networks

A network is a group of computers connected together via communication channels. Each device has an IP address (unique logical network address). A DNS converts a hostname into an IP address.

An IPv4 address is dividend into 4 bytes:

• class A network address: first octet as Net ID, other 3 as Host ID max 126 class A. Classes A go from 1.0.0.0 to 127.255.255.255 (i.e. 16.7m unique hosts)
• classes B and C were added later: class b: 2 bits 65k unique hosts class c network addresses: first 3 octets as NET ID, last as host ID 2.1m available. Classes C go from 192.0.0.0 to 223.255.255.255

Home network only has 1 IP address. Within the network, you can assign IPs to connected devices either statically or dynamically (DHCP).

NAT = Network Address Translation, allows to share 1 IP address among many locally connected computers, each of which has a unique address only seen on the local network. In a home network, the router acts as a NAT.

Important files:

Network interfaces are points of connection between a computer and a network.

References:

• https://youtu.be/sWbUDq4S6Y8

Partitioning

Before we dive into Quicksort, we need to understand what is partitioning. Given an array of \(n\) elements, we pick one element that will serve as pivot and place all the smaller elements on its left and all the bigger elements on its right. By doing so, we position the pivot where it should be.

In the following example, we consider an unordered array of integers from 1 to 10. We choose the first value as the pivot. We then rearrange the array so that the smaller values are on its left and the bigger values are on its right.

Partitioning a list of integers using its first element as the pivot.

Note that when moving smaller and bigger elements, their relative order may change: we say that Quicksort is not stable. In contrast, a stable sorting algorithm would preserve the relative order of equal elements in the sorted output.

A simple way to partition would be to initialize three subsets, loop through the array and allocate each element to the correct subset. Such a function would do the job but would not be memory-efficient since it would use three intermediary lists and return the partitioned array in a new list.

As you have probably guessed, we can be smarter than that and partition the array in-place, that is without creating new lists. To do so, we traverse the array once and swap elements so that all elements smaller than the pivot end up “towards the left” and all the elements bigger than the pivot end up “towards the right”. We then put the pivot value at its correct position.

def partition(array: list) -> None:
    """
    In-place partitioning using the first element as the pivot.
    """

    # Choose the first element as the pivot
    pivot = array[0]

    # `index` keeps track of the smaller subset
    # We initialize it with 1
    index = 1

    # Loop through the values (starting after the pivot)
    for i in range(1, len(array)):

        # If we find a value smaller than the pivot,
        # swap it with the current next element
        # after the "smaller" subset
        if array[i] < pivot:
            array[i], array[index] = array[index], array[i]
            index += 1

    # At this stage, `index - 1` represents the last
    # value in the smaller subset; swap it with the pivot
    # This way the pivot is placed just after the smaller subset
    array[0], array[index - 1] = array[index - 1], array[0]

Quicksort

Quicksort works by recursively partitioning the “smaller” and “bigger” subsets. By doing so, we place each pivot at its correct position given the subset we are in, then process the new “smaller” and “bigger” subsets, etc.

Let us now implement Quicksort using in-place partitioning. For that, we need to modify our partition() function. Since the function will be used on different subsets of a same list, we need to add a start and an end to its signature so that it knows where to start and where to stop. This way, the same function can operate on different segments of a same list from different layers of the call stack. We also need to have it return the position of the pivot: this way, we can call it again on the “smaller” subset (i.e. up until the pivot position) and on the “bigger” subset (i.e. from the pivot position until the end).

We can rewrite it as below:

def partition(array: list, start: int, end: int) -> int:
    """
    In-place partitioning using the first element as the pivot.
    """

    # Choose the first element as the pivot
    pivot = array[start]

    # `index` keeps track of the smaller subset
    # We initialize it with start + 1
    index = start + 1

    # Loop through the values (starting after the pivot)
    for i in range(start + 1, end):

        # If we find a value smaller than the pivot,
        # swap it with the current next element
        # after the "smaller" subset
        if array[i] < pivot:
            array[i], array[index] = array[index], array[i]
            index += 1

    # At this stage, `index - 1` represents the last
    # value in the smaller subset; swap it with the pivot
    # This way the pivot is placed just after the smaller subset
    array[start], array[index - 1] = array[index - 1], array[start]

    # Return the index of the pivot
    return index - 1

Finally, we can write the Quicksort algorithm as below:

def quicksort(array: list, start: int, end: int) -> None:
    """
    In-place Quicksort implementation.
    """

    # Base condition
    if start < end:

        # Partition a given subset of the array
        # and store the position of the pivot
        pivot = partition(array, start, end)

        # Recursive call on the "smaller" subset
        quicksort(array, start, pivot)

        # Recursive call on the "bigger" subset
        quicksort(array, pivot + 1, end)

The base condition of our recursive algorithm is that it only runs when start is strictly less than end. The reason for that is: when we reach a subset of 1 element, the partitioning function will not do anything and return the position of the pivot, which is equal to start. At this point the next two calls to quicksort() further up the call stack will return nothing, and ultimately this branch of recursion will be closed.

Complexity analysis

Let’s first look at the time complexity. On average, the number of times the array will be divided into subsets is \(log(n)\), and at each pass we traverse the whole array, which takes \(n\) operations. The average time complexity is therefore \(O(n log(n))\).

The worst time complexity happens when the array is already sorted. In that case, each pair of subset will be of type \([ 1 : n-1 ]\) and the array will have to be partitioned \(n\) times. The worst-case time complexity is therefore \(O(n2)\).

When it comes to space complexity analysis, there are two things to consider: the actual memory used for variables and the memory used by the call stack. Regarding the first one, Quicksort’s footprint is minimal since we swap all elements in-place (complexity of \(O(1)\)). Regarding the call stack though, the space complexity is on average \(O(log(n))\) since we need to divide the array \(log(n)\) times, and it can be \(O(n)\) in the worst case.

Conclusion

In this article we presented the Quicksort algorithm along with its recursive Python implementation. Quicksort is time-efficient due to partitioning and space-efficient due to the partitioning being done in-place.

There is some flexibility with the algorithm: so far we have always selected the first element of the list as pivot, but it is possible to choose the last element, the middle element, a random element, etc. In fact, choosing a random element usually mitigates the risk of encountering a worst-case scenario.

As usual with sorting algorithms, the best algorithm is the one most suited for the data. Although Quicksort is often the fastest algorithm, it can’t beat good old BubbleSort on an already-sorted list for instance (but then again, who would want to sort a sorted list 🤔?).

References:

• https://me.dt.in.th/page/quicksort/
• https://www.enjoyalgorithms.com/blog/quick-sort-algorithm
• https://cs.stackexchange.com/questions/144424/stability-of-quicksort-algorithm
• https://stackoverflow.com/questions/18262306/quicksort-with-python

After a bit of browsing where I revisited Hugo and a few other systems, I stumbled upon Ghost and decided to give it a try. Ghost is an open-source publishing platform written in JavaScript (Node.js) with built-in newsletter and subscription functionalities. It also boasts a powerful online editor to write posts directly from the browser. You can either host it on your own or use the paid managed hosting. Since I enjoy making my life more complicated, I thought I would setup an instance myself using a micro AWS EC2.

The official Ghost documentation assumes you’re using MySQL as a database. After several installation attempts, I found that MySQL was consistently bringing my EC2 micro instance to its knees: the CPU would spike, memory would saturate and the instance would become unresponsive. From there, I could either run Ghost on a more powerful (but more costly) EC2 instance type, or switch the default database for SQLite. Because the static website was to be served by CloudFront, the database would never be a bottleneck so I chose to replace MySQL with SQLite. As a bonus point, backups became trivial: all I had to do was to copy the whole Ghost folder including the SQLite file into an S3 bucket. And when I finally completed the installation and SSH’ed into the EC2, there it was, the Ghost in the shell.

Installation

This guide assumes some familiarity with the AWS ecosystem. As usual, I am not giving exact instructions since the AWS interface tends to change quickly, but the main principles should remain the same. One thing to remember: when creating resources in AWS, always ensure you’re in the correct region (top-right corner of the screen).

Start by creating a Virtual Private Cloud. The VPC provides essential networking infrastructure and ensures your EC2 instance runs in a secured, dedicated environment within AWS. Then set up a Security Group. The Security Group acts as a virtual firewall for the EC2 instance. Make sure the Security Group allows SSH (port 22), HTTP (port 80) and HTTPS (port 443) so the EC2 can be accessed from the web. Then go to the EC2 dashboard and launch a new t2.micro instance with an Ubuntu Amazon Machine Image (AMI). Attach the instance to the VPC and the Security Group. Generate a SSH key pair and download the .pem file. The instance is now accessible, but its IP will change every time it stops and starts. To prevent this, assign an Elastic IP to your EC2 instance. You can now connect to your instance using the SSH key generated earlier as well as the Elastic IP. Note that the default username is usually ubuntu:

ssh -i /path/to/your-key.pem ubuntu@your-elastic-ip

Following the official Ghost installation guide, install Ghost onto your EC2 instance but use SQLite instead of MySQL to avoid the resource overload described before. Register a custom domain name for your blog in Route 53 and create a Hosted Zone with the necessary DNS records. In particular, create a A record pointing the domain to the Elastic IP of the EC2 instance. This will direct traffic from the domain to the blog. We now need to setup the DNS using CloudFront, but to do so we need an HTTPS certificate. Using AWS Certificate Manager (ACM), request a free SSL certificate for your domain and validate it via DNS using Route 53. This will enable HTTPS traffic to your blog. Now you can setup a CloudFront distribution of your glob using the EC2 Elastic IP as the origin, the ACM certificate for HTTPS and leave the default cache behavior.

Finally, update Ghost configuration by editing config.production.json to set your domain, enable HTTPS and configure SQLite as the database. You can now access your blog via https://yourblog.com. Optionally, you can setup a CloudWatch to monitor the EC2 performance and alert for high resource usage or downtime.

Additionals scripts

I wanted to have a regular backup of the blog into an S3 bucket. To do so, I created a custom bucket named backup.myblog.com and added the below script in /var/local/. This script copies the whole Ghost folder including the SQLite file into a tarball and copies it to the S3 bucket.

# backup.sh

date=$(date +"%Y-%m-%d")
filename=$date.backup.myblog.com.tar.gz
source=/var/www/myblog/content
local_dest=/var/backups
remote_dest=s3://backup.myblog.com
tar -czf $local_dest/$filename $source
aws s3 cp $local_dest/$filename $remote_dest
rm $local_dest/$filename

Ghost also needs some help to purge unused images (images that used to be inserted in a post but are not anymore following some editing). This feature is not available within Ghost so you have to rely on a third-party script named ghost-purge-images and available as an NPM package. This script requires access keys that have to be generated from the Ghost interface. Get the API keys, install the NPM package and add the below script in /var/local as well:

# purge.sh

ghost-purge-images purge --content-key=XXX --admin-key=XXX

Now you should see both scripts in /var/local/:

cd /var/local
ls

backup.sh purge.sh

Finally, to automate the tasks, simply sudo into the crontab and add the lines below.

sudo crontab -u root -e

0 1 * * * /var/local/backup.sh
0 1 * * * /var/local/purge.sh

It is now time to learn how to traverse a connected graph. In this post, we introduce the Breadth-First Search (BFS) and the Depth-First Search (DFS) algorithms. BFS progresses layer by layer, listing all the children of a given node. In contrast, DFS would delve deep into a given branch all the way to the leaf before backtrackig and exploring the next branch. We can run a BFS or a DFS on either an adjacency list or an adjacency matrix.

Example

In this article we will consider the example graph below to explain BFS and DFS.

Figure 1: example connected tree

Let us build this graph as an adjacency list using Python:

from collections import defaultdict

# Input
edges = [["A", "B"], ["A", "C"], ["B", "D"], ["B", "E"], ["C", "F"], ["C", "G"]]

# Build adjacency list
graph = defaultdict(list)
for edge in edges:
    graph[edge[0]].append(edge[1])
    graph[edge[1]].append(edge[0])

BFS algorithm

Let us look at the below graph to understand how BFS works: from a given starting node, we list all the children. We then explore each child, and for each one of them, we list all its children. We then move another level down, etc.

Figure 2: visual overview of the BFS algorithm

In the above example, starting from A we list B and C. Moving to B, we list D and E. Moving to C, we list F and G. Moving to D, E, F and finally G, we realize they are leaf nodes so we don’t list anything. When the list is empty, the algorithm stops.

Figure 1 is acyclic, but BFS needs to be able to explore cyclic graphs without getting trapped into infinite loops. To do so, we maintain a list of visited nodes and only add unvisited nodes to the “next nodes” list.

To implement BFS, we use a queue data structure (deque object in Python).

from collections import deque

AdjacencyList = dict[set]

def bfs(graph: AdjacencyList, node: int) -> None:
    visited = set()
    queue = deque()
    queue.append(node)

    while queue:
        node = queue.popleft()
        if node not in visited:
            visited.add(node)
            print(f"{node}:", end=" ")

            neighbors = graph[node]
            for neighbor in neighbors:
                if neighbor not in visited:
                    queue.append(neighbor)

Let us run the code on our example to see the order in which the nodes were explored:

A B C D E F G

What we do with BFS is very versatile: we can use BFS to explore all connected nodes, or to look for a specific node. We can use it to add edges etc.

DFS algorithm

Iterative implementation

Graphs come in all shapes and forms. This post introduces five key properties to describe and categorize them: direction, weight, cyclicity, connectivity and density.

Table of contents:

• Directed and undirected graphs
• Weighted and unweighted graphs
• Connecting the dots
• Cyclic and acyclic graphs
• Connected and disconnected graphs
• Density
• Trees
• Conclusion

Directed and undirected graphs

In a directed graph, edges indicate a one-way relationship between nodes. Each edge has a specific direction. In other words:

\[ edge(A,B)≠edge(B,A) \]

Some edges in a directed graph can be bi-directional. In Figure 2 for instance, the edge between nodes A and C is bi-directional. A directed graph where all edges are bi-directional becomes an undirected graph.

Examples of directed graphs include followers in a social network, city maps and corporate holdings. In a social network like Instagram, if Alice follows Bob, it does not mean that Bob follows Alice. In a city, some streets can be only one-way. Regarding corporate holdings, if company A owns company B, it does not mean that company B owns company A.

Figure 1: an example of undirected graph

In an undirected graph, nodes are linked together but edges do not have a direction. If node A is linked to node B, then node B is also linked to node A. Edges are symmetric, they model two-way relationships and can be traversed in either direction. In other words:

\[ edge(A,B)=edge(B,A) \]

Examples of undirected graphs include connections in a social network and molecular structures. In a social network, if Alice is connected to Bob then Bob is in effect connected to Alice. In molecular structures, we can model atoms as nodes and bonds as edges.

Weighted and unweighted graphs

Unweighted graphs define connections but do not quantity these links. By convention, the weight of every edge in an unweighted graph is considered to be one. A weight of zero means no edge.

Typical examples of unweighted graphs include connections in a social network and hyperlinks between web pages. In a social network, connections between users simply exist or don’t exist, but they all have the same importance. Similarly, web pages are either linked or not linked, but each hyperlink is of similar importance (the number of links pointing to a web page, on the other hand, has value - it is the pillar of Google’s original PageRank algorithm).

In a weighted graph, each edge is given a numerical weight. This weight can represent a cost, a distance, a duration etc. Note that in a directed graph, the edge pointing from A to B can have a different value than the edge pointing from B to A.

We can model distances between cities or conversions between units as weighted graphs. The first example is useful to compute the classic traveling salesman problem. In the second example, each unit is a node and the conversion factors (if they exist) are modeled as directed weighted edges.

Connecting the dots

As you have probably understood by now, direction and weight are not mutually exclusive properties. For example, Figure 1 is both undirected and unweighted whereas Figure 3 is undirected but weighted.

Let’s summarize the four categories of graphs seen so far into a simple matrix. For each category, we give a real-life example expressed in the form edges between nodes:

Cyclic and acyclic graphs

A cycle is a non-empty path in which the first and the last nodes are equal. A graph containing at least one cycle is called cyclic.

Transportation networks and social networks usually exhibit cyclic properties. In a transportation network, trucks can move goods from A to B, then from B to C and back from C to A. In a social network, it can emerge that Alice follows Bob, Bob follows Carol and Carol follows Alice.

An acyclic graph does not have any cycle. When visiting the graph from node to node, one will never visit the same node twice.

In AirFlow, collections of tasks are defined as Directed Acyclic Graphs (or DAGs). It simply means that the tasks are linked together by edges that have a direction but do not form cycles. This way, we can specify an order of execution and avoid the formation of infinite loops.

Connected and disconnected graphs

We define a path as a sequence of edges. In a connected graph, there is a path between each node of the graph. For instance, the graph of a road network is usually connected since it’s unlikely that a road sits by itself away from all other roads.

In a disconnected graph: all nodes are not necessarily linked by a path. For example, constellations or archipelagos can be modeled using disconnected graphs.

Density

The maximal number of edges in an undirected graph of \(n\) nodes is \(n∗(n−1)/2\). Logically, in a directed graph, it is \(n∗(n−1)\) edges.

We can therefore describe graphs by their density:

Trees

A tree is a connected acyclic graph.

In a tree, edges are named branches and nodes without children are called leaf nodes. In computer science, trees are also defined by the existence of a root (i.e. a starting node) and are usually assumed to be directed. For instance, in Figure 6, node A is the root and nodes D, E, F and G are leaf nodes.

A disconnected acyclic graph, i.e. a collection of trees, is called a forest.

An example of tree structure that you probably use everyday is the file system, where each directory is a node. The Document Object Model (DOM) is also a tree. Other examples of trees include family trees and decision trees.

Conclusion

In this article we have reviewed the basic properties used to describe a graph. By now you should be familiar with the notions of direction, weight, cycles, connectivity and density. These properties are not mutually exclusive: a graph can be directed, unweighted, acyclic and connected but sparse for instance.

Ordinary graphs can be generalized into more abstract structures such as multigraphs (where two nodes can be linked by more than one or two edges) and hypergraphs (where an edge is an area linking an arbitrary number of nodes).

In the next post we will look at how to model ordinary graphs using Python.