Perturb.org - Scott's Geek Stuff

Linux: List running services

Sat, 19 Sep 2026 08:57:22 -0700

Just came across this quick command to show running services.

systemctl list-units --type=service --state=running

Perl: Split a string on a delimiter, but respect quotes

Fri, 04 Sep 2026 16:24:55 -0700

It's a common practice to split a string on a delimiter like a comma or semi-colon. If your input data contains the delimiter in quotes you need to respect that and not split there. I wrote a simple function to handle 99% of the use cases for splitting in this manner.

quote_split('foo, bar, baz');   # ('foo', 'bar', 'baz')
		quote_split("foo, 'bar, baz'"); # ('foo', 'bar, baz')

# Split a string on commas, but respect single and double quotes with commas
		sub quote_split {
		    my ($str, $separator) = @_;
		    $separator //= ",";
		    if (!length($separator)) {
		        die("quote_split separator cannot be empty\n");
		    }
		
		    my $separator_re = quotemeta($separator);
		    my @items;
		
		    while ($str =~ /\G\s*(?:
		        "((?:\\.|[^"\\])*)"   # Double-quoted
		        | '((?:\\.|[^'\\])*)' # Single-quoted
		        | ((?:(?!$separator_re)[\s\S])+) # Unquoted
		    )\s*(?:$separator_re|\z)/gcx) {
		
		        my $item = $1 // $2 // $3;
		
		        push(@items, $item);
		    }
		
		    return @items;
		}

Perl: Basic YAML parsing in a copy/pasteable function

Wed, 26 Aug 2026 13:51:35 -0700

I need very basic YAML parsing in Perl, mostly for reading configuration files. There aren't any great options in Perl core, and I only need a subset of YAML (basic scalars, arrays, and hashes), so I worked up a simple copy/pasteable function.

my $x = yaml_parse($yaml_str);

This implementation supports: nesting, scalars, arrays, and hashes, but is missing null / ~, booleans, and complex quotes.

sub yaml_parse {
		    return {} unless defined $_[0] && length $_[0];
		    my %data; my $root = \%data; my @st = ([-1, \$root]);
		    for my $line (split /\n/, $_[0]) {
		        $line =~ s/\r$//;
		        next if $line =~ /^\s*(?:$|---\s*$|#)/;
		        if ($line =~ /^(\s*)-\s*(.*)$/) {
		            my ($n, $v) = (length($1), $2);
		            pop @st while $n < $st[-1][0]; my $cur = ${$st[-1][1]};
		            die "yaml_parse: array without parent: $line" if @st == 1;
		            $cur = ${$st[-1][1]} = [] if ref $cur eq 'HASH' && !%$cur;
		            die "yaml_parse: mixed array/hash" if ref $cur ne 'ARRAY';
		            $v =~ s/^\s+|\s+$//g; $v =~ s/^(['"])(.*)\1$/$2/s;
		            $v += 0 if $v =~ /^-?\d+(?:\.\d+)?$/; if ($v =~ /^([\w\-\.\/]+):\s*$/) {
		            push(@$cur, my $el = {$1 => {}}); push(@st, [$n + 2, \$el->{$1}]); next; }
		            push(@$cur, $v);
		        } elsif ($line =~ /^(\s*)([\w\-\.\/]+)\s*:\s*(.*)$/) {
		            my ($n, $key, $v) = (length($1), $2, $3);
		            pop @st while $n <= $st[-1][0]; my $cur = ${$st[-1][1]};
		            die "yaml_parse: '$key' under array" if ref $cur eq 'ARRAY';
		            $v =~ s/\s+$//; $v =~ s/^\s+//; $v =~ s/^(['"])(.*)\1$/$2/s;
		            if ($v =~ /^\[(.*)\]$/) {
		                my @a = grep { length } map { s/^\s+|\s+$//gr =~ s/^(['"])(.*)\1$/$2/sr } split /,/, $1;
		                for (@a) { $_ += 0 if /^-?\d+(?:\.\d+)?$/ } $v = \@a;
		            } else { $v += 0 if $v =~ /^-?\d+(?:\.\d+)?$/; }
		            if (ref $v or length $v) { $cur->{$key} = $v }
		            else { $cur->{$key} = {}; push(@st, [$n, \$cur->{$key}]) }
		        } else { warn "yaml_parse: ignoring: $line\n" }
		    } return \%data;
		}

YAML::XS is definitely the best Perl YAML parser, but it can be overkill if all you need is simple parsing.

Update: I wrote some unit tests to go along with this.

Javascript: Sluz sandbox

Wed, 19 Aug 2026 18:50:14 -0700

I ported my Sluz templating engine from PHP to JavaScript. It's now possible to run a full Sluz installation entirely in-browser. As a proof-of-concept I ported the Sluz Sandbox to use the JS version of library. Now you can test and validate Sluz code 100% in-browser.

Hardware required to run on frontier level AI model

Thu, 13 Aug 2026 13:50:43 -0700

AI models like Claude Opus and ChatGPT 5.6 are called "frontier" (i.e. top of the line). There are several fully open source frontier level AI models that are available to download for free. I ran the specs on what it would take to run a frontier level model.

For inference of a frontier model (400B-1T+ params):

Minimum (4-bit quantized): ~200-500GB VRAM -> 4-8x H100 80GB GPUs

FP16/half precision: ~800GB-2TB VRAM -> 10-32x H100 80GB GPUs

System RAM: 512GB+

Interconnect: NVLink or InfiniBand between GPUs

Storage: Several hundred GB for model weights For training: 10,000-100,000+ GPU-hours on H100-class hardware, multi-million dollar cluster, weeks of continuous run time. No single consumer GPU can run a frontier model - even an RTX 4090 (24GB) is about 10-30x short of VRAM needed for even a heavily quantized frontier model.

If you just want to host a "good" AI model it requires 8x GPUs with 80GB of VRAM each.

It's about $300k to get in the door for a SINGLE server to run AI you can ask questions

Perl: romuduojr PRNG

Thu, 13 Aug 2026 09:37:13 -0700

Another day, another PRNG ported to Perl. Today is romuduojr from romu-random.org. Pretty simple 64bit PRNG.

Perl: A simple module that doubles as a script

Sat, 01 Aug 2026 12:02:05 -0700

I have a small Perl script that defines a handful of functions. Perl allows you to make a library that doubles as a script when called directly. Using caller() you can determine if your script was loaded via a require() call, or called directly. This allows you to export functions if called as a library, but run code if called directly via: perl my_lib.pl.

# my_lib.pl
		if (!caller()) {
		    say greet("Scott");
		}
		
		sub greet {
		    my $name = shift();
		
		    return "Hello $name";
		}
		
		1; # Required if you load as a library

Use a require() call to load the module and get access to the greet() function.

# main.pl
		require("/path/my_lib.pl");
		
		say greet("Foo");

Summary of each book in the Odyssey

Wed, 15 Jul 2026 07:57:37 -0700

The Odyssey by Homer

Odysseus's house is full of suitors eating all his food and drinking his wine waiting for Athena to choose a new husband
Telemachus calls a council of suitors to try and get rid of them, but the mock him and decide to stay
Telemachus sails to Pylos to meet King Nestor and ask about his father's Whereabouts
Telemachus reaches Sparta and learns his father is trapped on Calypso's island. The suitors plan ambush and kill Telemachus when he returns
Odysseus builds a raft and sails for 17 days besieged by Poseidon's wrath. The raft is destroyed and he swims to shore.
Nausicaa finds Odysseus and takes him to her father's house for a weird washing party. She directs him to her royal parents.
The king senses Odysseus greatness and offers his daughter in marriage but Odysseus declines and only wants to return home.
The Phaeacian compete in sports style games and recruit Odysseus. He says he is too old and worn out from the war.
Odysseus gets captured by a huge cyclops and kept in a cave. Odysseus blinds the Cyclops with a flame stick and escapes to his boat taunting the cyclops as he leaves.
Circe turns Odysseus's men into pigs and tempts Odysseus into her bed. He makes her swear an oath she won't harm him on his quest. She tells them they must go to the underworld next.
Odysseus travels to the underworld and meets on his dead crewmen who fell off Circe's roof and broke his neck. He also meets a ghost who looks like his mother and it causes him grief.
Odysseus is warned about the Siren's call. He tells his men to bind him to the mast and ignore his pleas for freedom. The men put wax in their ears and row past the Sirens. His men, starving, slaughter a sacred cow so Zeus destroys their ship and drowns everyone except Odysseus.
Odysseus makes it back to Ithaca, but he doesn't recognize the location. Athena transforms him into a shepherd and tells him to go see the man in charge of his pigs.
Odysseus meets the swineherd who welcomes him warmly without recognizing him. They share a meal and stories of his travels.
Telemachus heads back to Ithaca after Athena warns him of the suitors ambush. Odysseus reveals his identity to the swineherd and they head to Oddysseus's home.
Telemachus arrives at the swineherds home and meets his father who is still disguised. The reunite and plot to murder the suitors.
The three travel to Odysseus's home and the goatherd mocks and kicks him. Odysseus ignores him and meets his dog who recognizes him even in disguise. The suitors assault and insult the disguised Odysseus.
A beggar arrives at the house and challenges Odysseus, but Odysseus knocks his down pretty easily. Eurymachus throws a stool at Odysseus, while he observes the suitors behavior.
Odysseus and Telemachus remove the weapons from the hall. Nurse Eurycleia recognizes the disguised Odysseus by a scar on his foot, but he swears her to secrecy.
Theoclymenus foresees doom for the suitors, prophesying their impending death, but they mock him and dismiss his warning.
Penelope brings out Odysseus's great bow and announces a contest to win her hand. The suitors all fail to string the bow, Odysseus steps up, strings the bow and shoots the arrow through twelve axes heads and wins the contest.

Git: Keep two branches in sync

Mon, 15 Jun 2026 09:24:42 -0700

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.

Using rsync to keep two directories in sync

Wed, 20 May 2026 11:40:26 -0700

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.

Perl: ULID generation

Sun, 26 Apr 2026 18:58:48 -0700

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
		    $bytes .= pack 'C*', map { int(rand(256)) } 1 .. 10;
		
		    # base32 encoding
		    my $bits  = '00' . unpack('B*', $bytes);
		
		    # Chars to use for base32
		    my @CROCKFORD_CHARS = split(//, '0123456789ABCDEFGHJKMNPQRSTVWXYZ');
		
		    my $result  = '';
		    for (my $i = 0; $i < 130; $i += 5) {
		        my $index = oct('0b' . substr($bits, $i, 5));
		        $result .= $chars[$index];
		    }
		
		    return $result;
		}

See also: UUIDv7

Perl: Using Inline::C to embed C functions in your Perl scripts

Thu, 23 Apr 2026 14:34:43 -0700

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.

Comparison of markup languages

Thu, 09 Apr 2026 10:58:41 -0700

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.

Linux: SFTP and SCP friendly login banners

Thu, 26 Mar 2026 14:07:00 -0700

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.

YAML is growing on me

Wed, 25 Mar 2026 10:04:29 -0700

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:

Use Case	Recommended	Why
API request/response	JSON	Universal support, strict parsing
Configuration files	YAML	Comments, readability
Browser/JavaScript	JSON	Native parsing
Kubernetes/Docker	YAML	Industry standard
Data interchange	JSON	Unambiguous, fast
Human-edited files	YAML	Less punctuation

YAML spec differences.