I have a Git repository with a primary branch that I maintain actively. I also have a separate feature branch that I'd like to keep in sync with the main branch, and alert if there are any conflicts immediately. Using Git hooks you can script automatically pulling each new commit from the primary branch to the feature branch.

Create a .git/hooks/post-commit file and put these contents in it:

#!/bin/sh

SRC="main"
DST="feature"

branch=$(git branch --show-current)

if [ "$branch" = "$SRC" ]; then
    commit=$(git rev-parse HEAD)

    git checkout $DST &&
    git cherry-pick "$commit" &&
    git checkout main
fi

If there are conflicts, Git errors out immediately and leaves you on the feature branch to manually resolve the conflict.

I have two directories with (mostly) the same content that I want to keep in sync. Specifically I want to make sure that the newest version of each file is synced to the other directory. This allows me to update a file on either side, and that version will propagate to the other. You can do this with a bi-directional rsync command:

rsync --update -av /dir/a/ /dir/b/
rsync --update -av /dir/b/ /dir/a/

Using --update tells rsync to skip files on the receiving side that are newer. If you sync a -> b and then b -> a you end up with both locations having the newest copy of each file.

ULID's are an interesting way to generate globally unique identifiers. Here is a quickie Perl implementation to generate ULIDs. This implementation does not include the intra-millisecond monotonic increment however. If that feature is important to you consider checking out a more full-featured implementation like ULID::Tiny.

for (1 .. 5) {
    say(ulid());
}

sub ulid {
    my $ts    = $_[0] || time() * 1000;
    my $bytes = substr(pack("Q>", $ts), 2, 6);

    # Append 10 random bytes
    for (0 .. 9) { $bytes .= chr(int(rand(256))); }

    # base32 encoding
    my $bits  = unpack("B*", $bytes);
    my $pad   = (5 - (length($bits) % 5)) % 5;
    $bits    .= '0' x $pad;

    # Chars to use for base32
    my @CROCKFORD_CHARS = split(//, '0123456789ABCDEFGHJKMNPQRSTVWXYZ');

    my $result  = '';
    for (my $i = 0; $i < length($bits); $i += 5) {
        my $chunk = substr($bits, $i, 5);
        my $index = 0;
        for my $bit (split //, $chunk) {
            $index = ($index << 1) | $bit;
        }

        $result .= $CROCKFORD_CHARS[$index];
    }

    return $result;
}

See also: UUIDv7

Perl allows "inline" code written in other languages. This is useful because you can have native C functions interact with your Perl code. By placing your C code in the __DATA__ section of your Perl script you get clean separation between the two languages.

Note: Inline::C does not understand uint64_t in function definitions, so anything that interacts with Perl needs to use UV instead. Internally C functions can use and interact with uint64_t variables just fine.

use strict;
use warnings;
use v5.16;
use Inline 'C';

##############################################

seed_splitmix64(time());

for (1 .. 5) {
    say splitmix64();
}

##############################################

__DATA__
__C__

uint64_t x = 123456789;

void seed_splitmix64(UV seed) {
    x = seed;
}

UV splitmix64() {
    uint64_t z = (x += 0x9e3779b97f4a7c15);
    z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
    z = (z ^ (z >> 27)) * 0x94d049bb133111eb;

    return z ^ (z >> 31);
}

This will compile the C code into a shared object in the _Inline directory in whichever directory you instantiated your Perl script. Code is only compiled once (and where there are changes), so your script performance will be very high.

I've been investigating JSON vs YAML vs TOML for various applications. After testing many variations I ended up writing a simple tool to compare all three live.

To display a message when a user logs into your server, add the following to ~/.bashrc:

# If it's an interactive terminal show the banner
if [[ $- == *i* ]]; then
    echo "Welcome to the monitoring server"
    echo "Configuration is stored in /etc/myapp"
fi

This runs only for interactive sessions. Non-interactive connections such as SFTP and SCP remain unaffected, which prevents automated processes from breaking.

See also: The text_color project.

The more I learn about YAML, the more I like it. JSON is great as a machine readable format, but it sucks at being human readable. Want to add an element, better make sure you have all the commas and curly braces in the exact right place or the whole thing will be unusable. YAML on the other hand is designed to be human readable and modifiable. It's a very simple key/value system using indentation to represent layers.

PHP has a PECL module with good YAML support. There are also pure PHP versions if you're unable to install PECL modules. Symfony provides one, and so does Spyc. I prefer the latter because it's a single file and very easy to install.

On the Perl side there is YAML::XS, YAML::PP, and many others.

Parsing YAML is very easy in just about every language I can find. If you have a complex data structure that you need humans to interact with use YAML please.

Here is a great breakdown of when to use YAML vs JSON:

YAML spec differences.

Often I need to generate random unsigned integers for seeding PRNGs. The best way is using the getentropy() system function to read OS level randomness into your array.

#include <sys/random.h>

// Read from system random to fill up data structure
int8_t fill_urandom(void *buf, size_t bytes) {
    int8_t ok = getentropy(buf, bytes);

    return (ok == 0);
}

Declare your array of integers, and then pass it as a pointer to this function to fill with random bytes from your OS. This will get you a bunch of random integers you can use for seeding PRNGs.

uint64_t seed[4];
fill_urandom(seed, sizeof(seed));

List of books I read in 2026. Also see the list of 2025. The date indicated denotes the date I started reading the book.

2026-01-01 - White Fang by Jack London - 180 pages
2026-01-03 - Hollow Man by John Dickson Carr - 213 pages
2026-01-06 - The Three-body Problem by Cixin Liu - 400 pages
2026-01-12 - Star Wars: Revelation by Karen Traviss - 410 pages
2026-01-19 - Pale Blue Dot by Carl Sagan - 342 pages
2026-01-25 - Dungeon Crawler Carl by Matt Dinniman - 450 pages
2026-02-01 - Project Hail Mary by Andy Weir - 478 pages
2026-02-09 - The Dark Forest by Cixin Liu - 512 pages
2026-02-18 - The Hike by Drew Magary - 278 pages
2026-02-22 - Fletch by Gregory Mcdonald - 249 pages
2026-02-26 - Zen And The Art Of Motorcycle Maintenance by Robert M. Pirsig - 540 pages
2026-03-06 - Aliens: The Female War by Steve Perry - 258 pages
2026-03-11 - The Crystal Cave by Mary Stewart - 522 pages
2026-03-20 - Nexus by Yuval Noah Harari - 420 pages
2026-03-26 - Star Wars: Onslaught by Michael A. Stackpole - 292 pages
2026-03-31 - Death's End by Cixin Liu - 590 pages
2026-04-09 - The Call Of The Wild by Jack London - 160 pages
2026-04-11 - Dragons Of Autumn Twilight by Margaret Weis - 444 pages
2026-04-19 - Wayne Of Gotham by Tracy Hickman - 296 pages
2026-04-23 - Unwept by Tracy Hickman - 268 pages
2026-04-27 - Star Wars: Ruin by Michael A. Stackpole - 292 pages
2026-05-10 - Invisible by James Patterson - 401 pages
2026-05-18 - Blood Meridian by Cormac McCarthy - 349 pages
2026-05-22 - Star Wars: Invincible by Troy Denning - 347 pages
2026-05-28 - Atlantis Found by Clive Cussler - 532 pages
2026-06-06 - The Hunt For Red October by Tom Clancy - 469 pages

Inheritance Cycle

2026-05-02 - Eragon by Christopher Paolini - 503 pages
2026-xx-xx - Eldest by Christopher Paolini - 679 pages
2026-xx-xx - Brisingr by Christopher Paolini - 763 pages
2026-xx-xx - Inheritance by Christopher Paolini - 849 pages

2026-xx-xx - Dragons Of A Fallen Sun by Margaret Weis - 627 pages
2026-xx-xx - Dragons Of A Lost Star by Margaret Weis - 550 pages
2026-xx-xx - Dragons Of A Vanished Moon by Margaret Weis - 629 pages

In the extended edition of Fellowship of the Ring Gandalf fights the Balrog and then falls for about 70 seconds.

It takes about 12 seconds to reach terminal velocity: 0.5 * g * t^2 = 0.5 * 9.81 * 12^2 ~ 706m

The remaining 58 seconds Gandalf is at terminal velocity (not speeding up) of 53m/s which is v * t = 53 * 58 ~ 3074m. For a total of 3780 meters, or about 2.35 miles.

Pretty impressive free-fall considering they were ALREADY under ground.

Biski64 is a new PRNG there is extremely fast and also very simple. This one was pretty simple so I ported it to Perl in biski64.pl.

SFC64 is also largely considered on of the better PRNGs so I ported it also in sfc64.pl.

I found a PCG64 implementation that I was able to borrow and convert to pure Perl:

# PCG64 RXS-M-XS "simple" variant
#my $seeds = [12, 34];
#my $rand  = pcg64_perl($seeds);
sub pcg64_perl {
    my $seeds = $_[0];
    my $ret   = (($seeds->[0] >> (($seeds->[0] >> 59) + 5)) ^ $seeds->[0]);

    use integer;
    $ret *= 12605985483714917081;
    $seeds->[0] = $seeds->[0] * 6364136223846793005 + $seeds->[1];
    no integer;

    $ret = ($ret >> 43) ^ $ret;

    return $ret;
}

Update: Bonus points because it's really fast:

*               Rate xosh256**  biski64     sfc64     PCG32 Splitmix64     PCG64
xosh256**  1589825/s        --     -26%      -48%      -52%       -58%      -65%
biski64    2145923/s       35%       --      -30%      -35%       -43%      -53%
sfc64      3058104/s       92%      43%        --       -8%       -19%      -33%
PCG32      3311258/s      108%      54%        8%        --       -13%      -28%
Splitmix64 3787879/s      138%      77%       24%       14%         --      -17%
PCG64      4587156/s      189%     114%       50%       39%        21%        --

I have some large audio files that I need to serve via HTTPs. They need to be protected by my PHP login system so they cannot live inside of the webroot. Fortunately there is a nifty Apache module named X-sendfile, that lets you serve files outside of the webroot.

Credential checking is done in PHP, and then you set a special HTTP header that Apache watches for. When Apaches sees the X-Sendfile header it serves the file directly. This gets you all the advantages of a full-blown HTTP server handling your files, but the convenience and simplicity of PHP for handling authentication.

if ($authorized) {
    $mime_type = mime_from_filename($filepath);

    header("Content-Type: $mime_type");
    header("X-Sendfile: $filepath");
    exit;
}

See also: Get mime type for file

If you need to get the mime type for a file in PHP you can use this function which wrappers the finfo_open() function.

function mime_from_filename($filename) {
    $finfo = finfo_open(FILEINFO_MIME_TYPE);
    $mime  = finfo_file($finfo, $filename);
    finfo_close($finfo);

    return $mine;
}

Note: This function requires the file to exist on the disk.

If you need a fast and simple way to get the terminal width in Perl core use Term::ReadKey. This is almost certainly faster and better than shelling out to tput cols.

sub get_terminal_width {
    my @x      = Term::ReadKey::GetTerminalSize();
    my $width  = $x[0] || 0;

    return $width;
}