Update content for md

39 files changed, 592 insertions, 23 deletions

diff --git a/gemfeed/2008-06-26-perl-poetry.md b/gemfeed/2008-06-26-perl-poetry.md
index 9d6c6c02..0de1bdaf 100644
--- a/gemfeed/2008-06-26-perl-poetry.md
+++ b/gemfeed/2008-06-26-perl-poetry.md
@@ -25,6 +25,17 @@ _~~|~/_|_|__/|~~~~~~~ |  / ~~~~~ |   | ~~~~~~~~
                     (__)         (____)
 ```
 
+## Table of Contents
+
+* [⇢ Perl Poetry](#perl-poetry)
+* [⇢ ⇢ Introduction](#introduction)
+* [⇢ ⇢ math.pl](#mathpl)
+* [⇢ ⇢ christmas.pl](#christmaspl)
+* [⇢ ⇢ shopping.pl](#shoppingpl)
+* [⇢ ⇢ More...](#more)
+
+## Introduction
+
 Here are some Perl Poems I wrote. They don't do anything useful when you run them, but they don't produce a compiler error either. They only exist for fun and demonstrate what you can do with Perl syntax.
 
 Wikipedia: "Perl poetry is the practice of writing poems that can be compiled as legal Perl code, for example the piece known as Black Perl. Perl poetry is made possible by the large number of English words that are used in the Perl language. New poems are regularly submitted to the community at PerlMonks."
diff --git a/gemfeed/2011-05-07-perl-daemon-service-framework.md b/gemfeed/2011-05-07-perl-daemon-service-framework.md
index 183a3de1..e393a1ea 100644
--- a/gemfeed/2011-05-07-perl-daemon-service-framework.md
+++ b/gemfeed/2011-05-07-perl-daemon-service-framework.md
@@ -9,6 +9,22 @@
       //\ //\\   //\ //\\       //\ //\\jrei
 ```
 
+## Table of Contents
+
+* [⇢ Perl Daemon (Service Framework)](#perl-daemon-service-framework)
+* [⇢ ⇢ Introduction](#introduction)
+* [⇢ ⇢ Features](#features)
+* [⇢ ⇢ Quick Guide](#quick-guide)
+* [⇢ ⇢ How to configure](#how-to-configure)
+* [⇢ ⇢ Example ](#example-)
+* [⇢ ⇢ HiRes event loop](#hires-event-loop)
+* [⇢ ⇢ Writing your own modules](#writing-your-own-modules)
+* [⇢ ⇢ ⇢ Example module](#example-module)
+* [⇢ ⇢ ⇢ Your own module](#your-own-module)
+* [⇢ ⇢ May the source be with you](#may-the-source-be-with-you)
+
+## Introduction
+
 PerlDaemon is a minimal daemon for Linux and other Unix like operating systems programmed in Perl. It is a minimal but pretty functional and fairly generic service framework. This means that it does not do anything useful other than providing a framework for starting, stopping, configuring and logging. To do something useful, a module (written in Perl) must be provided.
 
 ## Features
diff --git a/gemfeed/2016-04-09-jails-and-zfs-on-freebsd-with-puppet.md b/gemfeed/2016-04-09-jails-and-zfs-on-freebsd-with-puppet.md
index ff7e2413..3879df57 100644
--- a/gemfeed/2016-04-09-jails-and-zfs-on-freebsd-with-puppet.md
+++ b/gemfeed/2016-04-09-jails-and-zfs-on-freebsd-with-puppet.md
@@ -22,6 +22,17 @@
                \      `.
 ```
 
+## Table of Contents
+
+* [⇢ Jails and ZFS with Puppet on FreeBSD](#jails-and-zfs-with-puppet-on-freebsd)
+* [⇢ ⇢ Introduction](#introduction)
+* [⇢ ⇢ ZFS](#zfs)
+* [⇢ ⇢ Jails](#jails)
+* [⇢ ⇢ Inside-Jail Puppet](#inside-jail-puppet)
+* [⇢ ⇢ Managing multiple Jails](#managing-multiple-jails)
+
+## Introduction
+
 Over the last couple of years I wrote quite a few Puppet modules in order to manage my personal server infrastructure. One of them manages FreeBSD Jails and another one ZFS file systems. I thought I would give a brief overview in how it looks and feels.
 
 ## ZFS
diff --git a/gemfeed/2021-04-22-dtail-the-distributed-log-tail-program.md b/gemfeed/2021-04-22-dtail-the-distributed-log-tail-program.md
index ecfdcfd7..b0a2bf0f 100644
--- a/gemfeed/2021-04-22-dtail-the-distributed-log-tail-program.md
+++ b/gemfeed/2021-04-22-dtail-the-distributed-log-tail-program.md
@@ -4,6 +4,22 @@
 
 [![DTail logo image](./dtail-the-distributed-log-tail-program/title.png "DTail logo image")](./dtail-the-distributed-log-tail-program/title.png)  
 
+## Table of Contents
+
+* [⇢ DTail - The distributed log tail program](#dtail---the-distributed-log-tail-program)
+* [⇢ ⇢ Introduction](#introduction)
+* [⇢ ⇢ A Mimecast Pet Project](#a-mimecast-pet-project)
+* [⇢ ⇢ Differentiating from log management systems](#differentiating-from-log-management-systems)
+* [⇢ ⇢ Combining simplicity, security and efficiency](#combining-simplicity-security-and-efficiency)
+* [⇢ ⇢ The DTail family of commands](#the-dtail-family-of-commands)
+* [⇢ ⇢ Usage example](#usage-example)
+* [⇢ ⇢ Fitting it in](#fitting-it-in)
+* [⇢ ⇢ Advanced features](#advanced-features)
+* [⇢ ⇢ For the future](#for-the-future)
+* [⇢ ⇢ Open Source](#open-source)
+
+## Introduction
+
 This article first appeared at the Mimecast Engineering Blog but I made it available here in my personal internet site too.
 
 [Original Mimecast Engineering Blog post at Medium](https://medium.com/mimecast-engineering/dtail-the-distributed-log-tail-program-79b8087904bb)  
diff --git a/gemfeed/2021-04-24-welcome-to-the-geminispace.md b/gemfeed/2021-04-24-welcome-to-the-geminispace.md
index e8443ea3..27f82c24 100644
--- a/gemfeed/2021-04-24-welcome-to-the-geminispace.md
+++ b/gemfeed/2021-04-24-welcome-to-the-geminispace.md
@@ -30,6 +30,17 @@ However, if you still use HTTP, you are just surfing the fallback HTML version o
 
 ```
 
+## Table of Contents
+
+* [⇢ Welcome to the Geminispace](#welcome-to-the-geminispace)
+* [⇢ ⇢ Motivation](#motivation)
+* [⇢ ⇢ ⇢ My urge to revamp my personal website](#my-urge-to-revamp-my-personal-website)
+* [⇢ ⇢ ⇢ My still great Laptop running hot](#my-still-great-laptop-running-hot)
+* [⇢ ⇢ Discovering the Gemini internet protocol](#discovering-the-gemini-internet-protocol)
+* [⇢ ⇢ My own Gemini capsule](#my-own-gemini-capsule)
+* [⇢ ⇢ Gemini advantages summarised](#gemini-advantages-summarised)
+* [⇢ ⇢ Dive into deep Gemini space](#dive-into-deep-gemini-space)
+
 ## Motivation
 
 ### My urge to revamp my personal website
diff --git a/gemfeed/2021-05-16-personal-bash-coding-style-guide.md b/gemfeed/2021-05-16-personal-bash-coding-style-guide.md
index 1389be26..43b93229 100644
--- a/gemfeed/2021-05-16-personal-bash-coding-style-guide.md
+++ b/gemfeed/2021-05-16-personal-bash-coding-style-guide.md
@@ -15,6 +15,30 @@
 "\__/"---------------"\__/"-+---+'
 ```                     
 
+## Table of Contents
+
+* [⇢ Personal Bash coding style guide](#personal-bash-coding-style-guide)
+* [⇢ ⇢ Introduction](#introduction)
+* [⇢ ⇢ My modifications](#my-modifications)
+* [⇢ ⇢ ⇢ Shebang](#shebang)
+* [⇢ ⇢ ⇢ Two space soft-tabs indentation](#two-space-soft-tabs-indentation)
+* [⇢ ⇢ ⇢ Breaking long pipes](#breaking-long-pipes)
+* [⇢ ⇢ ⇢ Quoting your variables](#quoting-your-variables)
+* [⇢ ⇢ ⇢ Prefer built-in commands over external commands](#prefer-built-in-commands-over-external-commands)
+* [⇢ ⇢ My additions](#my-additions)
+* [⇢ ⇢ ⇢ Use of 'yes' and 'no'](#use-of-yes-and-no)
+* [⇢ ⇢ ⇢ Non-evil alternative to variable assignments via eval](#non-evil-alternative-to-variable-assignments-via-eval)
+* [⇢ ⇢ ⇢ Prefer pipes over arrays for list processing](#prefer-pipes-over-arrays-for-list-processing)
+* [⇢ ⇢ ⇢ Assign-then-shift](#assign-then-shift)
+* [⇢ ⇢ ⇢ Paranoid mode](#paranoid-mode)
+* [⇢ ⇢ Learned](#learned)
+* [⇢ ⇢ ⇢ Unintended lexicographical comparison.](#unintended-lexicographical-comparison)
+* [⇢ ⇢ ⇢ PIPESTATUS](#pipestatus)
+* [⇢ ⇢ Use common sense and BE CONSISTENT.](#use-common-sense-and-be-consistent)
+* [⇢ ⇢ Advanced Bash learning pro tip](#advanced-bash-learning-pro-tip)
+
+## Introduction
+
 Lately, I have been polishing and writing a lot of Bash code. Not that I never wrote a lot of Bash, but now as I also looked through the Google Shell Style Guide, I thought it is time also to write my thoughts on that. I agree with that guide in most, but not in all points. 
 
 [Google Shell Style Guide](https://google.github.io/styleguide/shellguide.html)  
diff --git a/gemfeed/2021-06-05-gemtexter-one-bash-script-to-rule-it-all.md b/gemfeed/2021-06-05-gemtexter-one-bash-script-to-rule-it-all.md
index 86878339..580aceab 100644
--- a/gemfeed/2021-06-05-gemtexter-one-bash-script-to-rule-it-all.md
+++ b/gemfeed/2021-06-05-gemtexter-one-bash-script-to-rule-it-all.md
@@ -43,11 +43,30 @@
                                                            `+a:f:......jrei'''
 ```
 
+## Table of Contents
+
+* [⇢ Gemtexter - One Bash script to rule it all](#gemtexter---one-bash-script-to-rule-it-all)
+* [⇢ ⇢ Introduction](#introduction)
+* [⇢ ⇢ ⇢ Motivation](#motivation)
+* [⇢ ⇢ Output formats](#output-formats)
+* [⇢ ⇢ Taking it as far as I should, but no farther](#taking-it-as-far-as-i-should-but-no-farther)
+* [⇢ ⇢ ⇢ Modularization ](#modularization-)
+* [⇢ ⇢ ⇢ Bash best practises and ShellCheck](#bash-best-practises-and-shellcheck)
+* [⇢ ⇢ ⇢ Unit testing](#unit-testing)
+* [⇢ ⇢ ⇢ HTML unit test example](#html-unit-test-example)
+* [⇢ ⇢ ⇢ Markdown unit test example](#markdown-unit-test-example)
+* [⇢ ⇢ Handcrafted HTML styles](#handcrafted-html-styles)
+* [⇢ ⇢ Configurability](#configurability)
+* [⇢ ⇢ Future features](#future-features)
+* [⇢ ⇢ Conclusion](#conclusion)
+
+## Introduction
+
 You might have read my previous blog posts about entering the Geminispace, where I pointed out the benefits of having and maintaining an internet presence there. This whole site (the blog and all other pages) is composed in the Gemtext markup language.
 
 This comes with the benefit that I can write content in my favourite text editor (Vim). 
 
-## Motivation
+### Motivation
 
 Another benefit of using Gemini is that the Gemtext markup language is easy to parse. As my site is dual-hosted (Gemini+HTTP), I could, in theory, just write a shell script to deal with the conversion from Gemtext to HTML; there is no need for a full-featured programming language here. I have done a lot of Bash in the past, but I am also often revisiting old tools and techniques for refreshing and keeping the knowledge up to date here.
 
diff --git a/gemfeed/2021-09-12-keep-it-simple-and-stupid.md b/gemfeed/2021-09-12-keep-it-simple-and-stupid.md
index 4948944f..35215a19 100644
--- a/gemfeed/2021-09-12-keep-it-simple-and-stupid.md
+++ b/gemfeed/2021-09-12-keep-it-simple-and-stupid.md
@@ -17,25 +17,45 @@
 --------------------                    --------------------
 ```
 
+## Table of Contents
+
+* [⇢ Keep it simple and stupid](#keep-it-simple-and-stupid)
+* [⇢ ⇢ Introduction](#introduction)
+* [⇢ ⇢ Need faster hardware](#need-faster-hardware)
+* [⇢ ⇢ Too complex to be replaced](#too-complex-to-be-replaced)
+* [⇢ ⇢ ⇢ On COBOL](#on-cobol)
+* [⇢ ⇢ ⇢ On Kubernetes](#on-kubernetes)
+* [⇢ ⇢ ⇢ The younger generation of IT professionals](#the-younger-generation-of-it-professionals)
+* [⇢ ⇢ The bloated web](#the-bloated-web)
+* [⇢ ⇢ Fancy log-management solutions](#fancy-log-management-solutions)
+* [⇢ ⇢ More KISS](#more-kiss)
+* [⇢ ⇢ ⇢ The Adslowbe PDF Reader](#the-adslowbe-pdf-reader)
+* [⇢ ⇢ ⇢ The power of plain text files](#the-power-of-plain-text-files)
+* [⇢ ⇢ ⇢ KISS for programmers](#kiss-for-programmers)
+* [⇢ ⇢ When KISS is not KISS anymore](#when-kiss-is-not-kiss-anymore)
+* [⇢ ⇢ Other relevant readings](#other-relevant-readings)
+
+## Introduction
+
 A robust computer system must be kept simple and stupid (KISS). The fancier the system is, the more can break. Unfortunately, most systems tend to become complex and challenging to maintain in today's world. In the early days, so I was told, engineers understood every part of the system, but nowadays, we see more of the "lasagna" stack. One layer or framework is built on top of another layer, and in the end, nobody has got a clue what's going on.
 
-# Need faster hardware
+## Need faster hardware
 
 This not just makes the system much more complex, difficult to maintain and challenging to troubleshoot, but also slow. So more experts are needed to support it. Also, newer and faster hardware is required to make it run smoothly. Often, it's so much easier to buy speedier hardware than rewrite a whole system from scratch from the bottom-up. The latter would require much more resources in the short run, but in the long run, it should pay off. Unfortunately, many project owners scare away from it as they only want to get their project done and then move on.
 
-# Too complex to be replaced
+## Too complex to be replaced
 
-## On COBOL
+### On COBOL
 
 Have a look at COBOL, a prevalent programming language of the past. No one is learning COBOL in college or university anymore, but many legacy systems still require COBOL experts. Why is this? It's just too scary to write everything from scratch. There's too much COBOL code out there that can't be replaced from today to tomorrow. 
 
 [https://nymag.com/intelligencer/2020/04/what-is-cobol-what-does-it-have-to-do-with-the-coronavirus.html](https://nymag.com/intelligencer/2020/04/what-is-cobol-what-does-it-have-to-do-with-the-coronavirus.html)  
 
-## On Kubernetes
+### On Kubernetes
 
 Now have a look at Kubernetes (k8s), the current trendy infrastructure thing to use nowadays. Of course, there are many benefits of using k8s (auto-scaling, reproducible deployments, dynamic resource allocation and resource sharing, saving of hardware costs, good commercial for potential employees as it is the current hot sauce of infrastructure). But all of this also comes with costs: You need experts operating the k8s cluster (or you need to pay extra for a managed cluster in the cloud), increased complexity of the system (k8s comes with a steep learning curve). The latter not only applies to the engineers managing the k8s cluster -  it also applies to the software engineers, who now have to develop 'cloud native' applications and, therefore, have to change how they developed software how they used to. They all need to be re-educated on what cloud-native means, and they also need to understand the key concepts of k8s for writing optimal software for it.
 
-## The younger generation of IT professionals
+### The younger generation of IT professionals
 
 Maybe the younger generation knows all of this already after graduation, but then they are missing other critical parts of the system for sure. I have seen engineers who knew about containers and how to configure resource restrictions for a Docker container managed via k8s but have never heard the terms Linux control groups and Linux namespaces. So obviously, there is some knowledge gap of the underlying architecture. This can be a big problem when you have to troubleshoot such a system during a production incident and k8s adds a lot of abstraction to the mix which doesn't make it easier. 
 
@@ -51,7 +71,7 @@ And here is something to smile about:
 
 [https://christine.website/blog/theres-a-node-2021-10-02](https://christine.website/blog/theres-a-node-2021-10-02)  
 
-# The bloated web
+## The bloated web
 
 Another example is the modern web. Have you ever wondered why the internet becomes slower and slower nowadays? The modern web is so much like lasagna that I decided to use Gemini to be the primary protocol of my website. The HTML version of this website is just a fallback as many visitors don't know what Gemini is and don't have any compatible software installed for surfing the Geminispace:
 
@@ -59,7 +79,7 @@ Another example is the modern web. Have you ever wondered why the internet becom
 
 The Gemtext protocol is KISS. There's no way to do other formattings than headings, links, paragraphs, lists, quotes, and bare text blocks (e.g., ASCII art or code snippets). There's no way to create bloated Gemini sites, and due to its limited capabilities, there's also no way to commercialise it (e.g. there's no good way to track the site visitors as things like cookies don't exist). By design, the Gemini protocol can't be extended, so there is no chance to abuse it even in the future. Gemini sites will stay KISS forever, and there won't be any fancy HTML/JavaScript frameworks like we see on the modern web.
 
-# Fancy log-management solutions
+## Fancy log-management solutions
 
 Yet another example I want to bring up is DTail, the distributed log tail program I wrote. There are many great and fancy log-management solutions available to choose from, and they all seem complex to set up and maintain. The ELK stack, for example, requires you to operate an ElasticSearch cluster (or multiple, if you are geo-redundant), Logstash (different configurations and instances, depending on your infrastructure) and a Kibana web-frontend (which also needs to be highly available). I have operated ElasticSearch clusters on multiple occasions, and I must say that it is not an easy task to optimise it for the particular workload you might encounter. I also have seen many ES clusters operated by other people, and I have seen these clusters failing a lot (so it's not just me). The reduced complexity of DTail also makes it more robust against outages. You won't troubleshoot your distributed application very well if the log management infrastructure isn't working either.
 
@@ -67,23 +87,23 @@ Yet another example I want to bring up is DTail, the distributed log tail progra
 
 I don't say that the ELK stack doesn't work, but it requires experts and additional hardware resources to support it. But instead, if you keep your infrastructure simple (e.g. only use DTail), it will maintain pretty much by itself. 
 
-# More KISS
+## More KISS
 
-## The Adslowbe PDF Reader
+### The Adslowbe PDF Reader
 
 Another perfect example is the Adobe PDF reader. How can it be that the inventor of the PDF format creates such a terrible user experience with its official reader? The reader is awful bloated, and slow. There are much better alternatives around (especially for Linux and other UNIX like operating systems, look at Zathura for example). I believe the reason Adobe's reader is like this is featuritis, and 90% of the users don't use 90% of all available features. Less is more; keep it simple and stupid. 
 
-## The power of plain text files
+### The power of plain text files
 
 Speaking of file formats, never underestimate the power of plain text files.  Plain text files don't require any special software to be opened, and they outlive the software which created them in the first place. You will still be able to read a plain text file on a modern computer system ten (or twenty) years from now, but you probably won't be able to read such an old version of an Adobe Photoshop image file if the software required for reading that format isn't supported anymore and doesn't run anymore on modern computers.
 
-## KISS for programmers
+### KISS for programmers
 
 Not to mention, keeping things simple and stupid also reduces the potential malicious attack surface. It's not just about the software and services you use and operate. It's also about the software you write. Here is a nice article about the KISS principle in software development:
 
 [https://thevaluable.dev/kiss-principle-explained/](https://thevaluable.dev/kiss-principle-explained/)  
 
-# When KISS is not KISS anymore
+## When KISS is not KISS anymore
 
 There is, however, a trap. The more you spend time with things, the more these things feel natural to you and you become an expert. The more you become an expert, the more you introduce more abstractions and other clever ways of doing things. For you, things seem to be KISS still, but another person may not be an expert and might not understand what you do. One of the fundamental challenges is to keep things really KISS. You might add abstraction upon abstraction to a system and don't even notice it until it is too late.
 
diff --git a/gemfeed/2021-11-29-bash-golf-part-1.md b/gemfeed/2021-11-29-bash-golf-part-1.md
index 062a7cfd..d0e4fb26 100644
--- a/gemfeed/2021-11-29-bash-golf-part-1.md
+++ b/gemfeed/2021-11-29-bash-golf-part-1.md
@@ -14,6 +14,21 @@ jgs^^^^^^^`^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                                             Art by Joan Stark
 ```
 
+## Table of Contents
+
+* [⇢ Bash Golf Part 1](#bash-golf-part-1)
+* [⇢ ⇢ Introduction](#introduction)
+* [⇢ ⇢ TCP/IP networking](#tcpip-networking)
+* [⇢ ⇢ Process substitution](#process-substitution)
+* [⇢ ⇢ Grouping](#grouping)
+* [⇢ ⇢ Expansions](#expansions)
+* [⇢ ⇢ - aka stdin and stdout placeholder](#--aka-stdin-and-stdout-placeholder)
+* [⇢ ⇢ Alternative argument passing](#alternative-argument-passing)
+* [⇢ ⇢ : aka the null command](#-aka-the-null-command)
+* [⇢ ⇢ (No) floating point support](#no-floating-point-support)
+
+## Introduction
+
 This is the first blog post about my Bash Golf series. This series is about random Bash tips, tricks and weirdnesses I came across. It's a collection of smaller articles I wrote in an older (in German language) blog, which I translated and refreshed with some new content.
 
 [2021-11-29 Bash Golf Part 1 (You are currently reading this)](./2021-11-29-bash-golf-part-1.md)  
diff --git a/gemfeed/2022-01-01-bash-golf-part-2.md b/gemfeed/2022-01-01-bash-golf-part-2.md
index e7d11702..5f6df763 100644
--- a/gemfeed/2022-01-01-bash-golf-part-2.md
+++ b/gemfeed/2022-01-01-bash-golf-part-2.md
@@ -14,6 +14,20 @@ jgs^^^^^^^`^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                         Art by Joan Stark, mod. by Paul Buetow
 ```
 
+## Table of Contents
+
+* [⇢ Bash Golf Part 2](#bash-golf-part-2)
+* [⇢ ⇢ Introduction](#introduction)
+* [⇢ ⇢ Redirection](#redirection)
+* [⇢ ⇢ HERE](#here)
+* [⇢ ⇢ RANDOM](#random)
+* [⇢ ⇢ set -x and set -e and pipefile](#set--x-and-set--e-and-pipefile)
+* [⇢ ⇢ ⇢ -x](#-x)
+* [⇢ ⇢ ⇢ -e](#-e)
+* [⇢ ⇢ ⇢ pipefail](#pipefail)
+
+## Introduction
+
 This is the second blog post about my Bash Golf series. This series is random Bash tips, tricks and weirdnesses I came across. It's a collection of smaller articles I wrote in an older (in German language) blog, which I translated and refreshed with some new content.
 
 [2021-11-29 Bash Golf Part 1](./2021-11-29-bash-golf-part-1.md)  
diff --git a/gemfeed/2022-03-06-the-release-of-dtail-4.0.0.md b/gemfeed/2022-03-06-the-release-of-dtail-4.0.0.md
index eb50d81a..2474830e 100644
--- a/gemfeed/2022-03-06-the-release-of-dtail-4.0.0.md
+++ b/gemfeed/2022-03-06-the-release-of-dtail-4.0.0.md
@@ -16,6 +16,26 @@
                          |                           |
 ```
 
+## Table of Contents
+
+* [⇢ The release of DTail 4.0.0](#the-release-of-dtail-400)
+* [⇢ ⇢ Introduction](#introduction)
+* [⇢ ⇢ So, what's new in 4.0.0?](#so-whats-new-in-400)
+* [⇢ ⇢ ⇢ Rewritten logging](#rewritten-logging)
+* [⇢ ⇢ ⇢ Configurable terminal color codes](#configurable-terminal-color-codes)
+* [⇢ ⇢ ⇢ Serverless mode](#serverless-mode)
+* [⇢ ⇢ ⇢ Shorthand flags](#shorthand-flags)
+* [⇢ ⇢ ⇢ Spartan (aka plain) mode](#spartan-aka-plain-mode)
+* [⇢ ⇢ ⇢ Standard input pipe](#standard-input-pipe)
+* [⇢ ⇢ ⇢ New command dtailhealth](#new-command-dtailhealth)
+* [⇢ ⇢ ⇢ Improved documentation](#improved-documentation)
+* [⇢ ⇢ ⇢ Integration testing suite](#integration-testing-suite)
+* [⇢ ⇢ ⇢ Improved code](#improved-code)
+* [⇢ ⇢ ⇢ Use of memory pools](#use-of-memory-pools)
+* [⇢ ⇢ What's next](#whats-next)
+
+## Introduction
+
 I have recently released DTail 4.0.0 and this blog post goes through all the new goodies. If you want to jump directly to DTail, do it here (there are nice animated gifs which demonstrates the usage pretty well):
 
 [https://dtail.dev](https://dtail.dev)  
diff --git a/gemfeed/2022-05-27-perl-is-still-a-great-choice.md b/gemfeed/2022-05-27-perl-is-still-a-great-choice.md
index e56858e6..2849a07f 100644
--- a/gemfeed/2022-05-27-perl-is-still-a-great-choice.md
+++ b/gemfeed/2022-05-27-perl-is-still-a-great-choice.md
@@ -4,6 +4,18 @@
 
 [![Comic source: XKCD](./perl-is-still-a-great-choice/regular_expressions.png "Comic source: XKCD")](./perl-is-still-a-great-choice/regular_expressions.png)  
 
+## Table of Contents
+
+* [⇢ Perl is still a great choice](#perl-is-still-a-great-choice)
+* [⇢ ⇢ Introduction](#introduction)
+* [⇢ ⇢ Write-only language](#write-only-language)
+* [⇢ ⇢ Is Perl abandoned?](#is-perl-abandoned)
+* [⇢ ⇢ Why use Perl as there are better alternatives?](#why-use-perl-as-there-are-better-alternatives)
+* [⇢ ⇢ Why all the sigils? It looks like an exploding ASCII factory!!](#why-all-the-sigils-it-looks-like-an-exploding-ascii-factory)
+* [⇢ ⇢ Where do I personally still use perl?](#where-do-i-personally-still-use-perl)
+
+## Introduction
+
 Perl (the Practical Extraction and Report Language) is a battle-tested, mature, multi-paradigm dynamic programming language. Note that it's not called PERL, neither P.E.R.L. nor Pearl. "Perl" is the name of the language and `perl` the name of the interpreter or the interpreter command.
 
 Unfortunately (it makes me sad), Perl's popularity has been declining over the last years as Google trends shows:
diff --git a/gemfeed/2022-07-30-lets-encrypt-with-openbsd-and-rex.md b/gemfeed/2022-07-30-lets-encrypt-with-openbsd-and-rex.md
index b25f8669..409223fe 100644
--- a/gemfeed/2022-07-30-lets-encrypt-with-openbsd-and-rex.md
+++ b/gemfeed/2022-07-30-lets-encrypt-with-openbsd-and-rex.md
@@ -29,9 +29,28 @@
                                  ASCII Art by John Savard
 ```
 
+## Table of Contents
+
+* [⇢ Let's Encrypt with OpenBSD and Rex](#lets-encrypt-with-openbsd-and-rex)
+* [⇢ ⇢ Introduction](#introduction)
+* [⇢ ⇢ ⇢ What's Let's Encrypt?](#whats-lets-encrypt)
+* [⇢ ⇢ Meet `acme-client`](#meet-acme-client)
+* [⇢ ⇢ Configuration](#configuration)
+* [⇢ ⇢ ⇢ acme-client.conf](#acme-clientconf)
+* [⇢ ⇢ ⇢ httpd.conf](#httpdconf)
+* [⇢ ⇢ ⇢ CRON job](#cron-job)
+* [⇢ ⇢ relayd.conf and smtpd.conf](#relaydconf-and-smtpdconf)
+* [⇢ ⇢ Rexification](#rexification)
+* [⇢ ⇢ ⇢ General ACME client configuration](#general-acme-client-configuration)
+* [⇢ ⇢ ⇢ Service rexification ](#service-rexification-)
+* [⇢ ⇢ All pieces together](#all-pieces-together)
+* [⇢ ⇢ Conclusion](#conclusion)
+
+## Introduction
+
 I was amazed at how easy it is to automatically generate and update Let's Encrypt certificates with OpenBSD.
 
-## What's Let's Encrypt?
+### What's Let's Encrypt?
 
 > Let's Encrypt is a non-profit certificate authority run by Internet Security Research Group that provides X.509 certificates for Transport Layer Security (TLS) encryption at no charge. It is the world's largest certificate authority, used by more than 265 million websites, with the goal of all websites being secure and using HTTPS.
 
diff --git a/gemfeed/2022-08-27-gemtexter-1.1.0-lets-gemtext-again.md b/gemfeed/2022-08-27-gemtexter-1.1.0-lets-gemtext-again.md
index 358c5866..5a1c9ad0 100644
--- a/gemfeed/2022-08-27-gemtexter-1.1.0-lets-gemtext-again.md
+++ b/gemfeed/2022-08-27-gemtexter-1.1.0-lets-gemtext-again.md
@@ -14,6 +14,22 @@
  jgs  `"""""""""`
 ```
 
+## Table of Contents
+
+* [⇢ Gemtexter 1.1.0 - Let's Gemtext again](#gemtexter-110---lets-gemtext-again)
+* [⇢ ⇢ Introduction](#introduction)
+* [⇢ ⇢ What's new?](#whats-new)
+* [⇢ ⇢ ⇢ Automatic check for GNU version requirements](#automatic-check-for-gnu-version-requirements)
+* [⇢ ⇢ ⇢ Backticks now produce `inline code blocks` in the HTML output](#backticks-now-produce-inline-code-blocks-in-the-html-output)
+* [⇢ ⇢ ⇢ Cache for Atom feed generation](#cache-for-atom-feed-generation)
+* [⇢ ⇢ ⇢ Input filter support](#input-filter-support)
+* [⇢ ⇢ ⇢ Revamped `git` support](#revamped-git-support)
+* [⇢ ⇢ ⇢ Addition of `htmlextras` and web font support](#addition-of-htmlextras-and-web-font-support)
+* [⇢ ⇢ ⇢ Sub-section support](#sub-section-support)
+* [⇢ ⇢ ⇢ More](#more)
+
+## Introduction
+
 I proudly announce that I've released Gemtexter version `1.1.0`. What is Gemtexter? It's my minimalist static site generator for Gemini Gemtext, HTML and Markdown written in GNU Bash.
 
 [https://codeberg.org/snonux/gemtexter](https://codeberg.org/snonux/gemtexter)  
diff --git a/gemfeed/2022-10-30-installing-dtail-on-openbsd.md b/gemfeed/2022-10-30-install