Chameth.com - posts not monthly-meanderings-2026-01, tailscale-docker-gotcha, why-you-should-be-using-https

The Case of the Unchanging Config

2026-04-09T00:00:00Z

Last week I was attempting to make it so I could share pictures on IRC directly from my client. This sounds simple, but it involves a bouncer¹ that proxies the request to a standalone image hosting service that I had to modify to be compatible. At one point my testing loop was:

Make a change to the hosting service
Commit it
Tag a new release
Wait for it to build
Update the version I’m running on my server
Reconfigure the bouncer to pass the new parameter or change the URL or whatever
Try uploading a photo from my phone
Realise I’ve overlooked something and go back to step one

I could have set up a local copy of everything and tested it sensibly. I should have set up a local copy of everything and tested it sensibly. But it seemed like such a trivial change, and setting up the whole environment seemed like such a pain. After the third or so iteration of failure I was pretty annoyed with myself, computers, and basically everything.

My biggest annoyance was that my bouncer would not pick up the new URL from the config when I changed it. It’s meant to reload the config when it receives a SIGHUP, and it claimed to in the logs, but I could clearly see it was still hitting the old URL. Restarting the bouncer to update the config is a pain, as it disconnects me from all the IRC networks, and has to reconnect to them all, reauthenticate, etc. It also mildly spams everyone who shares a channel with me².

When I finally got everything working I had a look at the bouncer source, and thought I’d spotted the issue. I raised a bug report, ending in this remark:

It looks like the config is reloaded properly, but the handler for uploads is created once at startup and has its own copy of the uploader, so effectively snapshots the config to whatever it is at startup:

fileUploadHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    cfg := srv.Config()
    h := fileupload.Handler{
        Uploader:    cfg.FileUploader,
        DB:          db,
        Auth:        cfg.Auth,
        HTTPOrigins: cfg.HTTPOrigins,
    }
    h.ServeHTTP(w, r)
})

I’m not quite sure what I thought I saw there, but that’s not right. I want to call it a hallucination, but that feels like a very overloaded word these days. I guess I was just seeing what I wanted to see, and that was a good excuse to stop investigating. Still, even if I misidentified the cause, the bug was still present, right? … Right?

The Science of Deduction

When the developer got back and said he couldn’t reproduce my issue, I went back to my install and immediately reproduced it. With a calmer head, I figured it was probably something with my particular set up. First thing to check: am I actually running the version I think I am?

Unfortunately the bouncer doesn’t actually seem to expose the version anywhere that I can see. It’s not in the logs, it doesn’t have a -version flag, and none of the IRC-based status commands seem to include it. But I know it’s a Go app, and I know Go embeds the version information. go version -m <binary> will dump it all out, but the binary is inside a Docker image, and the Docker image is one of my nice, minimal, artisanal ones so doesn’t ship a go binary. No problem, docker compose cp bouncer:/bnc ./bnc yoinks the binary out of the container, and then dumping the version shows that, yes, I am running the version I thought I was. Hmm.

The next tool I reached for in my toolbox was strace. Maybe it’s not actually reading the file for some reason? I immediately executed strace -p <pid> -e trace=openat,open,read,pread64 -f without having to look any part of that up. Yep. Definitely. Then I edited the config, HUP’d the bouncer, and saw that it was… reading the config file. As it’s meant to. By default strace truncates strings to 32 bytes, so I couldn’t actually see the line I’d changed. Some more definitely-not-RTFMing later, and rerunning it with an extra -s 65536 let me see the full config. Surprise! The config hadn’t changed!

To confirm my findings, I used docker compose cp again, this time yoinking the config file from inside the container. The inside config file was definitely different to the outside config file. What? My hypothesis at this point was “something something Docker nonsense”. I mount the config as read-only, and was wondering if that meant that Docker was doing something weird instead of just bind mounting it. A quick trip to /proc/<pid>/mounts showed that it was, in fact, not doing anything weird, and was just bind mounting it.

If the file is bind mounted, then surely it’s the same file? I ran stat on the file on the host, noted the inode number, then pondered how to actually run stat on the file inside the container, given the aforementioned awkwardly minimal image. The solution was easy: access it via /proc/<pid>/root/. I could’ve saved myself a bunch of docker compose cp if I’d thought about that earlier. Oh well. The inode of that file was different. What?

The answer was DNS. It’s always DNS. Oh, sorry, force of habit. I meant the answer was vim. I was editing the config in vim, and when it saves files, by default, it writes the new content to a temporary file and does an atomic rename. That’s normally a good thing: it prevents corruption if the write fails midway through³. In this case, though, that means the new file has a new inode. Bind mounting a file binds to the inode, so the container just keeps clutching onto the original config from when it was started, blissfully unaware that the party has relocated down the street.

This problem is likely to happen whenever you bind mount a file into a container. When I mentioned this to a friend, he immediately responded “oh yeah, never do that”, and went on to describe the horrible hacks he’s had to add to Ansible to sidestep the issue. The nicer solution is to just bind mount an entire directory if you can, as then it doesn’t matter what happens to the files within it. I really like having the config files sat alongside the Docker compose files, though; having to create a directory just to work around some bind mount weirdness upsets me.

Now I knew what the problem was, I found there was an issue raised against Docker twelve years ago⁴. The first response was “that’s expected”, and I fully agree with the author: “respectfully, that might be expected by you, but it was not expected by me”!⁵ As a result of the issue they added a nice note to the docs:

Note: Many tools used to edit files including vi and sed --in-place may result in an inode change. Since Docker v1.1.0, this will produce an error such as “sed: cannot rename ./sedKdJ9Dy: Device or resource busy”. In the case where you want to edit the mounted file, it is often easiest to instead mount the parent directory.

But in the intervening twelve years, both the note and the functionality described have gone missing. Ho-hum.

I found it interesting how I’ve only just hit this problem, given how long I’ve used Docker. But I realised that almost everything I run I’m happy to just restart. Cattle, not pets, and so on. My IRC bouncer is one of the few exceptions to that. The only other thing I regularly hot reloaded was Centauri, my reverse proxy, but that had a whole config directory mounted because it was shared between containers, so nicely sidestepped the foot-gun.

So lesson learnt: check for weird bind mount issues before raising issues about config hot reloading. It’ll join the esteemed company of “maybe the drive is full and causing completely unrelated problems?”, “perhaps everything is dog slow because the kernel ran out of entropy?”, and “did systemd sneakily take over that functionality while you weren’t looking?” in the troubleshooting checklist.

An IRC bouncer is basically an always-on proxy. It connects to the IRC networks for you, then your clients connect to your bouncer. The bouncer can then send incoming messages to all your different clients, cache them when you’re offline and replay them later, and lots of other nice things people take for granted in their chat apps these days. ↩︎
Join/part/quit spam is part of IRC, and clients have ways of handling it, but I still feel bad about doing it excessively. ↩︎
You can disable this in vim by setting backupcopy=yes. Good luck redoing all the debugging if you ever accidentally remove that from your vimrc, though! ↩︎
Which is weird, because Docker can’t possibly be that old. That would make me much older than I’m prepared to accept. ↩︎
If you read the thread they didn’t actually mean to sound so dismissive, but it’s still pretty funny. “Yes, it’s expected that the foot-gun causes your foot to hurt. Duh. What did you expect?” ↩︎

Modern CSS is fun

2026-03-17T00:00:00Z

I’ve been doing a bunch of CSS tweaking recently, and keep being surprised by how nice modern CSS is to work with. As someone grey-haired enough to remember writing HTML without CSS, it’s amazing to think how far along web technology has come¹. I wanted to demonstrate some of the handy bits and pieces I’ve used recently.

:has

The :has selector allows you to effectively query for child elements. While a span will match a <span> within an <a>, a:has(span) will match an <a> that contains a <span>. This really shines when combined with more complex selectors, for example:

input {
    border-radius: var(--border-radius);

    &:has(+ .results:not(:empty)) {
        border-bottom-left-radius: 0;
        border-bottom-right-radius: 0;
    }
}

This is part of the styling for my film search box. When the search box is presented initially it has fully rounded corners. But when it is followed by a non-empty results element, it removes the rounding on the bottom corners so that the border continues in a straight line down into the results. You can see it in action below; just enter a few characters (like “the”) to get some results:

You could achieve the same effect by having JavaScript add a class to the <input> element, but I’ll take a CSS solution over a JavaScript solution any day.

Nested rules

You probably spotted this in the example above. It’s what finally made me switch from SCSS to plain CSS. If you have a rule for .foo and a rule for .foo .bar you can just nest them. Not only does it save repeating yourself an awful lot, it keeps everything organised nicely. For example, the CSS for my film list embeds looks like this:

a.film-list {
    display: grid;
    grid-template-areas: "header images" "description images" "meta images";
    grid-template-columns: 1fr auto;
    grid-template-rows: auto 1fr auto;
    row-gap: var(--small-space);

    @media (width <= 800px) {
        grid-template-areas: "header" "description" "images" "meta";
        grid-template-columns: 1fr;
        grid-template-rows: auto auto auto auto;
    }

    & + & {
        margin-top: var(--medium-space);
    }

    h3 {
        font-size: var(--font-size-xxlarge);
    }

    .description {
        /* ... */
    }
}

Everything is wrapped up in a single bundle, including the @media rules for changing the layout on smaller screens, the lovely little & + & rule that adds some extra margin if there are two lists in a row, etc. The & syntax refers to the parent selector, so & + & in this case is the same as a.film-list + a.film-list: it’s very handy! The best part about this is that it’s the exact same syntax as SCSS, so converting is easy². The styled element looks like this:

Watched films ranked

Every film I’ve watched since I started logging, ranked.

Obviously super subjective, and subject to change often and arbitrarily.

264 films

Media range syntax

Once again, you might have spotted this in the previous snippet. I’m not deliberately teasing things, I promise! Back in the day, you did media queries like so:

@media (min-width: 1000px) and (max-width: 2000px) {
    /* some rules that work for screens at least 1000px wide and at most 2000px wide */
}

I always hated this syntax. I always got muddled up as to whether I wanted “min” or “max”, and whether they were inclusive or not. It’s easy to reason through, but it never came naturally. Fortunately you can now just use ranges:

@media (1000px <= width <= 2000px) {
    /* some rules that work for screens at least 1000px wide and at most 2000px wide */
}

I find this style so much easier to write and understand.

Anchor positioning

Trying to dynamically position one element next to another used to exclusively fall within the purview of JavaScript. Fortunately anchor positioning fixes all this. I use this in the film search field I showed above:

.film-search {
    input {
        anchor-name: --film-search-box;
    }
    .results {
        position: absolute;
        position-anchor: --film-search-box;
        position-area: bottom center;
        position-visibility: always;
        width: anchor-size();
    }
}

This does lots of fun things. The .results element is anchored to the input field (via the --film-search-box name), and it’s positioned on the bottom, directly under the anchor. The position-area rule describes a 3x3 grid, with the anchor at the center, so top left would put it diagonally adjacent to the anchor. Next, position-visibility keeps the .results element visible when the anchor isn’t; otherwise when you scroll the anchor off the screen the results would immediately vanish. Finally, the special anchor-size() function makes the .results element take up the same exact width as the anchor.

All-in-all, this puts the results exactly where I want them, without having to deal with any JavaScript at all. I can see how it’d also be amazingly useful trying to do tooltips or other forms of ‘floating’ content too. You can even leave the positioning up to the browser, giving it hints about which order to try, or what property to optimise for (e.g. you can say “anchor to the left or right, whichever has more horizontal space”).

attr() function

This one blew my mind a little. In some of the elements on the site, I’ve added a little label to the top. It looks something like this:

It’s meant to just be a visual flourish, not a semantic title or anything, so I initially just added a ::before selector to each element, customising the content to have the right value. I didn’t like the duplication, though. Now, instead, I do this:

&::before {
    content: attr(data-title);
}

Each component defines its title in a data attribute: <div class="raised-box" data-title="an example">, and the attr function plucks it out and puts it in the content rule. It’s worth noting that this is only widely supported for the content rule, you can’t yet use it for colours or dimensions or other things. It still feels a bit magical, though. Like you’re making a reusable, customisable component with just HTML and CSS.

layers

I’d come across layers a few times, but I never found a need for them. It seemed like something you’d only really need with complicated design systems, or something. Then I had a problem and layers were the perfect solution!

The headings on this site have a whole bunch of CSS attached to them. Currently they look a bit like blue painter’s tape with handwriting on them. This style is applied to all headers, and then the various places that don’t want it had to manually reset everything. I got fed up with that, so decided to add a plain-header class which would “disable” the extra styling:

h2,
h3,
h4,
h5,
h6 {
    /* common styles for all headers, regardless */
    font-family: "Chris Hand", sans-serif;
    font-size: var(--font-size-xxlarge);
    color: var(--text-highlight-colour);
    margin: var(--medium-space) 0;
    line-height: 1;

    &:not(.plain-header) {
        /* do fancy stuff if it _doesn't_ have the .plain-header class */
        transform: rotate(-0.15deg);
        padding: var(--smedium-space);
        font-weight: 800;
        filter: drop-shadow(3px 3px 5px rgb(0, 0, 0));

        a {
            background: none;
            text-decoration-skip-ink: auto;
        }
    }
}

This might seem a bit backwards but I want the default to be styled, as those are far more common. I added this change, sprinkled around some “plain-header” classes, tidied up a lot of duplicate CSS, and things mostly worked. Mostly. Some things stopped working. In a few places the headers had slight tweaks, and they stopped working entirely.

It turns out in moving the rules from a plain h2 selector to a h2:not(.plain-header), I’d made them more specific. Previously a selector like h2.special would have been more specific, so its properties would override those from the less specific h2 selector. My first reaction was to try and hack around it. Changing all the overrides to body h2.special would make them more specific again, but I didn’t want to have to remember to do that forever more.

Instead, I defined some custom layers, and put the header definitions in one:

@layer reset, links, headings

@layer headings {
    h2,
    h3 {
        /* etc */
    }
}

The first @layer rule defines some layers that will be handled in a specific order: first the “reset” layer, then the “links” layer, then the “headings” layer, and then anything not in a layer after that. Rules in one layer don’t have to worry about beating the specificity of rules in another layer, because they’re handled separately.

Note that I couldn’t just put the headings in a layer and call it a day: their rules have to come after the CSS reset, and after the normal link styles, as headers have a bit of extra styling for nested links. If the CSS reset weren’t in a layer, then the * { margin: 0; padding: 0; } type reset would apply over the rules from the headings layer.

Using layers is definitely a bit fiddly, and is not necessary for a lot of sites, but it’s a much cleaner alternative to ugly specificity hacking.

Things I’m looking forward to

There are a few things that aren’t (widely) available yet, that particularly interest me:

sibling-index() and sibling-count()

These new functions are available in WebKit and Blink based browsers, but not Firefox. They give you the index of the element within its siblings, or the count of siblings. For the film list component above, I currently have this abomination for the overlapping posters:

&:nth-child(1) {
    z-index: 5;
    left: 0;
}
&:nth-child(2) {
    z-index: 4;
    left: calc(133px * var(--overlap) * 1);
}
&:nth-child(3) {
    z-index: 3;
    left: calc(133px * var(--overlap) * 2);
}
&:nth-child(4) {
    z-index: 2;
    left: calc(133px * var(--overlap) * 3);
}
&:nth-child(5) {
    z-index: 1;
    left: calc(133px * var(--overlap) * 4);
}

These could be replaced with something like:

z-index: calc(1 + sibling-count() - sibling-index());
left: calc(133px * var(--overlap) * (sibling-index() - 1));

As an added bonus, it would scale to any number of posters. index being 1-based not 0-based is a bit unfortunate as it makes using it in calculations awkward (see 1 offset in both of those rules!), but it’s leagues better than writing 5 separate rules.

random()

Currently only available in Safari. There are a few places where I’d like to have slight random variations of the style. Things like elements that are rotated slightly for aesthetics; they look a bit silly if they’re all identically positioned. I also randomise the icons and positions of my rating stars to break up the visual monotony. Here are a few examples:

Currently I do the stars by hardcoding a bunch of classes and having the backend randomly apply one when it generates the markup for stars. Being able to do it in CSS would be great, though.

Mixins

This one’s so far off it’s not even listed on caniuse.com yet. Mixins are another handy feature of SCSS, that allow you to define reusable blocks of rules, then import them when needed:

@mixin fancy-background {
    background: /*...*/;
}

.some-element {
    @include fancy-background;
}

#other-element {
    @include fancy-background;
}

This would be particularly useful if you can’t easily control the markup to add classes to everything. For example, my footnotes are rendered by a markdown plugin, and don’t easily have a way to add extra classes to them. To style it the same as another element, I currently duplicate a bunch of rules between them both. Mixins would allow me to define those rules once, and then import them in both places.

Aside from JavaScript, which seems to just endlessly reinvent new frameworks and ways to make the most sprawling dependency tree possible. ↩︎
It also means that if your website’s syntax highlighting library doesn’t seem to understand nested rules, you can just pretend your perfectly valid CSS is actually SCSS and it’ll magically work. Grumble, grumble. ↩︎

The longest way to represent a date

2026-03-14T00:00:00Z

The other day, someone on IRC posed this question: “What is the longest way to represent a date using any means possible that isn’t just repeated filler?”

Some people jumped for writing the date out in languages that had longer translations. My immediate reaction was instead to suggest an obnoxious string-based representation of a unix timestamp: “one second after one second after one second after … midnight on January 1st 1970”. It’s very repetitive, but it’s not filler: taking out any of the repetitions would change the value. Effectively it’s a successor function for unix timestamps, writ long. Some quick napkin maths suggests the full string representation would be around 30GiB¹.

An obvious approach to make it bigger is to make it more precise. If we do the same sort of successor function for milliseconds it’d be a bit over 1000x longer². It actually ends up being just over 35TiB³.

There’s no reason to stop there, though. You can step down to microseconds, nanoseconds, and so on… or… we can just skip right to the end. How about: “one oscillation of the caesium-133 hyperfine transition frequency after one oscillation of the caesium-133 hyperfine transition frequency after … midnight on January 1st 1970”? There are over 9 billion of those every second, and the phrasing is wordy. That comes out to almost 1ZiB⁴. If we pooled all the data storage on the planet together we could save a couple hundred of these timestamps.

One final step, then: why use the unix epoch when we could use the universe’s own⁵? We’re something around 4×10^17 seconds past the big bang, so… hold on, I need to look up some units… that’d be over 200,000 yobibytes⁶. There’s not actually a standard prefix for that order of magnitude, according to Wikipedia. I think it should be 200 robibytes. Does anyone have a contact at the IEC?

That is a big number. Is it impossibly big? If we wanted to track our current time, we’d need to write around 600GiB/s⁷ to disk. That’s a bit more than we can manage at the minute, but isn’t completely outrageous. What about storage? Apparently hard drives require around a million atoms to store a bit of data. There’s some research showing it’s possible to use as few as 12, but I don’t think it’s anything that can be used at scale anytime soon⁸. So just for the direct data storage, not counting all the other infrastructure you need for a disk drive to work we’d need around 10^36 atoms. If we sourced our atoms for our local paperclip maximiser we’d need around 200 trillion paperclips. For just one timestamp.

On the plus side, this timestamp format would compress wonderfully.

17 bytes of repetition * 1773528583 seconds ~= 3×10^10. ↩︎
There’d be a thousand times more repetitions, and each one would have the extra five bytes from the “milli” prefix. ↩︎
22 bytes of repetition * 1773528583000 milliseconds ~= 3×10^13. ↩︎
72 bytes of repetition * 1773528583 seconds * 9192631770 oscillations per second ~= 1×10^21. ↩︎
Other than it being impractical, not known to a decent accuracy, and the myriad other problems, of course. ↩︎
72 bytes of repetition * 4×10^17 seconds * 9192631770 oscillations per second ~= 3×10^29. ↩︎
72 bytes of repetition * 9192631770 oscillations per second ~= 6×10^11. ↩︎
Not that we could scale conventional drives up this much, either. ↩︎

Surge protectors: marketing vs reality

2026-01-24T00:00:00Z

A while back I went down a deep rabbit hole looking into surge protectors, and what all the different numbers mean, and how that affects things in case of a voltage spike. Then I didn’t really do anything with the information, other than bore a few friends, and look around in despair at all the shockingly bad products out there. Time to fix that!

I’m coming at this from the angle of a computer user in a country with very good electrical regulations. If you’re protecting something else, or live somewhere that doesn’t believe in grounding things, your mileage may vary.

Building a better mental model

I think when most of us think of surge protectors, we think of an extension lead with some magical property that stops surges and protects everything plugged into them. It’s a bit like the shield on the USS Enterprise. If we put the shields up in time, they’ll stop everything thrown at them, until at some point they’re overloaded and stop working. Only then will we have problems. There’s even a little LED that goes out when she cannae take it any more, cap’n.

Of course, if that was actually the case, I wouldn’t be writing a blog post. Surge protectors are more like the crumple zone on a car. If you hit something, the crumple zone will absorb some of the impact, but you can quite easily still get injured. If the impact is big enough then the crumple zone will bleed some energy, but you’re still going to have a very bad time. My point here is that it’s not a perfect shield, can be overcome with a single excessive impact, and doesn’t magically recharge back to full strength.

The numbers, Mason! What do they mean?

To understand what protection these things really offer, we need to look at a couple of numbers. Unfortunately, they’re not the numbers that are displayed in the marketing. Sometimes they’re not even on the spec sheet. Most of the time they’re on the actual device, and if they’re not then it’s safe to just assume things are bad.

The most important number is the let-through voltage, U_p. It may also be called the clamping voltage, the voltage protection rating, or the VPR. This is the voltage that will be let through, before the surge protector does anything¹. We use 230V mains, with a +10%/-6% tolerance. So we shouldn’t be seeing anything above 253V. If you were designing a surge protector, you’d want it to engage a little above this, right? Maybe call it 300V so it doesn’t cut in prematurely? If you have a surge protector nearby, I invite you to try and find its U_p value. If you don’t have one, you can follow along with mine:

A not-very-good surge protector. Please take a moment to consider how difficult it was to make this text readable.

Yes, that’s 1,500 Volts. Up until that point the surge protector does nothing. Your computer’s power supply just has to deal with it. That’s not even the highest I’ve seen, either. It’s just the closest I had to hand.

So what are the other numbers? U_c is the maximum continuous operating voltage. That’s probably fine — in the worst case it’ll slowly degrade over time if the mains rides the 253V edge — but at the same time, would you not spec it for 275V or more given that? For the most part, we don’t really care about this, though. If the surge protector has the right kind of plug on it, then it’s probably got a U_c in the right ballpark.

Then we have U_oc, which is the open circuit voltage. This is one of the numbers that might end up on the marketing, because it can be big! This is the surge voltage that the device can sustain without failing itself. So for this surge protector, it won’t do anything for surges up to 1.5kV, between 1.5kV and 4kV it will clamp the voltage, and above 4kV it might fail in some manner. That failure could be failing open and leaving your computer to deal with the rest of the surge (the little LED would go out, though!).

The number not on the device that’s on all the marketing materials is the “Joule rating”. That’s how much energy the thing can absorb before it fails. That can be gradually drained by small surges over time, or by a big one. Something in the realm of 1kJ seems to be a “good” value, but what does it actually mean? Say we had a surge of 1.5kV, our 1kJ of protection would cover 0.66 Amp seconds. Surges are typically very short; let’s say one lasts 2µs. That energy budget would allow for 333kA of current to be handled! That’s an order of magnitude more than a lightning strike! Amazing! Except… There’s also a maximum surge current rating, and I guarantee it’s less than that. The actual number on the Joule rating is basically useless given all the other constraints, but the bigger the number the more hardy the protector will be, in general.

Oh, one more thing on that Joule rating. Sometimes surge protectors will have multiple different protection devices inside, especially when they protect other connectors like coax or telephone cables. Sometimes the Joule rating will just be the sum of all the individual protectors, so is even more useless. Yay marketing.

How much abuse can a PSU take, anyway?

OK, so it turns out surge protectors are… underwhelming, shall we say? If there’s a surge, your computer is going to be involved. So what can PSUs actually deal with?

Turns out modern PSUs have surge protection built-in, along with all sorts of other “why is the electricity not electricitying right?” safeguards. I can’t find a single manufacturer that actually puts any numbers to that, though.

If you were to open one up and look inside, you’d see something like this:

I spy with my little eye… something beginning with MOV!

That little thing hidden in heatshrink is a MOV, or Metal Oxide Varistor. Also known as a Zinc-Oxide Non-liner Resistor, or ZNR, as it’s labelled in the picture. It’s basically a resistor that varies its resistance based on the voltage. So it can have a high resistance at low voltages, and then after, say, 300V it could start dropping off. Can you guess what component is inside basically all consumer surge protectors? Yeah, these things! So, as mentioned, I don’t have numbers to back this up but I’m going to go out on a limb and say that the MOV in a £130 PSU can probably handle at least the same as the MOVs in a £7 surge protector.

It’s hard to imagine a situation where there’s a surge that would have destroyed the PSU that would be mitigated by an external surge protector. It’s probably either going to take both of them out, or they’ll both survive. No Enterprise shields here, I’m afraid.

So is it not worth having a surge protector at all? Not quite. MOVs degrade with use, so if a surge protector handles some smaller surges, or takes bites out of bigger ones, it might prolong the life of the PSU. Maybe that’s worth it, especially if you find one of the (increasingly rare) ones with a decently low clamping voltage.

Addendum: covered equipment warranties and magic smoke

A bunch of surge protectors come with a warranty for downstream equipment. That sounds like a great deal, right? Even if there’s a huge surge that the protector can’t handle, at least you can replace the equipment? Alas, no. These warranties only cover if the surge protector doesn’t operate within its specifications. If you go over the max voltage, or the max current, or the max energy and all your equipment blows up, then the surge protector is merely working as designed. It’s meant to fail in those circumstances, and at that point all bets are off. No warranty money for you.

The other thing to bear in mind is that — in the UK at least — significant power surges aren’t common at all. If you travel with your computer then you’re more likely to come across dodgy electrics that can fry your computer than you are to hit a power surge. I’ve been to a lot of LAN events and have never heard of a surge protector popping and saving a computer; on the other hand I have seen an entire row of computers release their magic smoke because the electrician hadn’t connected the three-phase supply properly. There’s absolutely no protection to be had from that!

Photo credit: thanks to Greg for supplying the picture of the PSU so I didn’t have to take my computer apart.

Well, actually, it does a tiny bit before U_p because it’s not a binary switch, and life is messy. It won’t do much of anything before U_p. ↩︎

The meaning of life

2026-01-18T00:00:00Z

Now that’s a grandiose title for a blog post! Blame Jeremiah Lee, who selected it as the theme for January’s IndieWeb Carnival. I’ve not taken part in this before, but it’s basically a shared writing prompt. One person selects a theme, other people write about it on their own sites, and then the host does a round-up linking to all the various responses. I’ve come across it a few times before, but the topics have never really engaged me; they don’t feel like the sort of thing I’d write about. But… why not?

A Guide to the Good Life

The thing that actually tipped the scales for this particular topic was a book I was reading: A Guide to the Good Life by William B. Irvine. It’s basically a modern introduction to Stoicism. Not only is there a strong overlap between that and the meaning of life, one particular idea resonated with me:

In ancient Greece, when schools of philosophy were still prominent features of the cultural landscape, there were any number of schools to which parents could send their children. Suppose we could travel back in time to 300 bc and take a thinking person’s walking tour of Athens. We could begin our tour in the Agora, where Socrates a century earlier had philosophized with the citizens of Athens. On the northern side of the Agora we would see the Stoa Poikile, or Painted Porch, and holding forth there might be Zeno of Citium, the founder of the Stoic school of philosophy. This “porch” was actually a colonnade decorated with murals.

The idea that you could just wander around a city and come across people giving their considered opinions on philosophy is… something. Do we have any actual equivalent of that in the modern ages? Obviously you do get people espousing their views on the street, but they tend to either be proselytising or grinding a particular axe. And even if there was a modern day Socrates talking in Speaker’s Corner, would anyone actually stop to listen? We do have books, and speaking engagements, and so on, but they feel a lot more impersonal, and in a lot of cases motivated by money or politics or some other agenda. The philosophers of ancient Greek and Rome seemed to actually practice what they preached; as well as talking in public, and instructing in their schools, they’d write letters helping and advising people, or debating points of philosophy.

Some of that behaviour exists in academia, I’m sure, but it’s not really accessible to the person on the street in the way that it once was. But we do have personal websites and blogs. People just exchanging ideas, speaking out in public, with (generally) no expectation of reward or recognition for it. Is the “IndieWeb” the modern Agora? Probably not, but maybe it gives us some aspects of it that we otherwise wouldn’t have?

The Stoic approach to life

The Stoics believed in living a virtuous life; living as we were designed to live, in accordance with nature. A lot of those terms might be a bit loaded to the modern ear, and “designed to live” is awfully vague. I think this quote expands on it pretty well, though:

And for what function were people designed? To answer this question, the Stoics thought, we need only examine ourselves. On doing this, we will discover that we have certain instincts, as do all animals. We experience hunger; this is nature’s way of getting us to nourish ourselves. We also experience lust; this is nature’s way of getting us to reproduce. But we differ from other animals in one important respect: We have the ability to reason. From this we can conclude, Zeno would assert, that we were designed to be reasonable.

And if we use our reason, we will further conclude that we were designed to do certain things, that we have certain duties. Most significantly, since nature intended us to be social creatures, we have duties to our fellow men. We should, for example, honor our parents, be agreeable to our friends, and be concerned with the interests of our countrymen.

It all seems eminently reasonable. But in a world of fake news, social media, culture wars, and everything else, our ability to reason often seems forgotten. Hell, even being agreeable seems like it’s out of vogue at the moment. Would the Stoics despair if you transported one of them to the present day? Probably not. One of the other tenets they held was, well, being stoic. There was a concept of tranquility:

Stoic tranquility was a psychological state marked by the absence of negative emotions, such as grief, anger, and anxiety, and the presence of positive emotions, such as joy.

To get to this magical state, you need a form of detachment. Not in the sense of being completely passive and impartial as you float through life; that’s not how we’re “designed to life”. But in the sense of not letting outside events influence your inner state. When someone says something horrible, they don’t have the power to actually make you feel bad; that’s something you do. And I fully accept that it’s very easy to say that, and very hard to actually practice it.

This is actually a concept shared with many other religions and philosophies. Buddhism has the idea of Nekkhamma, Jainism and Hinduism have Vairāgya, and so on. Even if you don’t put any stock at all into religious teachings, it’s interesting that this concept comes up again and again.

If you’re like me, you probably have thoughts on all this. Sure, anxiety-free, anger-free life is probably nice, but how does that relate to the meaning of life and, anyway, shouldn’t you be angry about some things? The Stoics (particularly the Roman ones, who tended to not be so into physics and ethics) believed that this tranquility made it easier to focus on being virtuous. That makes sense to me; if we manage to get off the hedonistic treadmill of wanting shiny new things, of hoping people like our posts, and so on, then there’s surely more time in life for other pursuits. As for anger, I think the point is you don’t let the emotions drive your behaviour. There’s a difference between getting angry at what someone is saying and punching them in the face, and hearing someone, calmly and rationally assessing matters, and then punching them in the face. Maybe it’s best for society to punch certain people in the face. The Stoics were certainly not pacifists. Marcus Aurelius is one of the most well known, and he was Emperor of Rome. He’s hailed as one of the few good emperors, but you can bet he had an awful lot of blood on his hands even so.

Putting it into practice

It’s all well and good going on about not letting things bother you, but it’s very much easier said than done. The book introduces the concept of “negative visualisation”: imagining the negative things that could happen in your life, and thus starting to accept them. It also helps you to appreciate things that you do have, that you otherwise taken for granted. I’m sure everyone’s imagined what would happen if you lost your home, or your job, or so on… but what if you didn’t have your favourite mug? A particular tool? A certain piece of art?

I’ve heard of gratitude journals before. I’ve even tried keeping one for a while. There’s science showing it’s beneficial for mental health. But I always faded off after a short while. Once you tick off the big things: friends, family, food, etc, it feels like a stretch. Negative visualisation feels like a much better approach to me. I’m about to eat an apple; at the end of the day I’m not going to think back and write about an apple in a gratitude journal. But I can think briefly, in the moment, about not having the apple. Do I need to prepare myself for an apple-less life? Not really. But do I now appreciate the apple a little bit more, and take it for granted a little bit less? Yes. Does that make me a bit more tranquil? A bit less likely to wish I had something tastier than an apple? Also yes.

This process dovetails into the concept of impermanence, another concept found in Buddhism and elsewhere. Each apple could be the last one you ever have. If you knew that in advance, how would it change your approach? You’d probably savour it a bit more, appreciate it a bit more, and most of all not take it for granted. There’s a lot of pithy sayings about treating each day as if it’s your last, but at that level they’re a lot more nebulous than helpful; appreciating an apple, though? That’s something I can do.

It seems at first glance that thinking about negatives should be depressing or anxiety inducing. There are only so many reasons that this could be my last apple, and most of them involve something pretty unideal happening to me. But I don’t think it’s actually that glum. You don’t dwell on the negative, instead you use it to inspire a positive. And the alternative is to just sleepwalk through the process, not really paying attention, not gaining any enjoyment from it.

Bringing it back

Thanks for sticking with me on that tangent. You’ll be glad to know I’ve finished eating my apple now. The topic for this post was meant to be “the meaning of life”, not “thoughts on eating apples” or “living a Stoic life”, so allow me to try to tie it all together and pretend that I had a plan.

Life has no inherent meaning, it’s just a biological process. But that doesn’t mean we can’t seek to have a meaningful existence. The Stoics believed that involved being reasonable, and one of the approaches to give the reasoning room to happen is to strive towards an inner state of tranquility.

Obviously the Stoic approach isn’t the only one. And I’m not sure I did their philosophies any justice in my writing here. If it sparked your interest, though, I highly recommend picking up the book. If not, other approaches to life are available…

Be excellent to each other… and party on, dudes.