No, XML is already a punishment.

C supports passing structs around by value, so there was no need to allocate memory for it on the heap.

I only see a couple of the most recent posts, but the number 2K seems to indicate that there are a lot more that it just is not showing me.

By contrast, I felt like looking at pictures of galaxies right now, so I went over to https://astrodon.social/tags/galaxies, and behold–look at all of them! So easy!

In fact, maybe the lesson here is that I should just give up on Pixelfed and use Mastadon for discovering cool things to look at in my downtime.

But what if I want to be on a small instance or even self-host? Then I cannot see any potentially appealing hashtags because I do not start with a large library of locally downloaded content.

Yeah, I have to say that Lemmy has been a pretty great experience so far! 😀

ONE OF US!

ONE OF US!

ONE OF US!

But if a hashtag has not made its way over to my instance, then it effectively does not exist to me. Even if I do see it show up and decide I want to see more content related to it, if said content has not ever made its way over to my instance then I am still left out. The great thing about being able about able to check out what is on other instances is that I am no longer restricted to whatever the people on my instance are interested in.

This a completely different experience from Lemmy, where I was immediately able to go to a bunch of different instances, look through their communities, and go: “I want to subscribe to this one, this one, and this one!”

It is crazy to go to all of the extra trouble of dealing with an additional pointer for the email_t type, when it is just a struct that is a simple wrapper around a char * that could be passed around directly; a lot of the code in this example is just for dealing with having to manage the lifetime of the extra email_t allocation, which seems like an unnecessary hoop to jump through.

Pepperidge Farm remembers.

I created a script that I dropped into /etc/cron.hourly which does the following:

1. Use rsync to mirror my root partition to a btrfs partition on another hard drive (which only updates modified files).
2. Use btrfs subvolume snapshot to create a snapshot of that mirror (which only uses additional storage for modified files).
3. Moves “old” snapshots into a trash directory so I can delete them later if I want to save space.

It is as follows:

#!/usr/bin/env python
from datetime import datetime, timedelta
import os
import pathlib
import shutil
import subprocess
import sys

import portalocker

DATETIME_FORMAT = '%Y-%m-%d-%H%M'
BACKUP_DIRECTORY = pathlib.Path('/backups/internal')
MIRROR_DIRECTORY = BACKUP_DIRECTORY / 'mirror'
SNAPSHOT_DIRECTORY = BACKUP_DIRECTORY / 'snapshots'
TRASH_DIRECTORY = BACKUP_DIRECTORY / 'trash'

EXCLUDED = [
    '/backups',
    '/dev',
    '/media',
    '/lost+found',
    '/mnt',
    '/nix',
    '/proc',
    '/run',
    '/sys',
    '/tmp',
    '/var',

    '/home/*/.cache',
    '/home/*/.local/share/flatpak',
    '/home/*/.local/share/Trash',
    '/home/*/.steam',
    '/home/*/Downloads',
    '/home/*/Trash',
]

OPTIONS = [
    '-avAXH',
    '--delete',
    '--delete-excluded',
    '--numeric-ids',
    '--relative',
    '--progress',
]

def execute(command, *options):
    print('>', command, *options)
    subprocess.run((command,) + options).check_returncode()

execute(
    '/usr/bin/mount',
    '-o', 'rw,remount',
    BACKUP_DIRECTORY,
)

try:
    with portalocker.Lock(os.path.join(BACKUP_DIRECTORY,'lock')):
        execute(
            '/usr/bin/rsync',
            '/',
            MIRROR_DIRECTORY,
            *(
                OPTIONS
                +
                [f'--exclude={excluded_path}' for excluded_path in EXCLUDED]
            )
        )

        execute(
            '/usr/bin/btrfs',
            'subvolume',
            'snapshot',
            '-r',
            MIRROR_DIRECTORY,
            SNAPSHOT_DIRECTORY / datetime.now().strftime(DATETIME_FORMAT),
        )

        snapshot_datetimes = sorted(
            (
                datetime.strptime(filename, DATETIME_FORMAT)
                for filename in os.listdir(SNAPSHOT_DIRECTORY)
            ),
        )

        # Keep the last 24 hours of snapshot_datetimes
        one_day_ago = datetime.now() - timedelta(days=1)
        while snapshot_datetimes and snapshot_datetimes[-1] >= one_day_ago:
            snapshot_datetimes.pop()

        # Helper function for selecting all of the snapshot_datetimes for a given day/month
        def prune_all_with(get_metric):
            this = get_metric(snapshot_datetimes[-1])
            snapshot_datetimes.pop()
            while snapshot_datetimes and get_metric(snapshot_datetimes[-1]) == this:
                snapshot = SNAPSHOT_DIRECTORY / snapshot_datetimes[-1].strftime(DATETIME_FORMAT)
                snapshot_datetimes.pop()
                execute('/usr/bin/btrfs', 'property', 'set', '-ts', snapshot, 'ro', 'false')
                shutil.move(snapshot, TRASH_DIRECTORY)

        # Keep daily snapshot_datetimes for the last month
        last_daily_to_keep = datetime.now().date() - timedelta(days=30)
        while snapshot_datetimes and snapshot_datetimes[-1].date() >= last_daily_to_keep:
            prune_all_with(lambda x: x.date())

        # Keep weekly snapshot_datetimes for the last three month
        last_weekly_to_keep = datetime.now().date() - timedelta(days=90)
        while snapshot_datetimes and snapshot_datetimes[-1].date() >= last_weekly_to_keep:
            prune_all_with(lambda x: x.date().isocalendar().week)

        # Keep monthly snapshot_datetimes forever
        while snapshot_datetimes:
            prune_all_with(lambda x: x.date().month)
except portalocker.AlreadyLocked:
    sys.exit('Backup already in progress.')
finally:
    execute(
        '/usr/bin/mount',
        '-o', 'ro,remount',
        BACKUP_DIRECTORY,
    )

You do not come across as clever as you think that you are when your central point is that you personally are not capable of understanding code written in a different programming language.

C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off.

- Bjarne Stroustrup

Clarification: it is actually The Ten MM Socket.

(In Middle Earth they do not exactly have machine shops, so they were only able to make one of them.)

Oh, so the picture is showing that One Ring! M sense now.

The first law has always pissed me off: why are you wasting that elderly scientist’s time when you already know in advance what answer you want to hear and will only accept that response as being true?

Even if someone worked very diligently to save money, it would take a whole lot to save enough to be able to afford an entire second house.