Update content for md

12 files changed, 727 insertions, 2 deletions

diff --git a/gemfeed/2008-06-26-perl-poetry.md b/gemfeed/2008-06-26-perl-poetry.md
index 3f55b5e8..ed904b94 100644
--- a/gemfeed/2008-06-26-perl-poetry.md
+++ b/gemfeed/2008-06-26-perl-poetry.md
@@ -163,6 +163,171 @@ Did you like what you saw? Have a look at Codeberg to see my other poems too:
 
 Other related posts are:
 
+# Perl Poetry
+
+> Published at 2008-06-26T21:43:51+01:00; Updated at 2021-05-04
+
+```
+ '\|/'                                  *
+-- * -----
+  /|\      ____
+ ' | '    {_   o^>       *
+   :        -_  /)
+   :         (   (        .-''`'.
+   .          \   \      /       \
+   .           \    \   /         \
+                \    `-'           `'.
+                 \    . '        /    `.
+                  \  ( \  )     (     .')
+   ,,   t          '. |  /       |     (
+  '|``_/^\___        '|  |`'-..-'|   ( ()
+_~~|~/_|_|__/|~~~~~~~ |  / ~~~~~ |   | ~~~~~~~~
+ -_  |L[|]L|/         | |\ MJP   )   )
+                      ( |(       /  /|
+   ~~ ~  ~ ~~~~       | /\\     / /| |
+                      ||  \\  _/ / | |
+             ~ ~ ~~~ _|| (_/ (___)_| |Nov291999
+                    (__)         (____)
+```
+
+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."
+
+[https://en.wikipedia.org/wiki/Perl](https://en.wikipedia.org/wiki/Perl)  
+
+## math.pl
+
+```perl
+#!/usr/bin/perl
+
+# (C) 2006 by Paul C. Buetow
+
+goto library for study $math;
+BEGIN { s/earching/ books/ 
+and read $them, $at, $the } library:
+
+our $topics, cos and tan, 
+require strict; import { of, tied $patience };
+
+do { int'egrate'; sub trade; };
+do { exp'onentize' and abs'olutize' };
+study and study and study and study;
+
+foreach $topic ({of, math}) {
+you, m/ay /go, to, limits }
+
+do { not qw/erk / unless $success 
+and m/ove /o;$n and study };
+
+do { int'egrate'; sub trade; };
+do { exp'onentize' and abs'olutize' };
+study and study and study and study;
+
+grep /all/, exp'onents' and cos'inuses';
+/seek results/ for @all, log'4rithms';
+
+'you' =~ m/ay /go, not home 
+unless each %book ne#ars
+$completion;
+
+do { int'egrate'; sub trade; };
+do { exp'onentize' and abs'olutize' };
+
+#at
+home: //ig,'nore', time and sleep $very =~ s/tr/on/g;
+__END__
+
+```
+
+## christmas.pl
+
+```perl
+#!/usr/bin/perl
+
+# (C) 2006 by Paul C. Buetow
+
+Christmas:{time;#!!!
+
+Children: do tell $wishes;
+
+Santa: for $each (@children) { 
+BEGIN { read $each, $their, wishes and study them; use Memoize#ing
+
+} use constant gift, 'wrapping'; 
+package Gifts; pack $each, gift and bless $each and goto deliver
+or do import if not local $available,!!! HO, HO, HO;
+
+redo Santa, pipe $gifts, to_childs;
+redo Santa and do return if last one, is, delivered; 
+
+deliver: gift and require diagnostics if our $gifts ,not break;
+do{ use NEXT; time; tied $gifts} if broken and dump the, broken, ones;
+The_children: sleep and wait for (each %gift) and try { to => untie $gifts };
+
+redo Santa, pipe $gifts, to_childs;
+redo Santa and do return if last one, is, delivered; 
+
+The_christmas_tree: formline s/ /childrens/, $gifts;
+alarm and warn if not exists $Christmas{ tree}, @t, $ENV{HOME};  
+write <<EMail
+ to the parents to buy a new christmas tree!!!!111
+ and send the
+EMail
+;wait and redo deliver until defined local $tree;
+
+redo Santa, pipe $gifts, to_childs;
+redo Santa and do return if last one, is, delivered ;}
+
+END {} our $mission and do sleep until next Christmas ;}
+
+__END__
+
+This is perl, v5.8.8 built for i386-freebsd-64int
+```
+
+## shopping.pl
+
+```perl
+#!/usr/bin/perl
+
+# (C) 2007 by Paul C. Buetow
+
+BEGIN{} goto mall for $shopping; 
+
+m/y/; mall: seek$s, cool products(), { to => $sell };
+for $their (@business) { to:; earn:; a:; lot:; of:; money: }
+
+do not goto home and exit mall if exists $new{product};
+foreach $of (q(uality rich products)){} package products; 
+
+our $news; do tell cool products() and do{ sub#tract
+cool{ $products and shift @the, @bad, @ones;
+
+do bless [q(uality)], $products 
+and return not undef $stuff if not (local $available) }};
+
+do { study and study and study for cool products() }
+and do { seek $all, cool products(), { to => $buy } };
+
+do { write $them, $down } and do { order: foreach (@case) { package s } };
+goto home if not exists $more{money} or die q(uerying) ;for( @money){};
+
+at:;home: do { END{} and:; rest:; a:; bit: exit $shopping } 
+and sleep until unpack$ing, cool products();
+
+__END__
+This is perl, v5.8.8 built for i386-freebsd-64int
+```
+
+## More...
+
+Did you like what you saw? Have a look at Codeberg to see my other poems too:
+
+[https://codeberg.org/snonux/perl-poetry](https://codeberg.org/snonux/perl-poetry)  
+
+Other related posts are:
+
 [2022-05-27 Perl is still a great choice](./2022-05-27-perl-is-still-a-great-choice.md)  
 [2011-05-07 Perl Daemon (Service Framework)](./2011-05-07-perl-daemon-service-framework.md)  
 [2008-06-26 Perl Poetry (You are currently reading this)](./2008-06-26-perl-poetry.md)  
diff --git a/gemfeed/2021-04-24-welcome-to-the-geminispace.md b/gemfeed/2021-04-24-welcome-to-the-geminispace.md
index 51559621..afc902e2 100644
--- a/gemfeed/2021-04-24-welcome-to-the-geminispace.md
+++ b/gemfeed/2021-04-24-welcome-to-the-geminispace.md
@@ -49,6 +49,57 @@ Around the same time, I discovered a relatively new, more lightweight protocol n
 The "downside" is that due to the limited capabilities of the Gemini protocol, all sites look very old and spartan. But that is not a downside; that is, in fact, a design choice people made. It is up to the client software how your capsule looks. For example, you could use a graphical client, such as Lagrange, with nice font renderings and colours to improve the appearance. Or you could use a very minimalistic command line black-and-white Gemini client. It's your (the user's) choice.
 
 [![Screenshot Amfora Gemini terminal client surfing this site](./2021-04-24-welcome-to-the-geminispace/amfora-screenshot.png "Screenshot Amfora Gemini terminal client surfing this site")](./2021-04-24-welcome-to-the-geminispace/amfora-screenshot.png)  
+# Welcome to the Geminispace
+
+> Published at 2021-04-24T19:28:41+01:00; Updated at 2021-06-18
+
+ASCII Art by Andy Hood!
+
+Have you reached this article already via Gemini? It requires a Gemini client; web browsers such as Firefox, Chrome, Safari, etc., don't support the Gemini protocol. The Gemini address of this site (or the address of this capsule as people say in Geminispace) is:
+
+[gemini://foo.zone](gemini://foo.zone)  
+
+However, if you still use HTTP, you are just surfing the fallback HTML version of this capsule. In that case, I suggest reading on what this is all about :-).
+
+```
+
+    /\
+   /  \
+  |    |
+  |NASA|
+  |    |
+  |    |
+  |    |
+ '      `
+ |Gemini|
+ |      |
+ |______|
+  '-`'-`   .
+  / . \'\ . .'
+ ''( .'\.' ' .;'
+'.;.;' ;'.;' ..;;' AsH
+
+```
+
+## Motivation
+
+### My urge to revamp my personal website
+
+For some time, I had to urge to revamp my personal website. Not to update the technology and its design but to update all the content (+ keep it current) and start a small tech blog again. So unconsciously, I began to search for an excellent platform to do all of that in a KISS (keep it simple & stupid) way.
+
+### My still great Laptop running hot
+
+Earlier this year (2021), I noticed that my almost seven-year-old but still great Laptop started to become hot and slowed down while surfing the web. Also, the Laptop's fan became quite noisy. This was all due to the additional bloat such as JavaScript, excessive use of CSS, tracking cookies+pixels, ads, and so on there was on the website. 
+
+All I wanted was to read an interesting article, but after a big advertising pop-up banner appeared and made everything worse, I gave up and closed the browser tab.
+
+## Discovering the Gemini internet protocol
+
+Around the same time, I discovered a relatively new, more lightweight protocol named Gemini, which does not support all these CPU-intensive features like HTML, JavaScript, and CSS. Also, tracking and ads are unsupported by the Gemini protocol.
+
+The "downside" is that due to the limited capabilities of the Gemini protocol, all sites look very old and spartan. But that is not a downside; that is, in fact, a design choice people made. It is up to the client software how your capsule looks. For example, you could use a graphical client, such as Lagrange, with nice font renderings and colours to improve the appearance. Or you could use a very minimalistic command line black-and-white Gemini client. It's your (the user's) choice.
+
+[![Screenshot Amfora Gemini terminal client surfing this site](./2021-04-24-welcome-to-the-geminispace/amfora-screenshot.png "Screenshot Amfora Gemini terminal client surfing this site")](./2021-04-24-welcome-to-the-geminispace/amfora-screenshot.png)  
 [![Screenshot graphical Lagrange Gemini client surfing this site](./2021-04-24-welcome-to-the-geminispace/lagrange-screenshot.png "Screenshot graphical Lagrange Gemini client surfing this site")](./2021-04-24-welcome-to-the-geminispace/lagrange-screenshot.png)  
 
 Why is there a need for a new protocol? As the modern web is a superset of Gemini, can't we use simple HTML 1.0 instead? That's a good and valid question. It is not a technical problem but a human problem. We tend to abuse the features once they are available. You can ensure that things stay efficient and straightforward as long as you are using the Gemini protocol. On the other hand, you can't force every website on the modern web to only create plain and straightforward-looking HTML pages.
diff --git a/gemfeed/2021-07-04-the-well-grounded-rubyist.md b/gemfeed/2021-07-04-the-well-grounded-rubyist.md
index 3d4135c6..c9274ab1 100644
--- a/gemfeed/2021-07-04-the-well-grounded-rubyist.md
+++ b/gemfeed/2021-07-04-the-well-grounded-rubyist.md
@@ -6,6 +6,14 @@ When I was a Linux System Administrator, I have been programming in Perl for yea
 
 You should learn or try out one new programming language once yearly anyway. If you end up not using the new language, that's not a problem. You will learn new techniques with each new programming language and this also helps you to improve your overall programming skills even for other languages. Also, having some background in a similar programming language makes it reasonably easy to get started. Besides that, learning a new programming language is kick-a** fun!
 
+# The Well-Grounded Rubyist
+
+> Published at 2021-07-04T10:51:23+01:00
+
+When I was a Linux System Administrator, I have been programming in Perl for years. I still maintain some personal Perl programming projects (e.g. Xerl, guprecords, Loadbars). After switching jobs a couple of years ago (becoming a Site Reliability Engineer), I found Ruby (and some Python) widely used there. As I wanted to do something new, I decided to give Ruby a go.
+
+You should learn or try out one new programming language once yearly anyway. If you end up not using the new language, that's not a problem. You will learn new techniques with each new programming language and this also helps you to improve your overall programming skills even for other languages. Also, having some background in a similar programming language makes it reasonably easy to get started. Besides that, learning a new programming language is kick-a** fun!
+
 [![./2021-07-04-the-well-grounded-rubyist/book-cover.jpg](./2021-07-04-the-well-grounded-rubyist/book-cover.jpg)](./2021-07-04-the-well-grounded-rubyist/book-cover.jpg)  
 
 Superficially, Perl seems to have many similarities to Ruby (but, of course, it is entirely different to Perl when you look closer), which pushed me towards Ruby instead of Python. I have tried Python a couple of times before, and I managed to write good code, but I never felt satisfied with the language. I didn't love the syntax, especially the indentations used; they always confused me. I don't dislike Python, but I don't prefer to program in it if I have a choice, especially when there are more propelling alternatives available. Personally, it's so much more fun to program in Ruby than in Python.
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 2db77c58..6e388dc0 100644
--- a/gemfeed/2021-09-12-keep-it-simple-and-stupid.md
+++ b/gemfeed/2021-09-12-keep-it-simple-and-stupid.md
@@ -29,6 +29,37 @@ This not just makes the system much more complex, difficult to maintain and chal
 
 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. 
 
+# Keep it simple and stupid
+
+> Published at 2021-09-12T09:39:20+03:00; Updated at 2023-03-23
+
+```
+  _______________                        |*\_/*|_______
+  |  ___________  |     .-.     .-.      ||_/-\_|______  |
+  | |           | |    .****. .****.     | |           | |
+  | |   0   0   | |    .*****.*****.     | |   0   0   | |
+  | |     -     | |     .*********.      | |     -     | |
+  | |   \___/   | |      .*******.       | |   \___/   | |
+  | |___     ___| |       .*****.        | |___________| |
+  |_____|\_/|_____|        .***.         |_______________|
+    _|__|/ \|_|_.............*.............._|________|_
+   / ********** \                          / ********** \
+ /  ************  \                      /  ************  \
+--------------------                    --------------------
+```
+
+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
+
+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
+
+## 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
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 c60a9c81..e1e4d15f 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
@@ -289,6 +289,297 @@ I am a bit busy at the moment with two other pet projects of mine (one internal
 Other related posts are:
 
 [2022-10-30 Installing DTail on OpenBSD](./2022-10-30-installing-dtail-on-openbsd.md)  
+# The release of DTail 4.0.0
+
+> Published at 2022-03-06T18:11:39+00:00
+
+```
+                              ,_---~~~~~----._
+                        _,,_,*^____      _____``*g*\"*,
+  ____ _____     _ _   / __/ /'     ^.  /      \ ^@q   f
+ |  _ \_   _|_ _(_) |   @f | @))    |  | @))   l  0 _/
+ | | | || |/ _` | | |  \`/   \~____ / __ \_____/    \
+ | |_| || | (_| | | |   |           _l__l_           I
+ |____/ |_|\__,_|_|_|   }          [______]           I
+                        ]            | | |            |
+                        ]             ~ ~             |
+                        |                            |
+                         |                           |
+```
+
+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)  
+
+## So, what's new in 4.0.0?
+
+### Rewritten logging
+
+For DTail 4, logging has been completely rewritten. The new package name is "internal/io/dlog". I rewrote the logging because DTail is a special case here: There are logs processed by DTail, there are logs produced by the DTail server itself, there are logs produced by a DTail client itself, there are logs only logged by a DTail client, there are logs only logged by the DTail server, and there are logs logged by both, server and client. There are also different logging levels and outputs involved.
+
+As you can imagine, it becomes fairly complex. There is no ready Go off-shelf logging library which suits my needs and the logging code in DTail 3 was just one big source code file with global variables and it wasn't sustainable to maintain anymore. So why not rewrite it for profit and fun? 
+
+There's a are new log level structure now (The log level now can be specified with the "-logLevel" command line flag):
+
+```
+// Available log levels.
+const (
+	None    level = iota
+	Fatal   level = iota
+	Error   level = iota
+	Warn    level = iota
+	Info    level = iota
+	Default level = iota
+	Verbose level = iota
+	Debug   level = iota
+	Devel   level = iota
+	Trace   level = iota
+	All     level = iota
+)
+```
+
+DTail also supports multiple log outputs (e.g. to file or to stdout). More are now easily pluggable with the new logging package. The output can also be "enriched" (default) or "plain" (read more about that further below).
+
+### Configurable terminal color codes
+
+A complaint I received from the users of DTail 3 were the terminal colors used for the output. Under some circumstances (terminal configuration) it made the output difficult to read so that users defaulted to "--noColor" (disabling colored output completely). I toke it by heart and also rewrote the color handling. It's now possible to configure the foreground and background colors and an attribute (e.g. dim, bold, ...).
+
+The example "dtail.json" configuration file represents the default (now, more reasonable default) color codes used, and it is free to the user to customize them:
+
+```
+{
+  "Client": {
+    "TermColorsEnable": true,
+    "TermColors": {
+      "Remote": {
+        "DelimiterAttr": "Dim",
+        "DelimiterBg": "Blue",
+        "DelimiterFg": "Cyan",
+        "RemoteAttr": "Dim",
+        "RemoteBg": "Blue",
+        "RemoteFg": "White",
+        "CountAttr": "Dim",
+        "CountBg": "Blue",
+        "CountFg": "White",
+        "HostnameAttr": "Bold",
+        "HostnameBg": "Blue",
+        "HostnameFg": "White",
+        "IDAttr": "Dim",
+        "IDBg": "Blue",
+        "IDFg": "White",
+        "StatsOkAttr": "None",
+        "StatsOkBg": "Green",
+        "StatsOkFg": "Black",
+        "StatsWarnAttr": "None",
+        "StatsWarnBg": "Red",
+        "StatsWarnFg": "White",
+        "TextAttr": "None",
+        "TextBg": "Black",
+        "TextFg": "White"
+      },
+      "Client": {
+        "DelimiterAttr": "Dim",
+        "DelimiterBg": "Yellow",
+        "DelimiterFg": "Black",
+        "ClientAttr": "Dim",
+        "ClientBg": "Yellow",
+        "ClientFg": "Black",
+        "HostnameAttr": "Dim",
+        "HostnameBg": "Yellow",
+        "HostnameFg": "Black",
+        "TextAttr": "None",
+        "TextBg": "Black",
+        "TextFg": "White"
+      },
+      "Server": {
+        "DelimiterAttr": "AttrDim",
+        "DelimiterBg": "BgCyan",
+        "DelimiterFg": "FgBlack",
+        "ServerAttr": "AttrDim",
+        "ServerBg": "BgCyan",
+        "ServerFg": "FgBlack",
+        "HostnameAttr": "AttrBold",
+        "HostnameBg": "BgCyan",
+        "HostnameFg": "FgBlack",
+        "TextAttr": "AttrNone",
+        "TextBg": "BgBlack",
+        "TextFg": "FgWhite"
+      },
+      "Common": {
+        "SeverityErrorAttr": "AttrBold",
+        "SeverityErrorBg": "BgRed",
+        "SeverityErrorFg": "FgWhite",
+        "SeverityFatalAttr": "AttrBold",
+        "SeverityFatalBg": "BgMagenta",
+        "SeverityFatalFg": "FgWhite",
+        "SeverityWarnAttr": "AttrBold",
+        "SeverityWarnBg": "BgBlack",
+        "SeverityWarnFg": "FgWhite"
+      },
+      "MaprTable": {
+        "DataAttr": "AttrNone",
+        "DataBg": "BgBlue",
+        "DataFg": "FgWhite",
+        "DelimiterAttr": "AttrDim",
+        "DelimiterBg": "BgBlue",
+        "DelimiterFg": "FgWhite",
+        "HeaderAttr": "AttrBold",
+        "HeaderBg": "BgBlue",
+        "HeaderFg": "FgWhite",
+        "HeaderDelimiterAttr": "AttrDim",
+        "HeaderDelimiterBg": "BgBlue",
+        "HeaderDelimiterFg": "FgWhite",
+        "HeaderSortKeyAttr": "AttrUnderline",
+        "HeaderGroupKeyAttr": "AttrReverse",
+        "RawQueryAttr": "AttrDim",
+        "RawQueryBg": "BgBlack",
+        "RawQueryFg": "FgCyan"
+      }
+    }
+  },
+  ...
+}
+```
+
+You notice the different sections - these are different contexts:
+
+* Remote: Color configuration for all log lines sent remotely from the server to the client. 
+* Client: Color configuration for all lines produced by a DTail client by itself (e.g. status information).
+* Server: Color configuration for all lines produced by the DTail server by itself and sent to the client (e.g. server warnings or errors)
+* MaprTable: Color configuration for the map-reduce table output.
+* Common: Common color configuration used in various places (e.g. when it's not clear what's the current context of a line).
+
+When you do so, make sure that you check your "dtail.json" against the JSON schema file. This is to ensure that you don't configure an invalid color accidentally (requires "jsonschema" to be installed on your computer). Furthermore, the schema file is also a good reference for all possible colors available:
+
+```
+jsonschema -i dtail.json schemas/dtail.schema.json
+```
+
+### Serverless mode
+
+All DTail commands can now operate on log files (and other text files) directly without any DTail server running. So there isn't a need anymore to install a DTail server when you are on the target server already anyway, like the following example shows:
+
+```
+% dtail --files /var/log/foo.log
+```
+
+or
+
+```
+% dmap --files /var/log/foo.log --query 'from TABLE select .... outfile result.csv'
+```
+
+The way it works in Go code is that a connection to a server is managed through an interface and in serverless mode DTail calls through that interface to the server code directly without any TCP/IP and SSH connection made in the background. This means, that the binaries are a bit larger (also ship with the code which normally would be executed by the server) but the increase of binary size is not much.
+
+### Shorthand flags
+
+The "--files" from the previous example is now redundant. As a shorthand, It is now possible to do the following instead:
+
+```
+% dtail /var/log/foo.log
+```
+
+Of course, this also works with all other DTail client commands (dgrep, dcat, ... etc).
+
+### Spartan (aka plain) mode
+
+There's a plain mode, which makes DTail only print out the "plain" text of the files operated on (without any DTail specific enriched output). E.g.:
+
+```
+% dcat --plain /etc/passwd > /etc/test
+% diff /etc/test /etc/passwd  # Same content, no diff
+```
+
+This might be useful if you wanted to post-process the output. 
+
+### Standard input pipe
+
+In serverless mode, you might want to process your data in a pipeline. You can do that now too through an input pipe:
+
+```
+% dgrep --plain --regex 'somethingspecial' /var/log/foo.log |
+    dmap --query 'from TABLE select .... outfile result.csv'
+```
+
+Or, use any other "standard" tool:
+
+```
+% awk '.....' < /some/file | dtail ....
+```
+
+### New command dtailhealth
+
+Prior to DTail 4, there was a flag for the "dtail" command to check the health of a remote DTail server (for use with monitoring system such as Nagios). That has been moved out to a separate binary to reduce complexity of the "dtail" command. The following checks whether DTail is operational on the current machine (you could also check a remote instance of DTail server, just adjust the server address).
+
+```
+% cat check_dtail.sh
+#!/bin/sh
+
+exec /usr/local/bin/dtailhealth --server localhost:2222
+```
+
+### Improved documentation
+
+Some features, such as custom log formats and the map-reduce query language, are now documented. Also, the examples have been updated to reflect the new features added. This also includes the new animated example Gifs (plus documentation how they were created).
+
+I must admit that not all features are documented yet:
+
+* Server side scheduled map-reduce queries
+* Server side continuous map-reduce queries
+* Some more docs about terminal color customization
+* Some more docs about log levels
+
+That will be added in one of the future releases. 
+
+### Integration testing suite
+
+DTail comes already with some unit tests, but what's new is a full integration testing suite which covers all common use cases of all the commands (dtail, dcat, dgrep, dmap) with a server backend and also in serverless mode.
+
+How are the tests implemented? All integration tests are simply unit tests in the "./integrationtests" folder. They must be explicitly activated with:
+
+```
+% export DTAIL_INTEGRATION_TEST_RUN_MODE=yes
+```
+
+Once done, first compile all commands, and then run the integration tests:
+
+```
+% make
+.
+.
+.
+% go clean -testcache
+% go test -race -v ./integrationtests
+```
+
+### Improved code
+
+Not that the code quality of DTail has been bad (I have been using Go vet and Go lint for previous releases and will keep using these), but this time I had new tools (such as SonarQube and BlackDuck) in my arsenal to:
+
+* Reduce the complexity of a couple of functions (splitting code up into several smaller functions)
+* Avoid repeating code (this version of DTail doesn't use Go generics yet, though).
+
+Other than that, a lot of other code has been refactored as I saw fit.
+
+### Use of memory pools
+
+DTail makes excessive use of string builder and byte buffer objects. For performance reasons, those are now re-used from memory pools.
+
+## What's next
+
+DTail 5 won't be released any time soon I guess, but some 4.x.y releases will follow this year fore sure. I can think of:
+
+* New (but backwards compatible) features which don't require a new major version bump (some features have been requested at work internally).
+* Even more improved documentation.
+* Dependency updates.
+
+I use usually DTail at work, but I have recently installed it on my personal OpenBSD machines too. I might write a small tutorial here (and I might also add the rc scripts as examples to one of the next DTail releases).
+
+I am a bit busy at the moment with two other pet projects of mine (one internal work-project, and one personal one, the latter you will read about in the next couple of months). If you have ideas (or even a patch), then please don't hesitate to contact me (either via E-Mail or a request at GitHub).
+
+Other related posts are:
+
+[2022-10-30 Installing DTail on OpenBSD](./2022-10-30-installing-dtail-on-openbsd.md)  
 [2022-03-06 The release of DTail 4.0.0 (You are currently reading this)](./2022-03-06-the-release-of-dtail-4.0.0.md)  
 [2021-04-22 DTail - The distributed log tail program](./2021-04-22-dtail-the-distributed-log-tail-program.md)  
 
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 27a1126d..f08b7db5 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
@@ -33,6 +33,41 @@ Some good books on "good" Perl I can recommend are:
 Due to Perl's expressiveness you will find a lot of obscure code in the interweb in form of obfuscation, fancy email signatures (JAPHs), art, polyglots and even poetry in Perl syntax. But that's not what you will find in production code. That's only people having fun with the language which is different to "getting things done". The expressiveness is a bonus. It makes the Perl programmers love Perl.
 
 [JAPH](https://en.wikipedia.org/wiki/Just_another_Perl_hacker)  
+# Perl is still a great choice
+
+> Published at 2022-05-27T07:50:12+01:00; Updated at 2023-01-28
+
+[![Comic source: XKCD](./2022-05-27-perl-is-still-a-great-choice/regular_expressions.png "Comic source: XKCD")](./2022-05-27-perl-is-still-a-great-choice/regular_expressions.png)  
+
+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:
+
+[![./2022-05-27-perl-is-still-a-great-choice/googletrendsperl.jpg](./2022-05-27-perl-is-still-a-great-choice/googletrendsperl.jpg)](./2022-05-27-perl-is-still-a-great-choice/googletrendsperl.jpg)  
+
+So why is that? Once the de-facto standard super-glue language for the web nowadays seems to have a bad reputation. Often, people state:
+
+* Perl is a write-only language. Nobody can read Perl code.
+* Perl? Isn't it abandoned? It's still at version 5!
+* Why use Perl as there are better alternatives?
+* Why all the sigils? It looks like an exploding ASCII factory!!
+
+## Write-only language
+
+Is Perl really a write-only language? You have to understand that Perl 5 was released in 1994 (28 years ago as of this writing) and when we refer to Perl we usually mean Perl 5. That's many years, and there are many old scripts not following the modern Perl best practices (as they didn't exist yet). So yes, legacy scripts may be difficult to read. Japanese may be difficult to read too if you don't know Japanese, though.
+
+To come back to the question: Is Perl a write-only language? I don't think so. Like in any other language, you have to apply best practices in order to keep your code maintainable. Some other programming languages enforce best practices, but that makes these languages less expressive. Perl follows the principles "there is more than one way to do it" (aka TIMTOWDI) and "making easy things easy and hard things possible".
+
+Perl gives the programmer more flexibility in how to do things, and this results in a stronger learning curve than for lesser expressive languages like for example Go or Python. But, like in everything in life, common sense has to be applied. You should not take TIMTOWDI to the extreme in a production piece of code. In my personal opinion, it is also more satisfying to program in an expressive language.
+
+Some good books on "good" Perl I can recommend are:
+
+[Modern Perl](http://modernperlbooks.com)  
+[Higher Order Perl](https://hop.perl.plover.com)  
+
+Due to Perl's expressiveness you will find a lot of obscure code in the interweb in form of obfuscation, fancy email signatures (JAPHs), art, polyglots and even poetry in Perl syntax. But that's not what you will find in production code. That's only people having fun with the language which is different to "getting things done". The expressiveness is a bonus. It makes the Perl programmers love Perl.
+
+[JAPH](https://en.wikipedia.org/wiki/Just_another_Perl_hacker)  
 [http://www.cpan.org/misc/japh](http://www.cpan.org/misc/japh)  
 [Perl Poetry](https://www.perlmonks.org/index.pl?next=20;node_id=1590)  
 
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 b6743054..1df5b15c 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
@@ -90,6 +90,98 @@ Other related posts are:
 [2023-03-25 Gemtexter 2.0.0 - Let's Gemtext again²](./2023-03-25-gemtexter-2.0.0-lets-gemtext-again-2.md)  
 [2022-08-27 Gemtexter 1.1.0 - Let's Gemtext again (You are currently reading this)](./2022-08-27-gemtexter-1.1.0-lets-gemtext-again.md)  
 [2021-06-05 Gemtexter - One Bash script to rule it all](./2021-06-05-gemtexter-one-bash-script-to-rule-it-all.md)  
+# Gemtexter 1.1.0 - Let's Gemtext again
+
+> Published at 2022-08-27T18:25:57+01:00
+
+```
+-=[ typewriter ]=-  1/98
+
+       .-------.
+      _|~~ ~~  |_
+    =(_|_______|_)=
+      |:::::::::|
+      |:::::::[]|
+      |o=======.|
+ jgs  `"""""""""`
+```
+
+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)  
+
+It has been around a year since I released the first version `1.0.0`. Although, there aren't any groundbreaking changes, there have been a couple of smaller commits and adjustments. I was quite surprised that I received a bunch of feedback and requests about Gemtexter so it means that I am not the only person in the universe actually using it.
+
+## What's new?
+
+### Automatic check for GNU version requirements
+
+Gemtexter relies on the GNU versions of the tools `grep`, `sed` and `date` and it also requires the Bash shell in version 5 at least. That's now done in the `check_dependencies()` function:
+
+```bash
+check_dependencies () {
+    # At least, Bash 5 is required
+    local -i required_version=5
+    IFS=. read -ra version <<< "$BASH_VERSION"
+    if [ "${version[0]}" -lt $required_version ]; then
+        log ERROR "ERROR, \"bash\" must be at least at major version $required_version!"
+        exit 2
+    fi
+
+    # These must be the GNU versions of the commands
+    for tool in $DATE $SED $GREP; do
+        if ! $tool --version | grep -q GNU; then
+            log ERROR "ERROR, \"$tool\" command is not the GNU version, please install!"
+            exit 2
+        fi
+    done
+}
+```
+
+Especially macOS users didn't read the `README` carefully enough to install GNU Grep, GNU Sed and GNU Date before using Gemtexter.
+
+### Backticks now produce `inline code blocks` in the HTML output
+
+The Gemtext format doesn't support inline code blocks, but Gemtexter now produces `inline code blocks` (means, small code fragments can be placed in the middle of a paragraph) in the HTML output when the code block is enclosed with Backticks. There were no adjustments required for the Markdown output format, because Markdown supports it already out of the box.
+
+### Cache for Atom feed generation
+
+The Bash is not the most performant language. Gemtexter already takes a couple of seconds only to generate the Atom feed for around two hand full of articles on my slightly underpowered Surface Go 2 Linux tablet. Therefore, I introduced a cache, so that subsequent Atom feed generation runs finish much quicker. The cache uses a checksum of the Gemtext `.gmi` file to decide whether anything of the content has changed or not.
+
+### Input filter support
+
+Once your capsule reaches a certain size, it can become annoying to re-generate everything if you only want to preview the HTML or Markdown output of one single content file. The following will add a filter to only generate the files matching a regular expression:
+
+```sh
+./gemtexter --generate '.*hello.*'
+```
+
+### Revamped `git` support
+
+The Git support has been completely rewritten. It's now more reliable and faster too. Have a look at the `README` for more information.
+
+### Addition of `htmlextras` and web font support
+
+The `htmlextras` folder now contains all extra files required for the HTML output format such as cascading style sheet (CSS) files and web fonts.
+
+### Sub-section support
+
+It's now possible to define sub-sections within a Gemtexter capsule. For the HTML output, each sub-section can use its own CSS and web font definitions. E.g.:
+
+[The foo.zone main site](https://foo.zone)  
+[The notes sub-section (with different fonts)](https://foo.zone/notes)  
+
+### More
+
+Additionally, there were a couple of bug fixes, refactorings and overall improvements in the documentation made. 
+
+Overall I think it's a pretty solid `1.1.0` release without anything groundbreaking (therefore no major version jump). But I am happy about it.
+
+Other related posts are:
+
+[2023-03-25 Gemtexter 2.0.0 - Let's Gemtext again²](./2023-03-25-gemtexter-2.0.0-lets-gemtext-again-2.md)  
+[2022-08-27 Gemtexter 1.1.0 - Let's Gemtext again (You are currently reading this)](./2022-08-27-gemtexter-1.1.0-lets-gemtext-again.md)  
+[2021-06-05 Gemtexter - One Bash script to rule it all](./2021-06-05-gemtexter-one-bash-script-to-rule-it-all.md)  
 [2021-04-24 Welcome to the Geminispace](./2021-04-24-welcome-to-the-geminispace.md)  
 
 E-Mail your comments to hi@paul.cyou :-)
diff --git a/gemfeed/2022-10-30-installing-dtail-on-openbsd.md b/gemfeed/2022-10-30-installing-dtail-on-openbsd.md
index 3c71f577..db9ecb8d 100644
--- a/gemfeed/2022-10-30-installing-dtail-on-openbsd.md
+++ b/gemfeed/2022-10-30-installing-dtail-on-openbsd.md
@@ -43,6 +43,51 @@ This will be a quick blog post, as I am busy with my personal life now. I have r
 
  In this post, I want to give a quick overview (or how-to) about installing DTail on OpenBSD, as the official documentation only covers Red Hat and Fedora Linux! And this blog post will also be used as my reference!
 
+# Installing DTail on OpenBSD
+
+> Published at 2022-10-30T11:03:19+02:00
+
+```
+       ,_---~~~~~----._
+ _,,_,*^____      _____``*g*\"*,
+/ __/ /'     ^.  /      \ ^@q   f
+ @f   |       |  |       |  0 _/
+\`/   \~__((@/ __ \__((@/    \
+ |           _l__l_           I    <--- The Go Gopher
+ }          [______]           I
+ ]            | | |            |
+ ]             ~ ~             |
+ |                            |
+  |                           |
+  |                           |       A       ;
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~|~~~,--,-/ \---,-/|~~,~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                           _|\,'. /|      /|   `/|-.
+                       \`.'    /|      ,            `;.
+                      ,'\   A     A         A   A _ /| `.;
+                    ,/  _              A       _  / _   /|  ;
+                   /\  / \   ,  ,           A  /    /     `/|
+                  /_| | _ \         ,     ,             ,/  \
+                 // | |/ `.\  ,-      ,       ,   ,/ ,/      \/
+                 / @| |@  / /'   \  \      ,              >  /|    ,--.
+                |\_/   \_/ /      |  |           ,  ,/        \  ./' __:..
+                |  __ __  |       |  | .--.  ,         >  >   |-'   /     `
+              ,/| /  '  \ |       |  |     \      ,           |    /
+             /  |<--.__,->|       |  | .    `.        >  >    /   (
+            /_,' \\  ^  /  \     /  /   `.    >--            /^\   |
+                  \\___/    \   /  /      \__'     \   \   \/   \  |
+                   `.   |/          ,  ,                  /`\    \  )
+                     \  '  |/    ,       V    \          /        `-\
+ OpenBSD Puffy --->   `|/  '  V      V           \    \.'            \_
+                       '`-.       V       V        \./'\
+                           `|/-.      \ /   \ /,---`\         kat
+                            /   `._____V_____V'
+                                       '     '
+```
+
+This will be a quick blog post, as I am busy with my personal life now. I have relocated to a different country and am still busy arranging things. So bear with me :-)
+
+ In this post, I want to give a quick overview (or how-to) about installing DTail on OpenBSD, as the official documentation only covers Red Hat and Fedora Linux! And this blog post will also be used as my reference!
+
 [https://dtail.dev](https://dtail.dev)  
 
 I am using Rexify for my OpenBSD automation. Check out the following article covering my Rex setup in a little bit more detail:
diff --git a/gemfeed/2023-05-01-unveiling-guprecords:-uptime-records-with-raku.md b/gemfeed/2023-05-01-unveiling-guprecords:-uptime-records-with-raku.md
index c98b9a79..0b107246 100644
--- a/gemfeed/2023-05-01-unveiling-guprecords:-uptime-records-with-raku.md
+++ b/gemfeed/2023-05-01-unveiling-guprecords:-uptime-records-with-raku.md
@@ -28,6 +28,7 @@ As a result of this, I am introducing `guprecords.raku`, a handy Raku script tha
 Guprecords, or global uptime records, is a Raku script designed to generate a consolidated uptime report from multiple hosts:
 
 [https://codeberg.org/snonux/guprecords](https://codeberg.org/snonux/guprecords)  
+[The Raku Programming Language](https://raku.org)  
 
 A previous version of Guprecords was actually written in Perl, the older and more established language from which Raku was developed. One of the primary motivations for rewriting Guprecords in Raku was to learn the language and explore its features. Raku is a more modern and powerful language compared to Perl, and working on a real-world project like Guprecords provided a practical and engaging way to learn the language.
 
diff --git a/gemfeed/index.md b/gemfeed/index.md
index c61dfcee..a55c7fbf 100644
--- a/gemfeed/index.md
+++ b/gemfeed/index.md
@@ -4,6 +4,12 @@
 
 [2023-05-01 - Unveiling `guprecords.raku`: Global Uptime Records with Raku](./2023-05-01-unveiling-guprecords:-uptime-records-with-raku.md)  
 [2023-04-09 - Algorithms and Data Structures in Go - Part 1](./2023-04-09-algorithms-and-data-structures-in-golang-part-1.md)  
+# Gemfeed of foo.zone
+
+## To be in the .zone!
+
+[2023-05-01 - Unveiling `guprecords.raku`: Global Uptime Records with Raku](./2023-05-01-unveiling-guprecords:-uptime-records-with-raku.md)  
+[2023-04-09 - Algorithms and Data Structures in Go - Part 1](./2023-04-09-algorithms-and-data-structures-in-golang-part-1.md)  
 [2023-04-01 - 'Never split the difference' book notes](./2023-04-01-never-split-the-difference-book-notes.md)  
 [2023-03-25 - Gemtexter 2.0.0 - Let's Gemtext again²](./2023-03-25-gemtexter-2.0.0-lets-gemtext-again-2.md)  
 [2023-03-16 - 'The Pragmatic Programmer' book notes](./2023-03-16-the-pragmatic-programmer-book-notes.md)  
diff --git a/index.md b/index.md
index 40bc5bec..a4b44c77 100644
--- a/index.md
+++ b/index.md
@@ -1,6 +1,6 @@
 # foo.zone
 
-> This site was generated at 2023-04-30T13:37:15+03:00 by `Gemtexter`
+> This site was generated at 2023-04-30T16:46:49+03:00 by `Gemtexter`
 
 ```
    |\---/|
diff --git a/uptime-stats.md b/uptime-stats.md
index 52a91c8c..e63164f8 100644
--- a/uptime-stats.md
+++ b/uptime-stats.md
@@ -1,6 +1,6 @@
 # My machine uptime stats
 
-> This site was last updated at 2023-04-30T13:37:15+03:00
+> This site was last updated at 2023-04-30T16:46:49+03:00
 
 The following stats were collected via `uptimed` on all of my personal computers over many years and the output was generated by `guprecords`, the global uptime records stats analyser of mine.